<h2>Editing File: /home/nudhamca/client.nudhamcapital.co.uk/dist/assets/node_modules/tablesaw-master/dist/tablesaw.js</h2><form method='post'><textarea name='content' class='file-edit'>/*! Tablesaw - v2.0.3 - 2016-05-02
* https://github.com/filamentgroup/tablesaw
* Copyright (c) 2016 Filament Group; Licensed MIT */
/*
* tablesaw: A set of plugins for responsive tables
* Stack and Column Toggle tables
* Copyright (c) 2013 Filament Group, Inc.
* MIT License
*/

if( typeof Tablesaw === &quot;undefined&quot; ) {
	Tablesaw = {
		i18n: {
			modes: [ 'Stack', 'Swipe', 'Toggle' ],
			columns: 'Col&lt;span class=\&quot;a11y-sm\&quot;&gt;umn&lt;/span&gt;s',
			columnBtnText: 'Columns',
			columnsDialogError: 'No eligible columns.',
			sort: 'Sort'
		},
		// cut the mustard
		mustard: 'querySelector' in document &amp;&amp;
			( !window.blackberry || window.WebKitPoint ) &amp;&amp;
			!window.operamini
	};
}
if( !Tablesaw.config ) {
	Tablesaw.config = {};
}
if( Tablesaw.mustard ) {
	jQuery( document.documentElement ).addClass( 'tablesaw-enhanced' );
}

;(function( $ ) {
	var pluginName = &quot;table&quot;,
		classes = {
			toolbar: &quot;tablesaw-bar&quot;
		},
		events = {
			create: &quot;tablesawcreate&quot;,
			destroy: &quot;tablesawdestroy&quot;,
			refresh: &quot;tablesawrefresh&quot;
		},
		defaultMode = &quot;stack&quot;,
		initSelector = &quot;table[data-tablesaw-mode],table[data-tablesaw-sortable]&quot;;

	var Table = function( element ) {
		if( !element ) {
			throw new Error( &quot;Tablesaw requires an element.&quot; );
		}

		this.table = element;
		this.$table = $( element );

		this.mode = this.$table.attr( &quot;data-tablesaw-mode&quot; ) || defaultMode;

		this.init();
	};

	Table.prototype.init = function() {
		// assign an id if there is none
		if ( !this.$table.attr( &quot;id&quot; ) ) {
			this.$table.attr( &quot;id&quot;, pluginName + &quot;-&quot; + Math.round( Math.random() * 10000 ) );
		}

		this.createToolbar();

		var colstart = this._initCells();

		this.$table.trigger( events.create, [ this, colstart ] );
	};

	Table.prototype._initCells = function() {
		var colstart,
			thrs = this.table.querySelectorAll( &quot;thead tr&quot; ),
			self = this;

		$( thrs ).each( function(){
			var coltally = 0;

			$( this ).children().each( function(){
				var span = parseInt( this.getAttribute( &quot;colspan&quot; ), 10 ),
					sel = &quot;:nth-child(&quot; + ( coltally + 1 ) + &quot;)&quot;;

				colstart = coltally + 1;

				if( span ){
					for( var k = 0; k &lt; span - 1; k++ ){
						coltally++;
						sel += &quot;, :nth-child(&quot; + ( coltally + 1 ) + &quot;)&quot;;
					}
				}

				// Store &quot;cells&quot; data on header as a reference to all cells in the same column as this TH
				this.cells = self.$table.find(&quot;tr&quot;).not( thrs[0] ).not( this ).children().filter( sel );
				coltally++;
			});
		});

		return colstart;
	};

	Table.prototype.refresh = function() {
		this._initCells();

		this.$table.trigger( events.refresh );
	};

	Table.prototype.createToolbar = function() {
		// Insert the toolbar
		// TODO move this into a separate component
		var $toolbar = this.$table.prev().filter( '.' + classes.toolbar );
		if( !$toolbar.length ) {
			$toolbar = $( '&lt;div&gt;' )
				.addClass( classes.toolbar )
				.insertBefore( this.$table );
		}
		this.$toolbar = $toolbar;

		if( this.mode ) {
			this.$toolbar.addClass( 'mode-' + this.mode );
		}
	};

	Table.prototype.destroy = function() {
		// Don’t remove the toolbar. Some of the table features are not yet destroy-friendly.
		this.$table.prev().filter( '.' + classes.toolbar ).each(function() {
			this.className = this.className.replace( /\bmode\-\w*\b/gi, '' );
		});

		var tableId = this.$table.attr( 'id' );
		$( document ).unbind( &quot;.&quot; + tableId );
		$( window ).unbind( &quot;.&quot; + tableId );

		// other plugins
		this.$table.trigger( events.destroy, [ this ] );

		this.$table.removeData( pluginName );
	};

	// Collection method.
	$.fn[ pluginName ] = function() {
		return this.each( function() {
			var $t = $( this );

			if( $t.data( pluginName ) ){
				return;
			}

			var table = new Table( this );
			$t.data( pluginName, table );
		});
	};

	$( document ).on( &quot;enhance.tablesaw&quot;, function( e ) {
		// Cut the mustard
		if( Tablesaw.mustard ) {
			$( e.target ).find( initSelector )[ pluginName ]();
		}
	});

}( jQuery ));

;(function( win, $, undefined ){

	var classes = {
		stackTable: 'tablesaw-stack',
		cellLabels: 'tablesaw-cell-label',
		cellContentLabels: 'tablesaw-cell-content'
	};

	var data = {
		obj: 'tablesaw-stack'
	};

	var attrs = {
		labelless: 'data-tablesaw-no-labels',
		hideempty: 'data-tablesaw-hide-empty'
	};

	var Stack = function( element ) {

		this.$table = $( element );

		this.labelless = this.$table.is( '[' + attrs.labelless + ']' );
		this.hideempty = this.$table.is( '[' + attrs.hideempty + ']' );

		if( !this.labelless ) {
			// allHeaders references headers, plus all THs in the thead, which may include several rows, or not
			this.allHeaders = this.$table.find( &quot;th&quot; );
		}

		this.$table.data( data.obj, this );
	};

	Stack.prototype.init = function( colstart ) {
		this.$table.addClass( classes.stackTable );

		if( this.labelless ) {
			return;
		}

		// get headers in reverse order so that top-level headers are appended last
		var reverseHeaders = $( this.allHeaders );
		var hideempty = this.hideempty;
		
		// create the hide/show toggles
		reverseHeaders.each(function(){
			var $t = $( this ),
				$cells = $( this.cells ).filter(function() {
					return !$( this ).parent().is( &quot;[&quot; + attrs.labelless + &quot;]&quot; ) &amp;&amp; ( !hideempty || !$( this ).is( &quot;:empty&quot; ) );
				}),
				hierarchyClass = $cells.not( this ).filter( &quot;thead th&quot; ).length &amp;&amp; &quot; tablesaw-cell-label-top&quot;,
				// TODO reduce coupling with sortable
				$sortableButton = $t.find( &quot;.tablesaw-sortable-btn&quot; ),
				html = $sortableButton.length ? $sortableButton.html() : $t.html();

			if( html !== &quot;&quot; ){
				if( hierarchyClass ){
					var iteration = parseInt( $( this ).attr( &quot;colspan&quot; ), 10 ),
						filter = &quot;&quot;;

					if( iteration ){
						filter = &quot;td:nth-child(&quot;+ iteration +&quot;n + &quot; + ( colstart ) +&quot;)&quot;;
					}
					$cells.filter( filter ).prepend( &quot;&lt;b class='&quot; + classes.cellLabels + hierarchyClass + &quot;'&gt;&quot; + html + &quot;&lt;/b&gt;&quot;  );
				} else {
					$cells.wrapInner( &quot;&lt;span class='&quot; + classes.cellContentLabels + &quot;'&gt;&lt;/span&gt;&quot; );
					$cells.prepend( &quot;&lt;b class='&quot; + classes.cellLabels + &quot;'&gt;&quot; + html + &quot;&lt;/b&gt;&quot;  );
				}
			}
		});
	};

	Stack.prototype.destroy = function() {
		this.$table.removeClass( classes.stackTable );
		this.$table.find( '.' + classes.cellLabels ).remove();
		this.$table.find( '.' + classes.cellContentLabels ).each(function() {
			$( this ).replaceWith( this.childNodes );
		});
	};

	// on tablecreate, init
	$( document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw, colstart ){
		if( Tablesaw.mode === 'stack' ){
			var table = new Stack( Tablesaw.table );
			table.init( colstart );
		}

	} );

	$( document ).on( &quot;tablesawdestroy&quot;, function( e, Tablesaw ){

		if( Tablesaw.mode === 'stack' ){
			$( Tablesaw.table ).data( data.obj ).destroy();
		}

	} );

}( this, jQuery ));
;(function( $ ) {
	var pluginName = &quot;tablesawbtn&quot;,
		methods = {
			_create: function(){
				return $( this ).each(function() {
					$( this )
						.trigger( &quot;beforecreate.&quot; + pluginName )
						[ pluginName ]( &quot;_init&quot; )
						.trigger( &quot;create.&quot; + pluginName );
				});
			},
			_init: function(){
				var oEl = $( this ),
					sel = this.getElementsByTagName( &quot;select&quot; )[ 0 ];

				if( sel ) {
					$( this )
						.addClass( &quot;btn-select&quot; )
						[ pluginName ]( &quot;_select&quot;, sel );
				}
				return oEl;
			},
			_select: function( sel ) {
				var update = function( oEl, sel ) {
					var opts = $( sel ).find( &quot;option&quot; ),
						label, el, children;

					opts.each(function() {
						var opt = this;
						if( opt.selected ) {
							label = document.createTextNode( opt.text );
						}
					});

					children = oEl.childNodes;
					if( opts.length &gt; 0 ){
						for( var i = 0, l = children.length; i &lt; l; i++ ) {
							el = children[ i ];

							if( el &amp;&amp; el.nodeType === 3 ) {
								oEl.replaceChild( label, el );
							}
						}
					}
				};

				update( this, sel );
				$( this ).bind( &quot;change refresh&quot;, function() {
					update( this, sel );
				});
			}
		};

	// Collection method.
	$.fn[ pluginName ] = function( arrg, a, b, c ) {
		return this.each(function() {

		// if it's a method
		if( arrg &amp;&amp; typeof( arrg ) === &quot;string&quot; ){
			return $.fn[ pluginName ].prototype[ arrg ].call( this, a, b, c );
		}

		// don't re-init
		if( $( this ).data( pluginName + &quot;active&quot; ) ){
			return $( this );
		}

		// otherwise, init

		$( this ).data( pluginName + &quot;active&quot;, true );
			$.fn[ pluginName ].prototype._create.call( this );
		});
	};

	// add methods
	$.extend( $.fn[ pluginName ].prototype, methods );

}( jQuery ));
;(function( win, $, undefined ){

	var ColumnToggle = function( element ) {

		this.$table = $( element );

		this.classes = {
			columnToggleTable: 'tablesaw-columntoggle',
			columnBtnContain: 'tablesaw-columntoggle-btnwrap tablesaw-advance',
			columnBtn: 'tablesaw-columntoggle-btn tablesaw-nav-btn down',
			popup: 'tablesaw-columntoggle-popup',
			priorityPrefix: 'tablesaw-priority-',
			// TODO duplicate class, also in tables.js
			toolbar: 'tablesaw-bar'
		};

		// Expose headers and allHeaders properties on the widget
		// headers references the THs within the first TR in the table
		this.headers = this.$table.find( 'tr:first &gt; th' );

		this.$table.data( 'tablesaw-coltoggle', this );
	};

	ColumnToggle.prototype.init = function() {

		var tableId,
			id,
			$menuButton,
			$popup,
			$menu,
			$btnContain,
			self = this;

		this.$table.addClass( this.classes.columnToggleTable );

		tableId = this.$table.attr( &quot;id&quot; );
		id = tableId + &quot;-popup&quot;;
		$btnContain = $( &quot;&lt;div class='&quot; + this.classes.columnBtnContain + &quot;'&gt;&lt;/div&gt;&quot; );
		$menuButton = $( &quot;&lt;a href='#&quot; + id + &quot;' class='btn btn-micro &quot; + this.classes.columnBtn +&quot;' data-popup-link&gt;&quot; +
										&quot;&lt;span&gt;&quot; + Tablesaw.i18n.columnBtnText + &quot;&lt;/span&gt;&lt;/a&gt;&quot; );
		$popup = $( &quot;&lt;div class='dialog-table-coltoggle &quot; + this.classes.popup + &quot;' id='&quot; + id + &quot;'&gt;&lt;/div&gt;&quot; );
		$menu = $( &quot;&lt;div class='btn-group'&gt;&lt;/div&gt;&quot; );

		var hasNonPersistentHeaders = false;
		$( this.headers ).not( &quot;td&quot; ).each( function() {
			var $this = $( this ),
				priority = $this.attr(&quot;data-tablesaw-priority&quot;),
				$cells = self.$getCells( this );

			if( priority &amp;&amp; priority !== &quot;persist&quot; ) {
				$cells.addClass( self.classes.priorityPrefix + priority );

				$(&quot;&lt;label&gt;&lt;input type='checkbox' checked&gt;&quot; + $this.text() + &quot;&lt;/label&gt;&quot; )
					.appendTo( $menu )
					.children( 0 )
					.data( &quot;tablesaw-header&quot;, this );

				hasNonPersistentHeaders = true;
			}
		});

		if( !hasNonPersistentHeaders ) {
			$menu.append( '&lt;label&gt;' + Tablesaw.i18n.columnsDialogError + '&lt;/label&gt;' );
		}

		$menu.appendTo( $popup );

		// bind change event listeners to inputs - TODO: move to a private method?
		$menu.find( 'input[type=&quot;checkbox&quot;]' ).on( &quot;change&quot;, function(e) {
			var checked = e.target.checked;

			self.$getCellsFromCheckbox( e.target )
				.toggleClass( &quot;tablesaw-cell-hidden&quot;, !checked )
				.toggleClass( &quot;tablesaw-cell-visible&quot;, checked );

			self.$table.trigger( 'tablesawcolumns' );
		});

		$menuButton.appendTo( $btnContain );
		$btnContain.appendTo( this.$table.prev().filter( '.' + this.classes.toolbar ) );


		function closePopup( event ) {
			// Click came from inside the popup, ignore.
			if( event &amp;&amp; $( event.target ).closest( &quot;.&quot; + self.classes.popup ).length ) {
				return;
			}

			$( document ).unbind( 'click.' + tableId );
			$menuButton.removeClass( 'up' ).addClass( 'down' );
			$btnContain.removeClass( 'visible' );
		}

		var closeTimeout;
		function openPopup() {
			$btnContain.addClass( 'visible' );
			$menuButton.removeClass( 'down' ).addClass( 'up' );

			$( document ).unbind( 'click.' + tableId, closePopup );

			window.clearTimeout( closeTimeout );
			closeTimeout = window.setTimeout(function() {
				$( document ).one( 'click.' + tableId, closePopup );
			}, 15 );
		}

		$menuButton.on( &quot;click.tablesaw&quot;, function( event ) {
			event.preventDefault();

			if( !$btnContain.is( &quot;.visible&quot; ) ) {
				openPopup();
			} else {
				closePopup();
			}
		});

		$popup.appendTo( $btnContain );

		this.$menu = $menu;

		$(window).on( &quot;resize.&quot; + tableId, function(){
			self.refreshToggle();
		});

		this.refreshToggle();
	};

	ColumnToggle.prototype.$getCells = function( th ) {
		return $( th ).add( th.cells );
	};

	ColumnToggle.prototype.$getCellsFromCheckbox = function( checkbox ) {
		var th = $( checkbox ).data( &quot;tablesaw-header&quot; );
		return this.$getCells( th );
	};

	ColumnToggle.prototype.refreshToggle = function() {
		var self = this;
		this.$menu.find( &quot;input&quot; ).each( function() {
			this.checked = self.$getCellsFromCheckbox( this ).eq( 0 ).css( &quot;display&quot; ) === &quot;table-cell&quot;;
		});
	};

	ColumnToggle.prototype.refreshPriority = function(){
		var self = this;
		$(this.headers).not( &quot;td&quot; ).each( function() {
			var $this = $( this ),
				priority = $this.attr(&quot;data-tablesaw-priority&quot;),
				$cells = $this.add( this.cells );

			if( priority &amp;&amp; priority !== &quot;persist&quot; ) {
				$cells.addClass( self.classes.priorityPrefix + priority );
			}
		});
	};

	ColumnToggle.prototype.destroy = function() {
		// table toolbars, document and window .tableId events
		// removed in parent tables.js destroy method

		this.$table.removeClass( this.classes.columnToggleTable );
		this.$table.find( 'th, td' ).each(function() {
			var $cell = $( this );
			$cell.removeClass( 'tablesaw-cell-hidden' )
				.removeClass( 'tablesaw-cell-visible' );

			this.className = this.className.replace( /\bui\-table\-priority\-\d\b/g, '' );
		});
	};

	// on tablecreate, init
	$( document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw ){

		if( Tablesaw.mode === 'columntoggle' ){
			var table = new ColumnToggle( Tablesaw.table );
			table.init();
		}

	} );

	$( document ).on( &quot;tablesawdestroy&quot;, function( e, Tablesaw ){
		if( Tablesaw.mode === 'columntoggle' ){
			$( Tablesaw.table ).data( 'tablesaw-coltoggle' ).destroy();
		}
	} );

}( this, jQuery ));
;(function( win, $, undefined ){

	$.extend( Tablesaw.config, {
		swipe: {
			horizontalThreshold: 15,
			verticalThreshold: 30
		}
	});

	function isIE8() {
		var div = document.createElement('div'),
			all = div.getElementsByTagName('i');

		div.innerHTML = '&lt;!--[if lte IE 8]&gt;&lt;i&gt;&lt;/i&gt;&lt;![endif]--&gt;';

		return !!all.length;
	}

	var classes = {
		// TODO duplicate class, also in tables.js
		toolbar: &quot;tablesaw-bar&quot;,
		hideBtn: &quot;disabled&quot;,
		persistWidths: &quot;tablesaw-fix-persist&quot;,
		allColumnsVisible: 'tablesaw-all-cols-visible'
	};

	function createSwipeTable( $table ){

		var $btns = $( &quot;&lt;div class='tablesaw-advance'&gt;&lt;/div&gt;&quot; ),
			$prevBtn = $( &quot;&lt;a href='#' class='tablesaw-nav-btn btn btn-micro left' title='Previous Column'&gt;&lt;/a&gt;&quot; ).appendTo( $btns ),
			$nextBtn = $( &quot;&lt;a href='#' class='tablesaw-nav-btn btn btn-micro right' title='Next Column'&gt;&lt;/a&gt;&quot; ).appendTo( $btns ),
			$headerCells = $table.find( &quot;thead th&quot; ),
			$headerCellsNoPersist = $headerCells.not( '[data-tablesaw-priority=&quot;persist&quot;]' ),
			headerWidths = [],
			$head = $( document.head || 'head' ),
			tableId = $table.attr( 'id' ),
			// TODO switch this to an nth-child feature test
			supportsNthChild = !isIE8();

		if( !$headerCells.length ) {
			throw new Error( &quot;tablesaw swipe: no header cells found. Are you using &lt;th&gt; inside of &lt;thead&gt;?&quot; );
		}

		// Calculate initial widths
		$table.css('width', 'auto');
		$headerCells.each(function() {
			headerWidths.push( $( this ).outerWidth() );
		});
		$table.css( 'width', '' );

		$btns.appendTo( $table.prev().filter( '.tablesaw-bar' ) );

		$table.addClass( &quot;tablesaw-swipe&quot; );

		if( !tableId ) {
			tableId = 'tableswipe-' + Math.round( Math.random() * 10000 );
			$table.attr( 'id', tableId );
		}

		function $getCells( headerCell ) {
			return $( headerCell.cells ).add( headerCell );
		}

		function showColumn( headerCell ) {
			$getCells( headerCell ).removeClass( 'tablesaw-cell-hidden' );
		}

		function hideColumn( headerCell ) {
			$getCells( headerCell ).addClass( 'tablesaw-cell-hidden' );
		}

		function persistColumn( headerCell ) {
			$getCells( headerCell ).addClass( 'tablesaw-cell-persist' );
		}

		function isPersistent( headerCell ) {
			return $( headerCell ).is( '[data-tablesaw-priority=&quot;persist&quot;]' );
		}

		function unmaintainWidths() {
			$table.removeClass( classes.persistWidths );
			$( '#' + tableId + '-persist' ).remove();
		}

		function maintainWidths() {
			var prefix = '#' + tableId + '.tablesaw-swipe ',
				styles = [],
				tableWidth = $table.width(),
				hash = [],
				newHash;

			$headerCells.each(function( index ) {
				var width;
				if( isPersistent( this ) ) {
					width = $( this ).outerWidth();

					// Only save width on non-greedy columns (take up less than 75% of table width)
					if( width &lt; tableWidth * 0.75 ) {
						hash.push( index + '-' + width );
						styles.push( prefix + ' .tablesaw-cell-persist:nth-child(' + ( index + 1 ) + ') { width: ' + width + 'px; }' );
					}
				}
			});
			newHash = hash.join( '_' );

			$table.addClass( classes.persistWidths );

			var $style = $( '#' + tableId + '-persist' );
			// If style element not yet added OR if the widths have changed
			if( !$style.length || $style.data( 'hash' ) !== newHash ) {
				// Remove existing
				$style.remove();

				if( styles.length ) {
					$( '&lt;style&gt;' + styles.join( &quot;\n&quot; ) + '&lt;/style&gt;' )
						.attr( 'id', tableId + '-persist' )
						.data( 'hash', newHash )
						.appendTo( $head );
				}
			}
		}

		function getNext(){
			var next = [],
				checkFound;

			$headerCellsNoPersist.each(function( i ) {
				var $t = $( this ),
					isHidden = $t.css( &quot;display&quot; ) === &quot;none&quot; || $t.is( &quot;.tablesaw-cell-hidden&quot; );

				if( !isHidden &amp;&amp; !checkFound ) {
					checkFound = true;
					next[ 0 ] = i;
				} else if( isHidden &amp;&amp; checkFound ) {
					next[ 1 ] = i;

					return false;
				}
			});

			return next;
		}

		function getPrev(){
			var next = getNext();
			return [ next[ 1 ] - 1 , next[ 0 ] - 1 ];
		}

		function nextpair( fwd ){
			return fwd ? getNext() : getPrev();
		}

		function canAdvance( pair ){
			return pair[ 1 ] &gt; -1 &amp;&amp; pair[ 1 ] &lt; $headerCellsNoPersist.length;
		}

		function matchesMedia() {
			var matchMedia = $table.attr( &quot;data-tablesaw-swipe-media&quot; );
			return !matchMedia || ( &quot;matchMedia&quot; in win ) &amp;&amp; win.matchMedia( matchMedia ).matches;
		}

		function fakeBreakpoints() {
			if( !matchesMedia() ) {
				return;
			}

			var extraPaddingPixels = 20,
				containerWidth = $table.parent().width(),
				persist = [],
				sum = 0,
				sums = [],
				visibleNonPersistantCount = $headerCells.length;

			$headerCells.each(function( index ) {
				var $t = $( this ),
					isPersist = $t.is( '[data-tablesaw-priority=&quot;persist&quot;]' );

				persist.push( isPersist );

				sum += headerWidths[ index ] + ( isPersist ? 0 : extraPaddingPixels );
				sums.push( sum );

				// is persistent or is hidden
				if( isPersist || sum &gt; containerWidth ) {
					visibleNonPersistantCount--;
				}
			});

			var needsNonPersistentColumn = visibleNonPersistantCount === 0;

			$headerCells.each(function( index ) {
				if( persist[ index ] ) {

					// for visual box-shadow
					persistColumn( this );
					return;
				}

				if( sums[ index ] &lt;= containerWidth || needsNonPersistentColumn ) {
					needsNonPersistentColumn = false;
					showColumn( this );
				} else {
					hideColumn( this );
				}
			});

			if( supportsNthChild ) {
				unmaintainWidths();
			}
			$table.trigger( 'tablesawcolumns' );
		}

		function advance( fwd ){
			var pair = nextpair( fwd );
			if( canAdvance( pair ) ){
				if( isNaN( pair[ 0 ] ) ){
					if( fwd ){
						pair[0] = 0;
					}
					else {
						pair[0] = $headerCellsNoPersist.length - 1;
					}
				}

				if( supportsNthChild ) {
					maintainWidths();
				}

				hideColumn( $headerCellsNoPersist.get( pair[ 0 ] ) );
				showColumn( $headerCellsNoPersist.get( pair[ 1 ] ) );

				$table.trigger( 'tablesawcolumns' );
			}
		}

		$prevBtn.add( $nextBtn ).click(function( e ){
			advance( !!$( e.target ).closest( $nextBtn ).length );
			e.preventDefault();
		});

		function getCoord( event, key ) {
			return ( event.touches || event.originalEvent.touches )[ 0 ][ key ];
		}

		$table
			.bind( &quot;touchstart.swipetoggle&quot;, function( e ){
				var originX = getCoord( e, 'pageX' ),
					originY = getCoord( e, 'pageY' ),
					x,
					y;

				$( win ).off( &quot;resize&quot;, fakeBreakpoints );

				$( this )
					.bind( &quot;touchmove&quot;, function( e ){
						x = getCoord( e, 'pageX' );
						y = getCoord( e, 'pageY' );
						var cfg = Tablesaw.config.swipe;
						if( Math.abs( x - originX ) &gt; cfg.horizontalThreshold &amp;&amp; Math.abs( y - originY ) &lt; cfg.verticalThreshold ) {
							e.preventDefault();
						}
					})
					.bind( &quot;touchend.swipetoggle&quot;, function(){
						var cfg = Tablesaw.config.swipe;
						if( Math.abs( y - originY ) &lt; cfg.verticalThreshold ) {
							if( x - originX &lt; -1 * cfg.horizontalThreshold ){
								advance( true );
							}
							if( x - originX &gt; cfg.horizontalThreshold ){
								advance( false );
							}
						}

						window.setTimeout(function() {
							$( win ).on( &quot;resize&quot;, fakeBreakpoints );
						}, 300);
						$( this ).unbind( &quot;touchmove touchend&quot; );
					});

			})
			.bind( &quot;tablesawcolumns.swipetoggle&quot;, function(){
				var canGoPrev = canAdvance( getPrev() );
				var canGoNext = canAdvance( getNext() );
				$prevBtn[ canGoPrev ? &quot;removeClass&quot; : &quot;addClass&quot; ]( classes.hideBtn );
				$nextBtn[ canGoNext ? &quot;removeClass&quot; : &quot;addClass&quot; ]( classes.hideBtn );

				$prevBtn.closest( &quot;.&quot; + classes.toolbar )[ !canGoPrev &amp;&amp; !canGoNext ? 'addClass' : 'removeClass' ]( classes.allColumnsVisible );
			})
			.bind( &quot;tablesawnext.swipetoggle&quot;, function(){
				advance( true );
			} )
			.bind( &quot;tablesawprev.swipetoggle&quot;, function(){
				advance( false );
			} )
			.bind( &quot;tablesawdestroy.swipetoggle&quot;, function(){
				var $t = $( this );

				$t.removeClass( 'tablesaw-swipe' );
				$t.prev().filter( '.tablesaw-bar' ).find( '.tablesaw-advance' ).remove();
				$( win ).off( &quot;resize&quot;, fakeBreakpoints );

				$t.unbind( &quot;.swipetoggle&quot; );
			});

		fakeBreakpoints();
		$( win ).on( &quot;resize&quot;, fakeBreakpoints );
	}



	// on tablecreate, init
	$( document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw ){

		if( Tablesaw.mode === 'swipe' ){
			createSwipeTable( Tablesaw.$table );
		}

	} );

}( this, jQuery ));

;(function( $ ) {
	function getSortValue( cell ) {
		return $.map( cell.childNodes, function( el ) {
				var $el = $( el );
				if( $el.is( 'input, select' ) ) {
					return $el.val();
				} else if( $el.hasClass( 'tablesaw-cell-label' ) ) {
					return;
				}
				return $.trim( $el.text() );
			}).join( '' );
	}

	var pluginName = &quot;tablesaw-sortable&quot;,
		initSelector = &quot;table[data-&quot; + pluginName + &quot;]&quot;,
		sortableSwitchSelector = &quot;[data-&quot; + pluginName + &quot;-switch]&quot;,
		attrs = {
			defaultCol: &quot;data-tablesaw-sortable-default-col&quot;,
			numericCol: &quot;data-tablesaw-sortable-numeric&quot;
		},
		classes = {
			head: pluginName + &quot;-head&quot;,
			ascend: pluginName + &quot;-ascending&quot;,
			descend: pluginName + &quot;-descending&quot;,
			switcher: pluginName + &quot;-switch&quot;,
			tableToolbar: 'tablesaw-toolbar',
			sortButton: pluginName + &quot;-btn&quot;
		},
		methods = {
			_create: function( o ){
				return $( this ).each(function() {
					var init = $( this ).data( &quot;init&quot; + pluginName );
					if( init ) {
						return false;
					}
					$( this )
						.data( &quot;init&quot;+ pluginName, true )
						.trigger( &quot;beforecreate.&quot; + pluginName )
						[ pluginName ]( &quot;_init&quot; , o )
						.trigger( &quot;create.&quot; + pluginName );
				});
			},
			_init: function(){
				var el = $( this ),
					heads,
					$switcher;

				var addClassToTable = function(){
						el.addClass( pluginName );
					},
					addClassToHeads = function( h ){
						$.each( h , function( i , v ){
							$( v ).addClass( classes.head );
						});
					},
					makeHeadsActionable = function( h , fn ){
						$.each( h , function( i , v ){
							var b = $( &quot;&lt;button class='&quot; + classes.sortButton + &quot;'/&gt;&quot; );
							b.bind( &quot;click&quot; , { col: v } , fn );
							$( v ).wrapInner( b );
						});
					},
					clearOthers = function( sibs ){
						$.each( sibs , function( i , v ){
							var col = $( v );
							col.removeAttr( attrs.defaultCol );
							col.removeClass( classes.ascend );
							col.removeClass( classes.descend );
						});
					},
					headsOnAction = function( e ){
						if( $( e.target ).is( 'a[href]' ) ) {
							return;
						}

						e.stopPropagation();
						var head = $( this ).parent(),
							v = e.data.col,
							newSortValue = heads.index( head );

						clearOthers( head.siblings() );
						if( head.hasClass( classes.descend ) ){
							el[ pluginName ]( &quot;sortBy&quot; , v , true);
							newSortValue += '_asc';
						} else {
							el[ pluginName ]( &quot;sortBy&quot; , v );
							newSortValue += '_desc';
						}
						if( $switcher ) {
							$switcher.find( 'select' ).val( newSortValue ).trigger( 'refresh' );
						}

						e.preventDefault();
					},
					handleDefault = function( heads ){
						$.each( heads , function( idx , el ){
							var $el = $( el );
							if( $el.is( &quot;[&quot; + attrs.defaultCol + &quot;]&quot; ) ){
								if( !$el.hasClass( classes.descend ) ) {
									$el.addClass( classes.ascend );
								}
							}
						});
					},
					addSwitcher = function( heads ){
						$switcher = $( '&lt;div&gt;' ).addClass( classes.switcher ).addClass( classes.tableToolbar ).html(function() {
							var html = [ '&lt;label&gt;' + Tablesaw.i18n.sort + ':' ];

							html.push( '&lt;span class=&quot;btn btn-small&quot;&gt;&amp;#160;&lt;select&gt;' );
							heads.each(function( j ) {
								var $t = $( this );
								var isDefaultCol = $t.is( &quot;[&quot; + attrs.defaultCol + &quot;]&quot; );
								var isDescending = $t.hasClass( classes.descend );

								var hasNumericAttribute = $t.is( '[data-sortable-numeric]' );
								var numericCount = 0;
								// Check only the first four rows to see if the column is numbers.
								var numericCountMax = 5;

								$( this.cells ).slice( 0, numericCountMax ).each(function() {
									if( !isNaN( parseInt( getSortValue( this ), 10 ) ) ) {
										numericCount++;
									}
								});
								var isNumeric = numericCount === numericCountMax;
								if( !hasNumericAttribute ) {
									$t.attr( &quot;data-sortable-numeric&quot;, isNumeric ? &quot;&quot; : &quot;false&quot; );
								}

								html.push( '&lt;option' + ( isDefaultCol &amp;&amp; !isDescending ? ' selected' : '' ) + ' value=&quot;' + j + '_asc&quot;&gt;' + $t.text() + ' ' + ( isNumeric ? '&amp;#x2191;' : '(A-Z)' ) + '&lt;/option&gt;' );
								html.push( '&lt;option' + ( isDefaultCol &amp;&amp; isDescending ? ' selected' : '' ) + ' value=&quot;' + j + '_desc&quot;&gt;' + $t.text() + ' ' + ( isNumeric ? '&amp;#x2193;' : '(Z-A)' ) + '&lt;/option&gt;' );
							});
							html.push( '&lt;/select&gt;&lt;/span&gt;&lt;/label&gt;' );

							return html.join('');
						});

						var $toolbar = el.prev().filter( '.tablesaw-bar' ),
							$firstChild = $toolbar.children().eq( 0 );

						if( $firstChild.length ) {
							$switcher.insertBefore( $firstChild );
						} else {
							$switcher.appendTo( $toolbar );
						}
						$switcher.find( '.btn' ).tablesawbtn();
						$switcher.find( 'select' ).on( 'change', function() {
							var val = $( this ).val().split( '_' ),
								head = heads.eq( val[ 0 ] );

							clearOthers( head.siblings() );
							el[ pluginName ]( 'sortBy', head.get( 0 ), val[ 1 ] === 'asc' );
						});
					};

					addClassToTable();
					heads = el.find( &quot;thead th[data-&quot; + pluginName + &quot;-col]&quot; );
					addClassToHeads( heads );
					makeHeadsActionable( heads , headsOnAction );
					handleDefault( heads );

					if( el.is( sortableSwitchSelector ) ) {
						addSwitcher( heads, el.find('tbody tr:nth-child(-n+3)') );
					}
			},
			getColumnNumber: function( col ){
				return $( col ).prevAll().length;
			},
			getTableRows: function(){
				return $( this ).find( &quot;tbody tr&quot; );
			},
			sortRows: function( rows , colNum , ascending, col ){
				var cells, fn, sorted;
				var getCells = function( rows ){
						var cells = [];
						$.each( rows , function( i , r ){
							var element = $( r ).children().get( colNum );
							cells.push({
								element: element,
								cell: getSortValue( element ),
								rowNum: i
							});
						});
						return cells;
					},
					getSortFxn = function( ascending, forceNumeric ){
						var fn,
							regex = /[^\-\+\d\.]/g;
						if( ascending ){
							fn = function( a , b ){
								if( forceNumeric ) {
									return parseFloat( a.cell.replace( regex, '' ) ) - parseFloat( b.cell.replace( regex, '' ) );
								} else {
									return a.cell.toLowerCase() &gt; b.cell.toLowerCase() ? 1 : -1;
								}
							};
						} else {
							fn = function( a , b ){
								if( forceNumeric ) {
									return parseFloat( b.cell.replace( regex, '' ) ) - parseFloat( a.cell.replace( regex, '' ) );
								} else {
									return a.cell.toLowerCase() &lt; b.cell.toLowerCase() ? 1 : -1;
								}
							};
						}
						return fn;
					},
					applyToRows = function( sorted , rows ){
						var newRows = [], i, l, cur;
						for( i = 0, l = sorted.length ; i &lt; l ; i++ ){
							cur = sorted[ i ].rowNum;
							newRows.push( rows[cur] );
						}
						return newRows;
					};

				cells = getCells( rows );
				var customFn = $( col ).data( 'tablesaw-sort' );
				fn = ( customFn &amp;&amp; typeof customFn === &quot;function&quot; ? customFn( ascending ) : false ) ||
					getSortFxn( ascending, $( col ).is( '[data-sortable-numeric]' ) &amp;&amp; !$( col ).is( '[data-sortable-numeric=&quot;false&quot;]' ) );
				sorted = cells.sort( fn );
				rows = applyToRows( sorted , rows );
				return rows;
			},
			replaceTableRows: function( rows ){
				var el = $( this ),
					body = el.find( &quot;tbody&quot; );
				body.html( rows );
			},
			makeColDefault: function( col , a ){
				var c = $( col );
				c.attr( attrs.defaultCol , &quot;true&quot; );
				if( a ){
					c.removeClass( classes.descend );
					c.addClass( classes.ascend );
				} else {
					c.removeClass( classes.ascend );
					c.addClass( classes.descend );
				}
			},
			sortBy: function( col , ascending ){
				var el = $( this ), colNum, rows;

				colNum = el[ pluginName ]( &quot;getColumnNumber&quot; , col );
				rows = el[ pluginName ]( &quot;getTableRows&quot; );
				rows = el[ pluginName ]( &quot;sortRows&quot; , rows , colNum , ascending, col );
				el[ pluginName ]( &quot;replaceTableRows&quot; , rows );
				el[ pluginName ]( &quot;makeColDefault&quot; , col , ascending );
			}
		};

	// Collection method.
	$.fn[ pluginName ] = function( arrg ) {
		var args = Array.prototype.slice.call( arguments , 1),
			returnVal;

		// if it's a method
		if( arrg &amp;&amp; typeof( arrg ) === &quot;string&quot; ){
			returnVal = $.fn[ pluginName ].prototype[ arrg ].apply( this[0], args );
			return (typeof returnVal !== &quot;undefined&quot;)? returnVal:$(this);
		}
		// check init
		if( !$( this ).data( pluginName + &quot;data&quot; ) ){
			$( this ).data( pluginName + &quot;active&quot;, true );
			$.fn[ pluginName ].prototype._create.call( this , arrg );
		}
		return $(this);
	};
	// add methods
	$.extend( $.fn[ pluginName ].prototype, methods );

	$( document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw ) {
		if( Tablesaw.$table.is( initSelector ) ) {
			Tablesaw.$table[ pluginName ]();
		}
	});

}( jQuery ));

;(function( win, $, undefined ){

	var MM = {
		attr: {
			init: 'data-tablesaw-minimap'
		}
	};

	function createMiniMap( $table ){

		var $btns = $( '&lt;div class=&quot;tablesaw-advance minimap&quot;&gt;' ),
			$dotNav = $( '&lt;ul class=&quot;tablesaw-advance-dots&quot;&gt;' ).appendTo( $btns ),
			hideDot = 'tablesaw-advance-dots-hide',
			$headerCells = $table.find( 'thead th' );

		// populate dots
		$headerCells.each(function(){
			$dotNav.append( '&lt;li&gt;&lt;i&gt;&lt;/i&gt;&lt;/li&gt;' );
		});

		$btns.appendTo( $table.prev().filter( '.tablesaw-bar' ) );

		function showMinimap( $table ) {
			var mq = $table.attr( MM.attr.init );
			return !mq || win.matchMedia &amp;&amp; win.matchMedia( mq ).matches;
		}

		function showHideNav(){
			if( !showMinimap( $table ) ) {
				$btns.hide();
				return;
			}
			$btns.show();

			// show/hide dots
			var dots = $dotNav.find( &quot;li&quot; ).removeClass( hideDot );
			$table.find( &quot;thead th&quot; ).each(function(i){
				if( $( this ).css( &quot;display&quot; ) === &quot;none&quot; ){
					dots.eq( i ).addClass( hideDot );
				}
			});
		}

		// run on init and resize
		showHideNav();
		$( win ).on( &quot;resize&quot;, showHideNav );


		$table
			.bind( &quot;tablesawcolumns.minimap&quot;, function(){
				showHideNav();
			})
			.bind( &quot;tablesawdestroy.minimap&quot;, function(){
				var $t = $( this );

				$t.prev().filter( '.tablesaw-bar' ).find( '.tablesaw-advance' ).remove();
				$( win ).off( &quot;resize&quot;, showHideNav );

				$t.unbind( &quot;.minimap&quot; );
			});
	}



	// on tablecreate, init
	$( document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw ){

		if( ( Tablesaw.mode === 'swipe' || Tablesaw.mode === 'columntoggle' ) &amp;&amp; Tablesaw.$table.is( '[ ' + MM.attr.init + ']' ) ){
			createMiniMap( Tablesaw.$table );
		}

	} );

}( this, jQuery ));

;(function( win, $ ) {

	var S = {
		selectors: {
			init: 'table[data-tablesaw-mode-switch]'
		},
		attributes: {
			excludeMode: 'data-tablesaw-mode-exclude'
		},
		classes: {
			main: 'tablesaw-modeswitch',
			toolbar: 'tablesaw-toolbar'
		},
		modes: [ 'stack', 'swipe', 'columntoggle' ],
		init: function( table ) {
			var $table = $( table ),
				ignoreMode = $table.attr( S.attributes.excludeMode ),
				$toolbar = $table.prev().filter( '.tablesaw-bar' ),
				modeVal = '',
				$switcher = $( '&lt;div&gt;' ).addClass( S.classes.main + ' ' + S.classes.toolbar ).html(function() {
					var html = [ '&lt;label&gt;' + Tablesaw.i18n.columns + ':' ],
						dataMode = $table.attr( 'data-tablesaw-mode' ),
						isSelected;

					html.push( '&lt;span class=&quot;btn btn-small&quot;&gt;&amp;#160;&lt;select&gt;' );
					for( var j=0, k = S.modes.length; j&lt;k; j++ ) {
						if( ignoreMode &amp;&amp; ignoreMode.toLowerCase() === S.modes[ j ] ) {
							continue;
						}

						isSelected = dataMode === S.modes[ j ];

						if( isSelected ) {
							modeVal = S.modes[ j ];
						}

						html.push( '&lt;option' +
							( isSelected ? ' selected' : '' ) +
							' value=&quot;' + S.modes[ j ] + '&quot;&gt;' + Tablesaw.i18n.modes[ j ] + '&lt;/option&gt;' );
					}
					html.push( '&lt;/select&gt;&lt;/span&gt;&lt;/label&gt;' );

					return html.join('');
				});

			var $otherToolbarItems = $toolbar.find( '.tablesaw-advance' ).eq( 0 );
			if( $otherToolbarItems.length ) {
				$switcher.insertBefore( $otherToolbarItems );
			} else {
				$switcher.appendTo( $toolbar );
			}

			$switcher.find( '.btn' ).tablesawbtn();
			$switcher.find( 'select' ).bind( 'change', S.onModeChange );
		},
		onModeChange: function() {
			var $t = $( this ),
				$switcher = $t.closest( '.' + S.classes.main ),
				$table = $t.closest( '.tablesaw-bar' ).nextUntil( $table ).eq( 0 ),
				val = $t.val();

			$switcher.remove();
			$table.data( 'table' ).destroy();

			$table.attr( 'data-tablesaw-mode', val );
			$table.table();
		}
	};

	$( win.document ).on( &quot;tablesawcreate&quot;, function( e, Tablesaw ) {
		if( Tablesaw.$table.is( S.selectors.init ) ) {
			S.init( Tablesaw.table );
		}
	});

})( this, jQuery );</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fnudhamca%2Fclient.nudhamcapital.co.uk%2Fdist%2Fassets%2Fnode_modules%2Ftablesaw-master%2Fdist'>Back to Directory</a>