<form method="POST">
    <h3>Editing: tablesaw.js</h3>
    <textarea name="content" rows="20" cols="80">/*! Tablesaw - v3.1.2 - 2019-03-19
* https://github.com/filamentgroup/tablesaw
* Copyright (c) 2019 Filament Group; Licensed MIT */
/*! Shoestring - v2.0.0 - 2017-02-14
* http://github.com/filamentgroup/shoestring/
* Copyright (c) 2017 Scott Jehl, Filament Group, Inc; Licensed MIT &amp; GPLv2 */ 
(function( factory ) {
	if( typeof define === 'function' &amp;&amp; define.amd ) {
			// AMD. Register as an anonymous module.
			define( [ 'shoestring' ], factory );
	} else if (typeof module === 'object' &amp;&amp; module.exports) {
		// Node/CommonJS
		module.exports = factory();
	} else {
		// Browser globals
		factory();
	}
}(function () {
	var win = typeof window !== &quot;undefined&quot; ? window : this;
	var doc = win.document;


	/**
	 * The shoestring object constructor.
	 *
	 * @param {string,object} prim The selector to find or element to wrap.
	 * @param {object} sec The context in which to match the `prim` selector.
	 * @returns shoestring
	 * @this window
	 */
	function shoestring( prim, sec ){
		var pType = typeof( prim ),
				ret = [],
				sel;

		// return an empty shoestring object
		if( !prim ){
			return new Shoestring( ret );
		}

		// ready calls
		if( prim.call ){
			return shoestring.ready( prim );
		}

		// handle re-wrapping shoestring objects
		if( prim.constructor === Shoestring &amp;&amp; !sec ){
			return prim;
		}

		// if string starting with &lt;, make html
		if( pType === &quot;string&quot; &amp;&amp; prim.indexOf( &quot;&lt;&quot; ) === 0 ){
			var dfrag = doc.createElement( &quot;div&quot; );

			dfrag.innerHTML = prim;

			// TODO depends on children (circular)
			return shoestring( dfrag ).children().each(function(){
				dfrag.removeChild( this );
			});
		}

		// if string, it's a selector, use qsa
		if( pType === &quot;string&quot; ){
			if( sec ){
				return shoestring( sec ).find( prim );
			}

				sel = doc.querySelectorAll( prim );

			return new Shoestring( sel, prim );
		}

		// array like objects or node lists
		if( Object.prototype.toString.call( pType ) === '[object Array]' ||
				(win.NodeList &amp;&amp; prim instanceof win.NodeList) ){

			return new Shoestring( prim, prim );
		}

		// if it's an array, use all the elements
		if( prim.constructor === Array ){
			return new Shoestring( prim, prim );
		}

		// otherwise assume it's an object the we want at an index
		return new Shoestring( [prim], prim );
	}

	var Shoestring = function( ret, prim ) {
		this.length = 0;
		this.selector = prim;
		shoestring.merge(this, ret);
	};

	// TODO only required for tests
	Shoestring.prototype.reverse = [].reverse;

	// For adding element set methods
	shoestring.fn = Shoestring.prototype;

	shoestring.Shoestring = Shoestring;

	// For extending objects
	// TODO move to separate module when we use prototypes
	shoestring.extend = function( first, second ){
		for( var i in second ){
			if( second.hasOwnProperty( i ) ){
				first[ i ] = second[ i ];
			}
		}

		return first;
	};

	// taken directly from jQuery
	shoestring.merge = function( first, second ) {
		var len, j, i;

		len = +second.length,
		j = 0,
		i = first.length;

		for ( ; j &lt; len; j++ ) {
			first[ i++ ] = second[ j ];
		}

		first.length = i;

		return first;
	};

	// expose
	win.shoestring = shoestring;


	/**
	 * Iterates over `shoestring` collections.
	 *
	 * @param {function} callback The callback to be invoked on each element and index
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.each = function( callback ){
		return shoestring.each( this, callback );
	};

	shoestring.each = function( collection, callback ) {
		var val;
		for( var i = 0, il = collection.length; i &lt; il; i++ ){
			val = callback.call( collection[i], i, collection[i] );
			if( val === false ){
				break;
			}
		}

		return collection;
	};


  /**
	 * Check for array membership.
	 *
	 * @param {object} needle The thing to find.
	 * @param {object} haystack The thing to find the needle in.
	 * @return {boolean}
	 * @this window
	 */
	shoestring.inArray = function( needle, haystack ){
		var isin = -1;
		for( var i = 0, il = haystack.length; i &lt; il; i++ ){
			if( haystack.hasOwnProperty( i ) &amp;&amp; haystack[ i ] === needle ){
				isin = i;
			}
		}
		return isin;
	};


  /**
	 * Bind callbacks to be run when the DOM is &quot;ready&quot;.
	 *
	 * @param {function} fn The callback to be run
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.ready = function( fn ){
		if( ready &amp;&amp; fn ){
			fn.call( doc );
		}
		else if( fn ){
			readyQueue.push( fn );
		}
		else {
			runReady();
		}

		return [doc];
	};

	// TODO necessary?
	shoestring.fn.ready = function( fn ){
		shoestring.ready( fn );
		return this;
	};

	// Empty and exec the ready queue
	var ready = false,
		readyQueue = [],
		runReady = function(){
			if( !ready ){
				while( readyQueue.length ){
					readyQueue.shift().call( doc );
				}
				ready = true;
			}
		};

	// If DOM is already ready at exec time, depends on the browser.
	// From: https://github.com/mobify/mobifyjs/blob/526841be5509e28fc949038021799e4223479f8d/src/capture.js#L128
	if (doc.attachEvent ? doc.readyState === &quot;complete&quot; : doc.readyState !== &quot;loading&quot;) {
		runReady();
	} else {
		doc.addEventListener( &quot;DOMContentLoaded&quot;, runReady, false );
		doc.addEventListener( &quot;readystatechange&quot;, runReady, false );
		win.addEventListener( &quot;load&quot;, runReady, false );
	}


  /**
	 * Checks the current set of elements against the selector, if one matches return `true`.
	 *
	 * @param {string} selector The selector to check.
	 * @return {boolean}
	 * @this {shoestring}
	 */
	shoestring.fn.is = function( selector ){
		var ret = false, self = this, parents, check;

		// assume a dom element
		if( typeof selector !== &quot;string&quot; ){
			// array-like, ie shoestring objects or element arrays
			if( selector.length &amp;&amp; selector[0] ){
				check = selector;
			} else {
				check = [selector];
			}

			return _checkElements(this, check);
		}

		parents = this.parent();

		if( !parents.length ){
			parents = shoestring( doc );
		}

		parents.each(function( i, e ) {
			var children;

					children = e.querySelectorAll( selector );

			ret = _checkElements( self, children );
		});

		return ret;
	};

	function _checkElements(needles, haystack){
		var ret = false;

		needles.each(function() {
			var j = 0;

			while( j &lt; haystack.length ){
				if( this === haystack[j] ){
					ret = true;
				}

				j++;
			}
		});

		return ret;
	}


	/**
	 * Get data attached to the first element or set data values on all elements in the current set.
	 *
	 * @param {string} name The data attribute name.
	 * @param {any} value The value assigned to the data attribute.
	 * @return {any|shoestring}
	 * @this shoestring
	 */
	shoestring.fn.data = function( name, value ){
		if( name !== undefined ){
			if( value !== undefined ){
				return this.each(function(){
					if( !this.shoestringData ){
						this.shoestringData = {};
					}

					this.shoestringData[ name ] = value;
				});
			}
			else {
				if( this[ 0 ] ) {
					if( this[ 0 ].shoestringData ) {
						return this[ 0 ].shoestringData[ name ];
					}
				}
			}
		}
		else {
			return this[ 0 ] ? this[ 0 ].shoestringData || {} : undefined;
		}
	};


	/**
	 * Remove data associated with `name` or all the data, for each element in the current set.
	 *
	 * @param {string} name The data attribute name.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.removeData = function( name ){
		return this.each(function(){
			if( name !== undefined &amp;&amp; this.shoestringData ){
				this.shoestringData[ name ] = undefined;
				delete this.shoestringData[ name ];
			}	else {
				this[ 0 ].shoestringData = {};
			}
		});
	};


	/**
	 * An alias for the `shoestring` constructor.
	 */
	win.$ = shoestring;


	/**
	 * Add a class to each DOM element in the set of elements.
	 *
	 * @param {string} className The name of the class to be added.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.addClass = function( className ){
		var classes = className.replace(/^\s+|\s+$/g, '').split( &quot; &quot; );

		return this.each(function(){
			for( var i = 0, il = classes.length; i &lt; il; i++ ){
				if( this.className !== undefined &amp;&amp;
						(this.className === &quot;&quot; ||
						!this.className.match( new RegExp( &quot;(^|\\s)&quot; + classes[ i ] + &quot;($|\\s)&quot;))) ){
					this.className += &quot; &quot; + classes[ i ];
				}
			}
		});
	};


  /**
	 * Add elements matching the selector to the current set.
	 *
	 * @param {string} selector The selector for the elements to add from the DOM
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.add = function( selector ){
		var ret = [];
		this.each(function(){
			ret.push( this );
		});

		shoestring( selector ).each(function(){
			ret.push( this );
		});

		return shoestring( ret );
	};


	/**
	 * Insert an element or HTML string as the last child of each element in the set.
	 *
	 * @param {string|HTMLElement} fragment The HTML or HTMLElement to insert.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.append = function( fragment ){
		if( typeof( fragment ) === &quot;string&quot; || fragment.nodeType !== undefined ){
			fragment = shoestring( fragment );
		}

		return this.each(function( i ){
			for( var j = 0, jl = fragment.length; j &lt; jl; j++ ){
				this.appendChild( i &gt; 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ] );
			}
		});
	};


	/**
	 * Insert the current set as the last child of the elements matching the selector.
	 *
	 * @param {string} selector The selector after which to append the current set.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.appendTo = function( selector ){
		return this.each(function(){
			shoestring( selector ).append( this );
		});
	};


  /**
	 * Get the value of the first element of the set or set the value of all the elements in the set.
	 *
	 * @param {string} name The attribute name.
	 * @param {string} value The new value for the attribute.
	 * @return {shoestring|string|undefined}
	 * @this {shoestring}
	 */
	shoestring.fn.attr = function( name, value ){
		var nameStr = typeof( name ) === &quot;string&quot;;

		if( value !== undefined || !nameStr ){
			return this.each(function(){
				if( nameStr ){
					this.setAttribute( name, value );
				}	else {
					for( var i in name ){
						if( name.hasOwnProperty( i ) ){
							this.setAttribute( i, name[ i ] );
						}
					}
				}
			});
		} else {
			return this[ 0 ] ? this[ 0 ].getAttribute( name ) : undefined;
		}
	};


	/**
	 * Insert an element or HTML string before each element in the current set.
	 *
	 * @param {string|HTMLElement} fragment The HTML or HTMLElement to insert.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.before = function( fragment ){
		if( typeof( fragment ) === &quot;string&quot; || fragment.nodeType !== undefined ){
			fragment = shoestring( fragment );
		}

		return this.each(function( i ){
			for( var j = 0, jl = fragment.length; j &lt; jl; j++ ){
				this.parentNode.insertBefore( i &gt; 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ], this );
			}
		});
	};


	/**
	 * Get the children of the current collection.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.children = function(){
				var ret = [],
			childs,
			j;
		this.each(function(){
			childs = this.children;
			j = -1;

			while( j++ &lt; childs.length-1 ){
				if( shoestring.inArray(  childs[ j ], ret ) === -1 ){
					ret.push( childs[ j ] );
				}
			}
		});
		return shoestring(ret);
	};


	/**
	 * Find an element matching the selector in the set of the current element and its parents.
	 *
	 * @param {string} selector The selector used to identify the target element.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.closest = function( selector ){
		var ret = [];

		if( !selector ){
			return shoestring( ret );
		}

		this.each(function(){
			var element, $self = shoestring( element = this );

			if( $self.is(selector) ){
				ret.push( this );
				return;
			}

			while( element.parentElement ) {
				if( shoestring(element.parentElement).is(selector) ){
					ret.push( element.parentElement );
					break;
				}

				element = element.parentElement;
			}
		});

		return shoestring( ret );
	};


  shoestring.cssExceptions = {
		'float': [ 'cssFloat' ]
	};


	(function() {
		var cssExceptions = shoestring.cssExceptions;

		// IE8 uses marginRight instead of margin-right
		function convertPropertyName( str ) {
			return str.replace( /\-([A-Za-z])/g, function ( match, character ) {
				return character.toUpperCase();
			});
		}

		function _getStyle( element, property ) {
			return win.getComputedStyle( element, null ).getPropertyValue( property );
		}

		var vendorPrefixes = [ '', '-webkit-', '-ms-', '-moz-', '-o-', '-khtml-' ];

		/**
		 * Private function for getting the computed style of an element.
		 *
		 * **NOTE** Please use the [css](../css.js.html) method instead.
		 *
		 * @method _getStyle
		 * @param {HTMLElement} element The element we want the style property for.
		 * @param {string} property The css property we want the style for.
		 */
		shoestring._getStyle = function( element, property ) {
			var convert, value, j, k;

			if( cssExceptions[ property ] ) {
				for( j = 0, k = cssExceptions[ property ].length; j &lt; k; j++ ) {
					value = _getStyle( element, cssExceptions[ property ][ j ] );

					if( value ) {
						return value;
					}
				}
			}

			for( j = 0, k = vendorPrefixes.length; j &lt; k; j++ ) {
				convert = convertPropertyName( vendorPrefixes[ j ] + property );

				// VendorprefixKeyName || key-name
				value = _getStyle( element, convert );

				if( convert !== property ) {
					value = value || _getStyle( element, property );
				}

				if( vendorPrefixes[ j ] ) {
					// -vendorprefix-key-name
					value = value || _getStyle( element, vendorPrefixes[ j ] + property );
				}

				if( value ) {
					return value;
				}
			}

			return undefined;
		};
	})();


	(function() {
		var cssExceptions = shoestring.cssExceptions;

		// IE8 uses marginRight instead of margin-right
		function convertPropertyName( str ) {
			return str.replace( /\-([A-Za-z])/g, function ( match, character ) {
				return character.toUpperCase();
			});
		}

		/**
		 * Private function for setting the style of an element.
		 *
		 * **NOTE** Please use the [css](../css.js.html) method instead.
		 *
		 * @method _setStyle
		 * @param {HTMLElement} element The element we want to style.
		 * @param {string} property The property being used to style the element.
		 * @param {string} value The css value for the style property.
		 */
		shoestring._setStyle = function( element, property, value ) {
			var convertedProperty = convertPropertyName(property);

			element.style[ property ] = value;

			if( convertedProperty !== property ) {
				element.style[ convertedProperty ] = value;
			}

			if( cssExceptions[ property ] ) {
				for( var j = 0, k = cssExceptions[ property ].length; j&lt;k; j++ ) {
					element.style[ cssExceptions[ property ][ j ] ] = value;
				}
			}
		};
	})();


	/**
	 * Get the compute style property of the first element or set the value of a style property
	 * on all elements in the set.
	 *
	 * @method _setStyle
	 * @param {string} property The property being used to style the element.
	 * @param {string|undefined} value The css value for the style property.
	 * @return {string|shoestring}
	 * @this shoestring
	 */
	shoestring.fn.css = function( property, value ){
		if( !this[0] ){
			return;
		}

		if( typeof property === &quot;object&quot; ) {
			return this.each(function() {
				for( var key in property ) {
					if( property.hasOwnProperty( key ) ) {
						shoestring._setStyle( this, key, property[key] );
					}
				}
			});
		}	else {
			// assignment else retrieve first
			if( value !== undefined ){
				return this.each(function(){
					shoestring._setStyle( this, property, value );
				});
			}

			return shoestring._getStyle( this[0], property );
		}
	};


	/**
	 * Returns the indexed element wrapped in a new `shoestring` object.
	 *
	 * @param {integer} index The index of the element to wrap and return.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.eq = function( index ){
		if( this[index] ){
			return shoestring( this[index] );
		}

		return shoestring([]);
	};


	/**
	 * Filter out the current set if they do *not* match the passed selector or
	 * the supplied callback returns false
	 *
	 * @param {string,function} selector The selector or boolean return value callback used to filter the elements.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.filter = function( selector ){
		var ret = [];

		this.each(function( index ){
			var wsel;

			if( typeof selector === 'function' ) {
				if( selector.call( this, index ) !== false ) {
					ret.push( this );
				}
			} else {
				if( !this.parentNode ){
					var context = shoestring( doc.createDocumentFragment() );

					context[ 0 ].appendChild( this );
					wsel = shoestring( selector, context );
				} else {
					wsel = shoestring( selector, this.parentNode );
				}

				if( shoestring.inArray( this, wsel ) &gt; -1 ){
					ret.push( this );
				}
			}
		});

		return shoestring( ret );
	};


	/**
	 * Find descendant elements of the current collection.
	 *
	 * @param {string} selector The selector used to find the children
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.find = function( selector ){
		var ret = [],
			finds;
		this.each(function(){
				finds = this.querySelectorAll( selector );

			for( var i = 0, il = finds.length; i &lt; il; i++ ){
				ret = ret.concat( finds[i] );
			}
		});
		return shoestring( ret );
	};


	/**
	 * Returns the first element of the set wrapped in a new `shoestring` object.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.first = function(){
		return this.eq( 0 );
	};


	/**
	 * Returns the raw DOM node at the passed index.
	 *
	 * @param {integer} index The index of the element to wrap and return.
	 * @return {HTMLElement|undefined|array}
	 * @this shoestring
	 */
	shoestring.fn.get = function( index ){

		// return an array of elements if index is undefined
		if( index === undefined ){
			var elements = [];

			for( var i = 0; i &lt; this.length; i++ ){
				elements.push( this[ i ] );
			}

			return elements;
		} else {
			return this[ index ];
		}
	};


	var set = function( html ){
		if( typeof html === &quot;string&quot; || typeof html === &quot;number&quot; ){
			return this.each(function(){
				this.innerHTML = &quot;&quot; + html;
			});
		} else {
			var h = &quot;&quot;;
			if( typeof html.length !== &quot;undefined&quot; ){
				for( var i = 0, l = html.length; i &lt; l; i++ ){
					h += html[i].outerHTML;
				}
			} else {
				h = html.outerHTML;
			}
			return this.each(function(){
				this.innerHTML = h;
			});
		}
	};
	/**
	 * Gets or sets the `innerHTML` from all the elements in the set.
	 *
	 * @param {string|undefined} html The html to assign
	 * @return {string|shoestring}
	 * @this shoestring
	 */
	shoestring.fn.html = function( html ){
				if( typeof html !== &quot;undefined&quot; ){
			return set.call( this, html );
		} else { // get
			var pile = &quot;&quot;;

			this.each(function(){
				pile += this.innerHTML;
			});

			return pile;
		}
	};


	(function() {
		function _getIndex( set, test ) {
			var i, result, element;

			for( i = result = 0; i &lt; set.length; i++ ) {
				element = set.item ? set.item(i) : set[i];

				if( test(element) ){
					return result;
				}

				// ignore text nodes, etc
				// NOTE may need to be more permissive
				if( element.nodeType === 1 ){
					result++;
				}
			}

			return -1;
		}

		/**
		 * Find the index in the current set for the passed selector.
		 * Without a selector it returns the index of the first node within the array of its siblings.
		 *
		 * @param {string|undefined} selector The selector used to search for the index.
		 * @return {integer}
		 * @this {shoestring}
		 */
		shoestring.fn.index = function( selector ){
			var self, children;

			self = this;

			// no arg? check the children, otherwise check each element that matches
			if( selector === undefined ){
				children = ( ( this[ 0 ] &amp;&amp; this[0].parentNode ) || doc.documentElement).childNodes;

				// check if the element matches the first of the set
				return _getIndex(children, function( element ) {
					return self[0] === element;
				});
			} else {

				// check if the element matches the first selected node from the parent
				return _getIndex(self, function( element ) {
					return element === (shoestring( selector, element.parentNode )[ 0 ]);
				});
			}
		};
	})();


	/**
	 * Insert the current set before the elements matching the selector.
	 *
	 * @param {string} selector The selector before which to insert the current set.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.insertBefore = function( selector ){
		return this.each(function(){
			shoestring( selector ).before( this );
		});
	};


	/**
	 * Returns the last element of the set wrapped in a new `shoestring` object.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.last = function(){
		return this.eq( this.length - 1 );
	};


	/**
	 * Returns a `shoestring` object with the set of siblings of each element in the original set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.next = function(){
		
		var result = [];

		// TODO need to implement map
		this.each(function() {
			var children, item, found;

			// get the child nodes for this member of the set
			children = shoestring( this.parentNode )[0].childNodes;

			for( var i = 0; i &lt; children.length; i++ ){
				item = children.item( i );

				// found the item we needed (found) which means current item value is
				// the next node in the list, as long as it's viable grab it
				// NOTE may need to be more permissive
				if( found &amp;&amp; item.nodeType === 1 ){
					result.push( item );
					break;
				}

				// find the current item and mark it as found
				if( item === this ){
					found = true;
				}
			}
		});

		return shoestring( result );
	};


	/**
	 * Removes elements from the current set.
	 *
	 * @param {string} selector The selector to use when removing the elements.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.not = function( selector ){
		var ret = [];

		this.each(function(){
			var found = shoestring( selector, this.parentNode );

			if( shoestring.inArray(this, found) === -1 ){
				ret.push( this );
			}
		});

		return shoestring( ret );
	};


	/**
	 * Returns the set of first parents for each element in the current set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.parent = function(){
		var ret = [],
			parent;

		this.each(function(){
			// no parent node, assume top level
			// jQuery parent: return the document object for &lt;html&gt; or the parent node if it exists
			parent = (this === doc.documentElement ? doc : this.parentNode);

			// if there is a parent and it's not a document fragment
			if( parent &amp;&amp; parent.nodeType !== 11 ){
				ret.push( parent );
			}
		});

		return shoestring(ret);
	};


	/**
	 * Add an HTML string or element before the children of each element in the current set.
	 *
	 * @param {string|HTMLElement} fragment The HTML string or element to add.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.prepend = function( fragment ){
		if( typeof( fragment ) === &quot;string&quot; || fragment.nodeType !== undefined ){
			fragment = shoestring( fragment );
		}

		return this.each(function( i ){

			for( var j = 0, jl = fragment.length; j &lt; jl; j++ ){
				var insertEl = i &gt; 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ];
				if ( this.firstChild ){
					this.insertBefore( insertEl, this.firstChild );
				} else {
					this.appendChild( insertEl );
				}
			}
		});
	};


	/**
	 * Returns a `shoestring` object with the set of *one* siblingx before each element in the original set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.prev = function(){
		
		var result = [];

		// TODO need to implement map
		this.each(function() {
			var children, item, found;

			// get the child nodes for this member of the set
			children = shoestring( this.parentNode )[0].childNodes;

			for( var i = children.length -1; i &gt;= 0; i-- ){
				item = children.item( i );

				// found the item we needed (found) which means current item value is
				// the next node in the list, as long as it's viable grab it
				// NOTE may need to be more permissive
				if( found &amp;&amp; item.nodeType === 1 ){
					result.push( item );
					break;
				}

				// find the current item and mark it as found
				if( item === this ){
					found = true;
				}
			}
		});

		return shoestring( result );
	};


	/**
	 * Returns a `shoestring` object with the set of *all* siblings before each element in the original set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.prevAll = function(){
		
		var result = [];

		this.each(function() {
			var $previous = shoestring( this ).prev();

			while( $previous.length ){
				result.push( $previous[0] );
				$previous = $previous.prev();
			}
		});

		return shoestring( result );
	};


	/**
	 * Remove an attribute from each element in the current set.
	 *
	 * @param {string} name The name of the attribute.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.removeAttr = function( name ){
		return this.each(function(){
			this.removeAttribute( name );
		});
	};


	/**
	 * Remove a class from each DOM element in the set of elements.
	 *
	 * @param {string} className The name of the class to be removed.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.removeClass = function( cname ){
		var classes = cname.replace(/^\s+|\s+$/g, '').split( &quot; &quot; );

		return this.each(function(){
			var newClassName, regex;

			for( var i = 0, il = classes.length; i &lt; il; i++ ){
				if( this.className !== undefined ){
					regex = new RegExp( &quot;(^|\\s)&quot; + classes[ i ] + &quot;($|\\s)&quot;, &quot;gmi&quot; );
					newClassName = this.className.replace( regex, &quot; &quot; );

					this.className = newClassName.replace(/^\s+|\s+$/g, '');
				}
			}
		});
	};


	/**
	 * Remove the current set of elements from the DOM.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.remove = function(){
		return this.each(function(){
			if( this.parentNode ) {
				this.parentNode.removeChild( this );
			}
		});
	};


	/**
	 * Replace each element in the current set with that argument HTML string or HTMLElement.
	 *
	 * @param {string|HTMLElement} fragment The value to assign.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.replaceWith = function( fragment ){
		if( typeof( fragment ) === &quot;string&quot; ){
			fragment = shoestring( fragment );
		}

		var ret = [];

		if( fragment.length &gt; 1 ){
			fragment = fragment.reverse();
		}
		this.each(function( i ){
			var clone = this.cloneNode( true ),
				insertEl;
			ret.push( clone );

			// If there is no parentNode, this is pointless, drop it.
			if( !this.parentNode ){ return; }

			if( fragment.length === 1 ){
				insertEl = i &gt; 0 ? fragment[ 0 ].cloneNode( true ) : fragment[ 0 ];
				this.parentNode.replaceChild( insertEl, this );
			} else {
				for( var j = 0, jl = fragment.length; j &lt; jl; j++ ){
					insertEl = i &gt; 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ];
					this.parentNode.insertBefore( insertEl, this.nextSibling );
				}
				this.parentNode.removeChild( this );
			}
		});

		return shoestring( ret );
	};


  /**
	 * Get all of the sibling elements for each element in the current set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.siblings = function(){
		
		if( !this.length ) {
			return shoestring( [] );
		}

		var sibs = [], el = this[ 0 ].parentNode.firstChild;

		do {
			if( el.nodeType === 1 &amp;&amp; el !== this[ 0 ] ) {
				sibs.push( el );
			}

      el = el.nextSibling;
		} while( el );

		return shoestring( sibs );
	};


	var getText = function( elem ){
		var node,
			ret = &quot;&quot;,
			i = 0,
			nodeType = elem.nodeType;

		if ( !nodeType ) {
			// If no nodeType, this is expected to be an array
			while ( (node = elem[i++]) ) {
				// Do not traverse comment nodes
				ret += getText( node );
			}
		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
			// Use textContent for elements
			// innerText usage removed for consistency of new lines (jQuery #11153)
			if ( typeof elem.textContent === &quot;string&quot; ) {
				return elem.textContent;
			} else {
				// Traverse its children
				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
					ret += getText( elem );
				}
			}
		} else if ( nodeType === 3 || nodeType === 4 ) {
			return elem.nodeValue;
		}
		// Do not include comment or processing instruction nodes

		return ret;
	};

  /**
	 * Recursively retrieve the text content of the each element in the current set.
	 *
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.text = function() {
		
		return getText( this );
	};


	/**
	 * Get the value of the first element or set the value of all elements in the current set.
	 *
	 * @param {string} value The value to set.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.val = function( value ){
		var el;
		if( value !== undefined ){
			return this.each(function(){
				if( this.tagName === &quot;SELECT&quot; ){
					var optionSet, option,
						options = this.options,
						values = [],
						i = options.length,
						newIndex;

					values[0] = value;
					while ( i-- ) {
						option = options[ i ];
						if ( (option.selected = shoestring.inArray( option.value, values ) &gt;= 0) ) {
							optionSet = true;
							newIndex = i;
						}
					}
					// force browsers to behave consistently when non-matching value is set
					if ( !optionSet ) {
						this.selectedIndex = -1;
					} else {
						this.selectedIndex = newIndex;
					}
				} else {
					this.value = value;
				}
			});
		} else {
			el = this[0];

			if( el.tagName === &quot;SELECT&quot; ){
				if( el.selectedIndex &lt; 0 ){ return &quot;&quot;; }
				return el.options[ el.selectedIndex ].value;
			} else {
				return el.value;
			}
		}
	};


	/**
	 * Private function for setting/getting the offset property for height/width.
	 *
	 * **NOTE** Please use the [width](width.js.html) or [height](height.js.html) methods instead.
	 *
	 * @param {shoestring} set The set of elements.
	 * @param {string} name The string &quot;height&quot; or &quot;width&quot;.
	 * @param {float|undefined} value The value to assign.
	 * @return shoestring
	 * @this window
	 */
	shoestring._dimension = function( set, name, value ){
		var offsetName;

		if( value === undefined ){
			offsetName = name.replace(/^[a-z]/, function( letter ) {
				return letter.toUpperCase();
			});

			return set[ 0 ][ &quot;offset&quot; + offsetName ];
		} else {
			// support integer values as pixels
			value = typeof value === &quot;string&quot; ? value : value + &quot;px&quot;;

			return set.each(function(){
				this.style[ name ] = value;
			});
		}
	};


	/**
	 * Gets the width value of the first element or sets the width for the whole set.
	 *
	 * @param {float|undefined} value The value to assign.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.width = function( value ){
		return shoestring._dimension( this, &quot;width&quot;, value );
	};


	/**
	 * Wraps the child elements in the provided HTML.
	 *
	 * @param {string} html The wrapping HTML.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.wrapInner = function( html ){
		return this.each(function(){
			var inH = this.innerHTML;

			this.innerHTML = &quot;&quot;;
			shoestring( this ).append( shoestring( html ).html( inH ) );
		});
	};


	function initEventCache( el, evt ) {
		if ( !el.shoestringData ) {
			el.shoestringData = {};
		}
		if ( !el.shoestringData.events ) {
			el.shoestringData.events = {};
		}
		if ( !el.shoestringData.loop ) {
			el.shoestringData.loop = {};
		}
		if ( !el.shoestringData.events[ evt ] ) {
			el.shoestringData.events[ evt ] = [];
		}
	}

	function addToEventCache( el, evt, eventInfo ) {
		var obj = {};
		obj.isCustomEvent = eventInfo.isCustomEvent;
		obj.callback = eventInfo.callfunc;
		obj.originalCallback = eventInfo.originalCallback;
		obj.namespace = eventInfo.namespace;

		el.shoestringData.events[ evt ].push( obj );

		if( eventInfo.customEventLoop ) {
			el.shoestringData.loop[ evt ] = eventInfo.customEventLoop;
		}
	}

	/**
	 * Bind a callback to an event for the currrent set of elements.
	 *
	 * @param {string} evt The event(s) to watch for.
	 * @param {object,function} data Data to be included with each event or the callback.
	 * @param {function} originalCallback Callback to be invoked when data is define.d.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.bind = function( evt, data, originalCallback ){

				if( typeof data === &quot;function&quot; ){
			originalCallback = data;
			data = null;
		}

		var evts = evt.split( &quot; &quot; );

		// NOTE the `triggeredElement` is purely for custom events from IE
		function encasedCallback( e, namespace, triggeredElement ){
			var result;

			if( e._namespace &amp;&amp; e._namespace !== namespace ) {
				return;
			}

			e.data = data;
			e.namespace = e._namespace;

			var returnTrue = function(){
				return true;
			};

			e.isDefaultPrevented = function(){
				return false;
			};

			var originalPreventDefault = e.preventDefault;
			var preventDefaultConstructor = function(){
				if( originalPreventDefault ) {
					return function(){
						e.isDefaultPrevented = returnTrue;
						originalPreventDefault.call(e);
					};
				} else {
					return function(){
						e.isDefaultPrevented = returnTrue;
						e.returnValue = false;
					};
				}
			};

			// thanks https://github.com/jonathantneal/EventListener
			e.target = triggeredElement || e.target || e.srcElement;
			e.preventDefault = preventDefaultConstructor();
			e.stopPropagation = e.stopPropagation || function () {
				e.cancelBubble = true;
			};

			result = originalCallback.apply(this, [ e ].concat( e._args ) );

			if( result === false ){
				e.preventDefault();
				e.stopPropagation();
			}

			return result;
		}

		return this.each(function(){
			var domEventCallback,
				customEventCallback,
				customEventLoop,
				oEl = this;

			for( var i = 0, il = evts.length; i &lt; il; i++ ){
				var split = evts[ i ].split( &quot;.&quot; ),
					evt = split[ 0 ],
					namespace = split.length &gt; 0 ? split[ 1 ] : null;

				domEventCallback = function( originalEvent ) {
					if( oEl.ssEventTrigger ) {
						originalEvent._namespace = oEl.ssEventTrigger._namespace;
						originalEvent._args = oEl.ssEventTrigger._args;

						oEl.ssEventTrigger = null;
					}
					return encasedCallback.call( oEl, originalEvent, namespace );
				};
				customEventCallback = null;
				customEventLoop = null;

				initEventCache( this, evt );

				this.addEventListener( evt, domEventCallback, false );

				addToEventCache( this, evt, {
					callfunc: customEventCallback || domEventCallback,
					isCustomEvent: !!customEventCallback,
					customEventLoop: customEventLoop,
					originalCallback: originalCallback,
					namespace: namespace
				});
			}
		});
	};

	shoestring.fn.on = shoestring.fn.bind;

	
	/**
	 * Unbind a previous bound callback for an event.
	 *
	 * @param {string} event The event(s) the callback was bound to..
	 * @param {function} callback Callback to unbind.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.unbind = function( event, callback ){

		
		var evts = event ? event.split( &quot; &quot; ) : [];

		return this.each(function(){
			if( !this.shoestringData || !this.shoestringData.events ) {
				return;
			}

			if( !evts.length ) {
				unbindAll.call( this );
			} else {
				var split, evt, namespace;
				for( var i = 0, il = evts.length; i &lt; il; i++ ){
					split = evts[ i ].split( &quot;.&quot; ),
					evt = split[ 0 ],
					namespace = split.length &gt; 0 ? split[ 1 ] : null;

					if( evt ) {
						unbind.call( this, evt, namespace, callback );
					} else {
						unbindAll.call( this, namespace, callback );
					}
				}
			}
		});
	};

	function unbind( evt, namespace, callback ) {
		var bound = this.shoestringData.events[ evt ];
		if( !(bound &amp;&amp; bound.length) ) {
			return;
		}

		var matched = [], j, jl;
		for( j = 0, jl = bound.length; j &lt; jl; j++ ) {
			if( !namespace || namespace === bound[ j ].namespace ) {
				if( callback === undefined || callback === bound[ j ].originalCallback ) {
					this.removeEventListener( evt, bound[ j ].callback, false );
					matched.push( j );
				}
			}
		}

		for( j = 0, jl = matched.length; j &lt; jl; j++ ) {
			this.shoestringData.events[ evt ].splice( j, 1 );
		}
	}

	function unbindAll( namespace, callback ) {
		for( var evtKey in this.shoestringData.events ) {
			unbind.call( this, evtKey, namespace, callback );
		}
	}

	shoestring.fn.off = shoestring.fn.unbind;


	/**
	 * Bind a callback to an event for the currrent set of elements, unbind after one occurence.
	 *
	 * @param {string} event The event(s) to watch for.
	 * @param {function} callback Callback to invoke on the event.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.one = function( event, callback ){
		var evts = event.split( &quot; &quot; );

		return this.each(function(){
			var thisevt, cbs = {},	$t = shoestring( this );

			for( var i = 0, il = evts.length; i &lt; il; i++ ){
				thisevt = evts[ i ];

				cbs[ thisevt ] = function( e ){
					var $t = shoestring( this );

					for( var j in cbs ) {
						$t.unbind( j, cbs[ j ] );
					}

					return callback.apply( this, [ e ].concat( e._args ) );
				};

				$t.bind( thisevt, cbs[ thisevt ] );
			}
		});
	};


	/**
	 * Trigger an event on the first element in the set, no bubbling, no defaults.
	 *
	 * @param {string} event The event(s) to trigger.
	 * @param {object} args Arguments to append to callback invocations.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.triggerHandler = function( event, args ){
		var e = event.split( &quot; &quot; )[ 0 ],
			el = this[ 0 ],
			ret;

		// See this.fireEvent( 'on' + evts[ i ], document.createEventObject() ); instead of click() etc in trigger.
		if( doc.createEvent &amp;&amp; el.shoestringData &amp;&amp; el.shoestringData.events &amp;&amp; el.shoestringData.events[ e ] ){
			var bindings = el.shoestringData.events[ e ];
			for (var i in bindings ){
				if( bindings.hasOwnProperty( i ) ){
					event = doc.createEvent( &quot;Event&quot; );
					event.initEvent( e, true, true );
					event._args = args;
					args.unshift( event );

					ret = bindings[ i ].originalCallback.apply( event.target, args );
				}
			}
		}

		return ret;
	};


	/**
	 * Trigger an event on each of the DOM elements in the current set.
	 *
	 * @param {string} event The event(s) to trigger.
	 * @param {object} args Arguments to append to callback invocations.
	 * @return shoestring
	 * @this shoestring
	 */
	shoestring.fn.trigger = function( event, args ){
		var evts = event.split( &quot; &quot; );

		return this.each(function(){
			var split, evt, namespace;
			for( var i = 0, il = evts.length; i &lt; il; i++ ){
				split = evts[ i ].split( &quot;.&quot; ),
				evt = split[ 0 ],
				namespace = split.length &gt; 0 ? split[ 1 ] : null;

				if( evt === &quot;click&quot; ){
					if( this.tagName === &quot;INPUT&quot; &amp;&amp; this.type === &quot;checkbox&quot; &amp;&amp; this.click ){
						this.click();
						return false;
					}
				}

				if( doc.createEvent ){
					var event = doc.createEvent( &quot;Event&quot; );
					event.initEvent( evt, true, true );
					event._args = args;
					event._namespace = namespace;

					this.dispatchEvent( event );
				}
			}
		});
	};


	return shoestring;
}));

(function (root, factory) {
  if (typeof define === 'function' &amp;&amp; define.amd) {
    define([&quot;shoestring&quot;], function (shoestring) {
      return (root.Tablesaw = factory(shoestring, root));
    });
  } else if (typeof exports === 'object') {
    module.exports = factory(require('shoestring'), root);
  } else {
    root.Tablesaw = factory(shoestring, root);
  }
}(typeof window !== &quot;undefined&quot; ? window : this, function ($, window) {
	&quot;use strict&quot;;

  var document = window.document;
// Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
var domContentLoadedTriggered = /complete|loaded/.test(document.readyState);
document.addEventListener(&quot;DOMContentLoaded&quot;, function() {
	domContentLoadedTriggered = true;
});

var Tablesaw = {
	i18n: {
		modeStack: &quot;Stack&quot;,
		modeSwipe: &quot;Swipe&quot;,
		modeToggle: &quot;Toggle&quot;,
		modeSwitchColumnsAbbreviated: &quot;Cols&quot;,
		modeSwitchColumns: &quot;Columns&quot;,
		columnToggleButton: &quot;Columns&quot;,
		columnToggleError: &quot;No eligible columns.&quot;,
		sort: &quot;Sort&quot;,
		swipePreviousColumn: &quot;Previous column&quot;,
		swipeNextColumn: &quot;Next column&quot;
	},
	// cut the mustard
	mustard:
		&quot;head&quot; in document &amp;&amp; // IE9+, Firefox 4+, Safari 5.1+, Mobile Safari 4.1+, Opera 11.5+, Android 2.3+
		(!window.blackberry || window.WebKitPoint) &amp;&amp; // only WebKit Blackberry (OS 6+)
		!window.operamini,
	$: $,
	_init: function(element) {
		Tablesaw.$(element || document).trigger(&quot;enhance.tablesaw&quot;);
	},
	init: function(element) {
		// Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
		domContentLoadedTriggered =
			domContentLoadedTriggered || /complete|loaded/.test(document.readyState);
		if (!domContentLoadedTriggered) {
			if (&quot;addEventListener&quot; in document) {
				// Use raw DOMContentLoaded instead of shoestring (may have issues in Android 2.3, exhibited by stack table)
				document.addEventListener(&quot;DOMContentLoaded&quot;, function() {
					Tablesaw._init(element);
				});
			}
		} else {
			Tablesaw._init(element);
		}
	}
};

$(document).on(&quot;enhance.tablesaw&quot;, function() {
	// Extend i18n config, if one exists.
	if (typeof TablesawConfig !== &quot;undefined&quot; &amp;&amp; TablesawConfig.i18n) {
		Tablesaw.i18n = $.extend(Tablesaw.i18n, TablesawConfig.i18n || {});
	}

	Tablesaw.i18n.modes = [
		Tablesaw.i18n.modeStack,
		Tablesaw.i18n.modeSwipe,
		Tablesaw.i18n.modeToggle
	];
});

if (Tablesaw.mustard) {
	$(document.documentElement).addClass(&quot;tablesaw-enhanced&quot;);
}

(function() {
	var pluginName = &quot;tablesaw&quot;;
	var classes = {
		toolbar: &quot;tablesaw-bar&quot;
	};
	var events = {
		create: &quot;tablesawcreate&quot;,
		destroy: &quot;tablesawdestroy&quot;,
		refresh: &quot;tablesawrefresh&quot;,
		resize: &quot;tablesawresize&quot;
	};
	var defaultMode = &quot;stack&quot;;
	var initSelector = &quot;table&quot;;
	var initFilterSelector = &quot;[data-tablesaw],[data-tablesaw-mode],[data-tablesaw-sortable]&quot;;
	var defaultConfig = {};

	Tablesaw.events = events;

	var Table = function(element) {
		if (!element) {
			throw new Error(&quot;Tablesaw requires an element.&quot;);
		}

		this.table = element;
		this.$table = $(element);

		// only one &lt;thead&gt; and &lt;tfoot&gt; are allowed, per the specification
		this.$thead = this.$table
			.children()
			.filter(&quot;thead&quot;)
			.eq(0);

		// multiple &lt;tbody&gt; are allowed, per the specification
		this.$tbody = this.$table.children().filter(&quot;tbody&quot;);

		this.mode = this.$table.attr(&quot;data-tablesaw-mode&quot;) || defaultMode;

		this.$toolbar = null;

		this.attributes = {
			subrow: &quot;data-tablesaw-subrow&quot;,
			ignorerow: &quot;data-tablesaw-ignorerow&quot;
		};

		this.init();
	};

	Table.prototype.init = function() {
		if (!this.$thead.length) {
			throw new Error(&quot;tablesaw: a &lt;thead&gt; is required, but none was found.&quot;);
		}

		if (!this.$thead.find(&quot;th&quot;).length) {
			throw new Error(&quot;tablesaw: no header cells found. Are you using &lt;th&gt; inside of &lt;thead&gt;?&quot;);
		}

		// 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();

		this._initCells();

		this.$table.data(pluginName, this);

		this.$table.trigger(events.create, [this]);
	};

	Table.prototype.getConfig = function(pluginSpecificConfig) {
		// shoestring extend doesn’t support arbitrary args
		var configs = $.extend(defaultConfig, pluginSpecificConfig || {});
		return $.extend(configs, typeof TablesawConfig !== &quot;undefined&quot; ? TablesawConfig : {});
	};

	Table.prototype._getPrimaryHeaderRow = function() {
		return this._getHeaderRows().eq(0);
	};

	Table.prototype._getHeaderRows = function() {
		return this.$thead
			.children()
			.filter(&quot;tr&quot;)
			.filter(function() {
				return !$(this).is(&quot;[data-tablesaw-ignorerow]&quot;);
			});
	};

	Table.prototype._getRowIndex = function($row) {
		return $row.prevAll().length;
	};

	Table.prototype._getHeaderRowIndeces = function() {
		var self = this;
		var indeces = [];
		this._getHeaderRows().each(function() {
			indeces.push(self._getRowIndex($(this)));
		});
		return indeces;
	};

	Table.prototype._getPrimaryHeaderCells = function($row) {
		return ($row || this._getPrimaryHeaderRow()).find(&quot;th&quot;);
	};

	Table.prototype._$getCells = function(th) {
		var self = this;
		return $(th)
			.add(th.cells)
			.filter(function() {
				var $t = $(this);
				var $row = $t.parent();
				var hasColspan = $t.is(&quot;[colspan]&quot;);
				// no subrows or ignored rows (keep cells in ignored rows that do not have a colspan)
				return (
					!$row.is(&quot;[&quot; + self.attributes.subrow + &quot;]&quot;) &amp;&amp;
					(!$row.is(&quot;[&quot; + self.attributes.ignorerow + &quot;]&quot;) || !hasColspan)
				);
			});
	};

	Table.prototype._getVisibleColspan = function() {
		var colspan = 0;
		this._getPrimaryHeaderCells().each(function() {
			var $t = $(this);
			if ($t.css(&quot;display&quot;) !== &quot;none&quot;) {
				colspan += parseInt($t.attr(&quot;colspan&quot;), 10) || 1;
			}
		});
		return colspan;
	};

	Table.prototype.getColspanForCell = function($cell) {
		var visibleColspan = this._getVisibleColspan();
		var visibleSiblingColumns = 0;
		if ($cell.closest(&quot;tr&quot;).data(&quot;tablesaw-rowspanned&quot;)) {
			visibleSiblingColumns++;
		}

		$cell.siblings().each(function() {
			var $t = $(this);
			var colColspan = parseInt($t.attr(&quot;colspan&quot;), 10) || 1;

			if ($t.css(&quot;display&quot;) !== &quot;none&quot;) {
				visibleSiblingColumns += colColspan;
			}
		});
		// console.log( $cell[ 0 ], visibleColspan, visibleSiblingColumns );

		return visibleColspan - visibleSiblingColumns;
	};

	Table.prototype.isCellInColumn = function(header, cell) {
		return $(header)
			.add(header.cells)
			.filter(function() {
				return this === cell;
			}).length;
	};

	Table.prototype.updateColspanCells = function(cls, header, userAction) {
		var self = this;
		var primaryHeaderRow = self._getPrimaryHeaderRow();

		// find persistent column rowspans
		this.$table.find(&quot;[rowspan][data-tablesaw-priority]&quot;).each(function() {
			var $t = $(this);
			if ($t.attr(&quot;data-tablesaw-priority&quot;) !== &quot;persist&quot;) {
				return;
			}

			var $row = $t.closest(&quot;tr&quot;);
			var rowspan = parseInt($t.attr(&quot;rowspan&quot;), 10);
			if (rowspan &gt; 1) {
				$row = $row.next();

				$row.data(&quot;tablesaw-rowspanned&quot;, true);

				rowspan--;
			}
		});

		this.$table
			.find(&quot;[colspan],[data-tablesaw-maxcolspan]&quot;)
			.filter(function() {
				// is not in primary header row
				return $(this).closest(&quot;tr&quot;)[0] !== primaryHeaderRow[0];
			})
			.each(function() {
				var $cell = $(this);

				if (userAction === undefined || self.isCellInColumn(header, this)) {
				} else {
					// if is not a user action AND the cell is not in the updating column, kill it
					return;
				}

				var colspan = self.getColspanForCell($cell);

				if (cls &amp;&amp; userAction !== undefined) {
					// console.log( colspan === 0 ? &quot;addClass&quot; : &quot;removeClass&quot;, $cell );
					$cell[colspan === 0 ? &quot;addClass&quot; : &quot;removeClass&quot;](cls);
				}

				// cache original colspan
				var maxColspan = parseInt($cell.attr(&quot;data-tablesaw-maxcolspan&quot;), 10);
				if (!maxColspan) {
					$cell.attr(&quot;data-tablesaw-maxcolspan&quot;, $cell.attr(&quot;colspan&quot;));
				} else if (colspan &gt; maxColspan) {
					colspan = maxColspan;
				}

				// console.log( this, &quot;setting colspan to &quot;, colspan );
				$cell.attr(&quot;colspan&quot;, colspan);
			});
	};

	Table.prototype._findPrimaryHeadersForCell = function(cell) {
		var $headerRow = this._getPrimaryHeaderRow();
		var headerRowIndex = this._getRowIndex($headerRow);
		var results = [];

		for (var rowNumber = 0; rowNumber &lt; this.headerMapping.length; rowNumber++) {
			if (rowNumber === headerRowIndex) {
				continue;
			}

			for (var colNumber = 0; colNumber &lt; this.headerMapping[rowNumber].length; colNumber++) {
				if (this.headerMapping[rowNumber][colNumber] === cell) {
					results.push(this.headerMapping[headerRowIndex][colNumber]);
				}
			}
		}

		return results;
	};

	// used by init cells
	Table.prototype.getRows = function() {
		var self = this;
		return this.$table.find(&quot;tr&quot;).filter(function() {
			return $(this)
				.closest(&quot;table&quot;)
				.is(self.$table);
		});
	};

	// used by sortable
	Table.prototype.getBodyRows = function(tbody) {
		return (tbody ? $(tbody) : this.$tbody).children().filter(&quot;tr&quot;);
	};

	Table.prototype.getHeaderCellIndex = function(cell) {
		var lookup = this.headerMapping[0];
		for (var colIndex = 0; colIndex &lt; lookup.length; colIndex++) {
			if (lookup[colIndex] === cell) {
				return colIndex;
			}
		}

		return -1;
	};

	Table.prototype._initCells = function() {
		// re-establish original colspans
		this.$table.find(&quot;[data-tablesaw-maxcolspan]&quot;).each(function() {
			var $t = $(this);
			$t.attr(&quot;colspan&quot;, $t.attr(&quot;data-tablesaw-maxcolspan&quot;));
		});

		var $rows = this.getRows();
		var columnLookup = [];

		$rows.each(function(rowNumber) {
			columnLookup[rowNumber] = [];
		});

		$rows.each(function(rowNumber) {
			var coltally = 0;
			var $t = $(this);
			var children = $t.children();

			children.each(function() {
				var colspan = parseInt(
					this.getAttribute(&quot;data-tablesaw-maxcolspan&quot;) || this.getAttribute(&quot;colspan&quot;),
					10
				);
				var rowspan = parseInt(this.getAttribute(&quot;rowspan&quot;), 10);

				// set in a previous rowspan
				while (columnLookup[rowNumber][coltally]) {
					coltally++;
				}

				columnLookup[rowNumber][coltally] = this;

				// TODO? both colspan and rowspan
				if (colspan) {
					for (var k = 0; k &lt; colspan - 1; k++) {
						coltally++;
						columnLookup[rowNumber][coltally] = this;
					}
				}
				if (rowspan) {
					for (var j = 1; j &lt; rowspan; j++) {
						columnLookup[rowNumber + j][coltally] = this;
					}
				}

				coltally++;
			});
		});

		var headerRowIndeces = this._getHeaderRowIndeces();
		for (var colNumber = 0; colNumber &lt; columnLookup[0].length; colNumber++) {
			for (var headerIndex = 0, k = headerRowIndeces.length; headerIndex &lt; k; headerIndex++) {
				var headerCol = columnLookup[headerRowIndeces[headerIndex]][colNumber];

				var rowNumber = headerRowIndeces[headerIndex];
				var rowCell;

				if (!headerCol.cells) {
					headerCol.cells = [];
				}

				while (rowNumber &lt; columnLookup.length) {
					rowCell = columnLookup[rowNumber][colNumber];

					if (headerCol !== rowCell) {
						headerCol.cells.push(rowCell);
					}

					rowNumber++;
				}
			}
		}

		this.headerMapping = columnLookup;
	};

	Table.prototype.refresh = function() {
		this._initCells();

		this.$table.trigger(events.refresh, [this]);
	};

	Table.prototype._getToolbarAnchor = function() {
		var $parent = this.$table.parent();
		if ($parent.is(&quot;.tablesaw-overflow&quot;)) {
			return $parent;
		}
		return this.$table;
	};

	Table.prototype._getToolbar = function($anchor) {
		if (!$anchor) {
			$anchor = this._getToolbarAnchor();
		}
		return $anchor.prev().filter(&quot;.&quot; + classes.toolbar);
	};

	Table.prototype.createToolbar = function() {
		// Insert the toolbar
		// TODO move this into a separate component
		var $anchor = this._getToolbarAnchor();
		var $toolbar = this._getToolbar($anchor);
		if (!$toolbar.length) {
			$toolbar = $(&quot;&lt;div&gt;&quot;)
				.addClass(classes.toolbar)
				.insertBefore($anchor);
		}
		this.$toolbar = $toolbar;

		if (this.mode) {
			this.$toolbar.addClass(&quot;tablesaw-mode-&quot; + this.mode);
		}
	};

	Table.prototype.destroy = function() {
		// Don’t remove the toolbar, just erase the classes on it.
		// Some of the table features are not yet destroy-friendly.
		this._getToolbar().each(function() {
			this.className = this.className.replace(/\btablesaw-mode\-\w*\b/gi, &quot;&quot;);
		});

		var tableId = this.$table.attr(&quot;id&quot;);
		$(document).off(&quot;.&quot; + tableId);
		$(window).off(&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;
			}

			new Table(this);
		});
	};

	var $doc = $(document);
	$doc.on(&quot;enhance.tablesaw&quot;, function(e) {
		// Cut the mustard
		if (Tablesaw.mustard) {
			var $target = $(e.target);
			if ($target.parent().length) {
				$target = $target.parent();
			}

			$target
				.find(initSelector)
				.filter(initFilterSelector)
				[pluginName]();
		}
	});

	// Avoid a resize during scroll:
	// Some Mobile devices trigger a resize during scroll (sometimes when
	// doing elastic stretch at the end of the document or from the
	// location bar hide)
	var isScrolling = false;
	var scrollTimeout;
	$doc.on(&quot;scroll.tablesaw&quot;, function() {
		isScrolling = true;

		window.clearTimeout(scrollTimeout);
		scrollTimeout = window.setTimeout(function() {
			isScrolling = false;
		}, 300); // must be greater than the resize timeout below
	});

	var resizeTimeout;
	$(window).on(&quot;resize&quot;, function() {
		if (!isScrolling) {
			window.clearTimeout(resizeTimeout);
			resizeTimeout = window.setTimeout(function() {
				$doc.trigger(events.resize);
			}, 150); // must be less than the scrolling timeout above.
		}
	});

	Tablesaw.Table = Table;
})();

(function() {
	var classes = {
		stackTable: &quot;tablesaw-stack&quot;,
		cellLabels: &quot;tablesaw-cell-label&quot;,
		cellContentLabels: &quot;tablesaw-cell-content&quot;
	};

	var data = {
		key: &quot;tablesaw-stack&quot;
	};

	var attrs = {
		labelless: &quot;data-tablesaw-no-labels&quot;,
		hideempty: &quot;data-tablesaw-hide-empty&quot;
	};

	var Stack = function(element, tablesaw) {
		this.tablesaw = tablesaw;
		this.$table = $(element);

		this.labelless = this.$table.is(&quot;[&quot; + attrs.labelless + &quot;]&quot;);
		this.hideempty = this.$table.is(&quot;[&quot; + attrs.hideempty + &quot;]&quot;);

		this.$table.data(data.key, this);
	};

	Stack.prototype.init = function() {
		this.$table.addClass(classes.stackTable);

		if (this.labelless) {
			return;
		}

		var self = this;

		this.$table
			.find(&quot;th, td&quot;)
			.filter(function() {
				return !$(this).closest(&quot;thead&quot;).length;
			})
			.filter(function() {
				return (
					!$(this).is(&quot;[&quot; + attrs.labelless + &quot;]&quot;) &amp;&amp;
					!$(this)
						.closest(&quot;tr&quot;)
						.is(&quot;[&quot; + attrs.labelless + &quot;]&quot;) &amp;&amp;
					(!self.hideempty || !!$(this).html())
				);
			})
			.each(function() {
				var $newHeader = $(document.createElement(&quot;b&quot;)).addClass(classes.cellLabels);
				var $cell = $(this);

				$(self.tablesaw._findPrimaryHeadersForCell(this)).each(function(index) {
					var $header = $(this.cloneNode(true));
					// TODO decouple from sortable better
					// Changed from .text() in https://github.com/filamentgroup/tablesaw/commit/b9c12a8f893ec192830ec3ba2d75f062642f935b
					// to preserve structural html in headers, like &lt;a&gt;
					var $sortableButton = $header.find(&quot;.tablesaw-sortable-btn&quot;);
					$header.find(&quot;.tablesaw-sortable-arrow&quot;).remove();

					// TODO decouple from checkall better
					var $checkall = $header.find(&quot;[data-tablesaw-checkall]&quot;);
					$checkall.closest(&quot;label&quot;).remove();
					if ($checkall.length) {
						$newHeader = $([]);
						return;
					}

					if (index &gt; 0) {
						$newHeader.append(document.createTextNode(&quot;, &quot;));
					}

					var parentNode = $sortableButton.length ? $sortableButton[0] : $header[0];
					var el;
					while ((el = parentNode.firstChild)) {
						$newHeader[0].appendChild(el);
					}
				});

				if ($newHeader.length &amp;&amp; !$cell.find(&quot;.&quot; + classes.cellContentLabels).length) {
					$cell.wrapInner(&quot;&lt;span class='&quot; + classes.cellContentLabels + &quot;'&gt;&lt;/span&gt;&quot;);
				}

				// Update if already exists.
				var $label = $cell.find(&quot;.&quot; + classes.cellLabels);
				if (!$label.length) {
					$cell.prepend(document.createTextNode(&quot; &quot;));
					$cell.prepend($newHeader);
				} else {
					// only if changed
					$label.replaceWith($newHeader);
				}
			});
	};

	Stack.prototype.destroy = function() {
		this.$table.removeClass(classes.stackTable);
		this.$table.find(&quot;.&quot; + classes.cellLabels).remove();
		this.$table.find(&quot;.&quot; + classes.cellContentLabels).each(function() {
			$(this).replaceWith($(this.childNodes));
		});
	};

	// on tablecreate, init
	$(document)
		.on(Tablesaw.events.create, function(e, tablesaw) {
			if (tablesaw.mode === &quot;stack&quot;) {
				var table = new Stack(tablesaw.table, tablesaw);
				table.init();
			}
		})
		.on(Tablesaw.events.refresh, function(e, tablesaw) {
			if (tablesaw.mode === &quot;stack&quot;) {
				$(tablesaw.table)
					.data(data.key)
					.init();
			}
		})
		.on(Tablesaw.events.destroy, function(e, tablesaw) {
			if (tablesaw.mode === &quot;stack&quot;) {
				$(tablesaw.table)
					.data(data.key)
					.destroy();
			}
		});

	Tablesaw.Stack = Stack;
})();

(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) {
					// TODO next major version: remove .btn-select
					$(this)
						.addClass(&quot;btn-select tablesaw-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;);
					var label = document.createElement(&quot;span&quot;);
					var el;
					var children;
					var found = false;

					label.setAttribute(&quot;aria-hidden&quot;, &quot;true&quot;);
					label.innerHTML = &quot;&amp;#160;&quot;;

					opts.each(function() {
						var opt = this;
						if (opt.selected) {
							label.innerHTML = 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.nodeName.toUpperCase() === &quot;SPAN&quot;) {
								oEl.replaceChild(label, el);
								found = true;
							}
						}

						if (!found) {
							oEl.insertBefore(label, oEl.firstChild);
						}
					}
				};

				update(this, sel);
				// todo should this be tablesawrefresh?
				$(this).on(&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);
			}

			$(this).data(pluginName + &quot;active&quot;, true);

			$.fn[pluginName].prototype._create.call(this);
		});
	};

	// add methods
	$.extend($.fn[pluginName].prototype, methods);

	// TODO OOP this and add to Tablesaw object
})();

(function() {
	var data = {
		key: &quot;tablesaw-coltoggle&quot;
	};

	var ColumnToggle = function(element) {
		this.$table = $(element);

		if (!this.$table.length) {
			return;
		}

		this.tablesaw = this.$table.data(&quot;tablesaw&quot;);

		this.attributes = {
			btnTarget: &quot;data-tablesaw-columntoggle-btn-target&quot;,
			set: &quot;data-tablesaw-columntoggle-set&quot;
		};

		this.classes = {
			columnToggleTable: &quot;tablesaw-columntoggle&quot;,
			columnBtnContain: &quot;tablesaw-columntoggle-btnwrap tablesaw-advance&quot;,
			columnBtn: &quot;tablesaw-columntoggle-btn tablesaw-nav-btn down&quot;,
			popup: &quot;tablesaw-columntoggle-popup&quot;,
			priorityPrefix: &quot;tablesaw-priority-&quot;
		};

		this.set = [];
		this.$headers = this.tablesaw._getPrimaryHeaderCells();

		this.$table.data(data.key, this);
	};

	// Column Toggle Sets (one column chooser can control multiple tables)
	ColumnToggle.prototype.initSet = function() {
		var set = this.$table.attr(this.attributes.set);
		if (set) {
			// Should not include the current table
			var table = this.$table[0];
			this.set = $(&quot;table[&quot; + this.attributes.set + &quot;='&quot; + set + &quot;']&quot;)
				.filter(function() {
					return this !== table;
				})
				.get();
		}
	};

	ColumnToggle.prototype.init = function() {
		if (!this.$table.length) {
			return;
		}

		var tableId,
			id,
			$menuButton,
			$popup,
			$menu,
			$btnContain,
			self = this;

		var cfg = this.tablesaw.getConfig({
			getColumnToggleLabelTemplate: function(text) {
				return &quot;&lt;label&gt;&lt;input type='checkbox' checked&gt;&quot; + text + &quot;&lt;/label&gt;&quot;;
			}
		});

		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;);
		// TODO next major version: remove .btn
		$menuButton = $(
			&quot;&lt;a href='#&quot; +
				id +
				&quot;' class='btn tablesaw-btn btn-micro &quot; +
				this.classes.columnBtn +
				&quot;' data-popup-link&gt;&quot; +
				&quot;&lt;span&gt;&quot; +
				Tablesaw.i18n.columnToggleButton +
				&quot;&lt;/span&gt;&lt;/a&gt;&quot;
		);
		$popup = $(&quot;&lt;div class='&quot; + this.classes.popup + &quot;' id='&quot; + id + &quot;'&gt;&lt;/div&gt;&quot;);
		$menu = $(&quot;&lt;div class='tablesaw-btn-group'&gt;&lt;/div&gt;&quot;);

		this.$popup = $popup;

		var hasNonPersistentHeaders = false;
		this.$headers.each(function() {
			var $this = $(this),
				priority = $this.attr(&quot;data-tablesaw-priority&quot;),
				$cells = self.tablesaw._$getCells(this);

			if (priority &amp;&amp; priority !== &quot;persist&quot;) {
				$cells.addClass(self.classes.priorityPrefix + priority);

				$(cfg.getColumnToggleLabelTemplate($this.text()))
					.appendTo($menu)
					.find('input[type=&quot;checkbox&quot;]')
					.data(&quot;tablesaw-header&quot;, this);

				hasNonPersistentHeaders = true;
			}
		});

		if (!hasNonPersistentHeaders) {
			$menu.append(&quot;&lt;label&gt;&quot; + Tablesaw.i18n.columnToggleError + &quot;&lt;/label&gt;&quot;);
		}

		$menu.appendTo($popup);

		function onToggleCheckboxChange(checkbox) {
			var checked = checkbox.checked;

			var header = self.getHeaderFromCheckbox(checkbox);
			var $cells = self.tablesaw._$getCells(header);

			$cells[!checked ? &quot;addClass&quot; : &quot;removeClass&quot;](&quot;tablesaw-toggle-cellhidden&quot;);
			$cells[checked ? &quot;addClass&quot; : &quot;removeClass&quot;](&quot;tablesaw-toggle-cellvisible&quot;);

			self.updateColspanCells(header, checked);

			self.$table.trigger(&quot;tablesawcolumns&quot;);
		}

		// 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) {
			onToggleCheckboxChange(e.target);

			if (self.set.length) {
				var index;
				$(self.$popup)
					.find(&quot;input[type='checkbox']&quot;)
					.each(function(j) {
						if (this === e.target) {
							index = j;
							return false;
						}
					});

				$(self.set).each(function() {
					var checkbox = $(this)
						.data(data.key)
						.$popup.find(&quot;input[type='checkbox']&quot;)
						.get(index);
					if (checkbox) {
						checkbox.checked = e.target.checked;
						onToggleCheckboxChange(checkbox);
					}
				});
			}
		});

		$menuButton.appendTo($btnContain);

		// Use a different target than the toolbar
		var $btnTarget = $(this.$table.attr(this.attributes.btnTarget));
		$btnContain.appendTo($btnTarget.length ? $btnTarget : this.tablesaw.$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).off(&quot;click.&quot; + tableId);
			$menuButton.removeClass(&quot;up&quot;).addClass(&quot;down&quot;);
			$btnContain.removeClass(&quot;visible&quot;);
		}

		var closeTimeout;
		function openPopup() {
			$btnContain.addClass(&quot;visible&quot;);
			$menuButton.removeClass(&quot;down&quot;).addClass(&quot;up&quot;);

			$(document).off(&quot;click.&quot; + tableId, closePopup);

			window.clearTimeout(closeTimeout);
			closeTimeout = window.setTimeout(function() {
				$(document).on(&quot;click.&quot; + 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;

		// Fix for iOS not rendering shadows correctly when using `-webkit-overflow-scrolling`
		var $overflow = this.$table.closest(&quot;.tablesaw-overflow&quot;);
		if ($overflow.css(&quot;-webkit-overflow-scrolling&quot;)) {
			var timeout;
			$overflow.on(&quot;scroll&quot;, function() {
				var $div = $(this);
				window.clearTimeout(timeout);
				timeout = window.setTimeout(function() {
					$div.css(&quot;-webkit-overflow-scrolling&quot;, &quot;auto&quot;);
					window.setTimeout(function() {
						$div.css(&quot;-webkit-overflow-scrolling&quot;, &quot;touch&quot;);
					}, 0);
				}, 100);
			});
		}

		$(window).on(Tablesaw.events.resize + &quot;.&quot; + tableId, function() {
			self.refreshToggle();
		});

		this.initSet();
		this.refreshToggle();
	};

	ColumnToggle.prototype.getHeaderFromCheckbox = function(checkbox) {
		return $(checkbox).data(&quot;tablesaw-header&quot;);
	};

	ColumnToggle.prototype.refreshToggle = function() {
		var self = this;
		var invisibleColumns = 0;
		this.$menu.find(&quot;input&quot;).each(function() {
			var header = self.getHeaderFromCheckbox(this);
			this.checked =
				self.tablesaw
					._$getCells(header)
					.eq(0)
					.css(&quot;display&quot;) === &quot;table-cell&quot;;
		});

		this.updateColspanCells();
	};

	ColumnToggle.prototype.updateColspanCells = function(header, userAction) {
		this.tablesaw.updateColspanCells(&quot;tablesaw-toggle-cellhidden&quot;, header, userAction);
	};

	ColumnToggle.prototype.destroy = function() {
		this.$table.removeClass(this.classes.columnToggleTable);
		this.$table.find(&quot;th, td&quot;).each(function() {
			var $cell = $(this);
			$cell.removeClass(&quot;tablesaw-toggle-cellhidden&quot;).removeClass(&quot;tablesaw-toggle-cellvisible&quot;);

			this.className = this.className.replace(/\bui\-table\-priority\-\d\b/g, &quot;&quot;);
		});
	};

	// on tablecreate, init
	$(document).on(Tablesaw.events.create, function(e, tablesaw) {
		if (tablesaw.mode === &quot;columntoggle&quot;) {
			var table = new ColumnToggle(tablesaw.table);
			table.init();
		}
	});

	$(document).on(Tablesaw.events.destroy, function(e, tablesaw) {
		if (tablesaw.mode === &quot;columntoggle&quot;) {
			$(tablesaw.table)
				.data(data.key)
				.destroy();
		}
	});

	$(document).on(Tablesaw.events.refresh, function(e, tablesaw) {
		if (tablesaw.mode === &quot;columntoggle&quot;) {
			$(tablesaw.table)
				.data(data.key)
				.refreshToggle();
		}
	});

	Tablesaw.ColumnToggle = ColumnToggle;
})();

(function() {
	function getSortValue(cell) {
		var text = [];
		$(cell.childNodes).each(function() {
			var $el = $(this);
			if ($el.is(&quot;input, select&quot;)) {
				text.push($el.val());
			} else if ($el.is(&quot;.tablesaw-cell-label&quot;)) {
			} else {
				text.push(($el.text() || &quot;&quot;).replace(/^\s+|\s+$/g, &quot;&quot;));
			}
		});

		return text.join(&quot;&quot;);
	}

	var pluginName = &quot;tablesaw-sortable&quot;,
		initSelector = &quot;table[data-&quot; + pluginName + &quot;]&quot;,
		sortableSwitchSelector = &quot;[data-&quot; + pluginName + &quot;-switch]&quot;,
		attrs = {
			sortCol: &quot;data-tablesaw-sortable-col&quot;,
			defaultCol: &quot;data-tablesaw-sortable-default-col&quot;,
			numericCol: &quot;data-tablesaw-sortable-numeric&quot;,
			subRow: &quot;data-tablesaw-subrow&quot;,
			ignoreRow: &quot;data-tablesaw-ignorerow&quot;
		},
		classes = {
			head: pluginName + &quot;-head&quot;,
			ascend: pluginName + &quot;-ascending&quot;,
			descend: pluginName + &quot;-descending&quot;,
			switcher: pluginName + &quot;-switch&quot;,
			tableToolbar: &quot;tablesaw-bar-section&quot;,
			sortButton: pluginName + &quot;-btn&quot;
		},
		methods = {
			_create: function(o) {
				return $(this).each(function() {
					var init = $(this).data(pluginName + &quot;-init&quot;);
					if (init) {
						return false;
					}
					$(this)
						.data(pluginName + &quot;-init&quot;, true)
						.trigger(&quot;beforecreate.&quot; + pluginName)
						[pluginName](&quot;_init&quot;, o)
						.trigger(&quot;create.&quot; + pluginName);
				});
			},
			_init: function() {
				var el = $(this);
				var tblsaw = el.data(&quot;tablesaw&quot;);
				var heads;
				var $switcher;

				function addClassToHeads(h) {
					$.each(h, function(i, v) {
						$(v).addClass(classes.head);
					});
				}

				function makeHeadsActionable(h, fn) {
					$.each(h, function(i, col) {
						var b = $(&quot;&lt;button class='&quot; + classes.sortButton + &quot;'/&gt;&quot;);
						b.on(&quot;click&quot;, { col: col }, fn);
						$(col)
							.wrapInner(b)
							.find(&quot;button&quot;)
							.append(&quot;&lt;span class='tablesaw-sortable-arrow'&gt;&quot;);
					});
				}

				function clearOthers(headcells) {
					$.each(headcells, function(i, v) {
						var col = $(v);
						col.removeAttr(attrs.defaultCol);
						col.removeClass(classes.ascend);
						col.removeClass(classes.descend);
					});
				}

				function headsOnAction(e) {
					if ($(e.target).is(&quot;a[href]&quot;)) {
						return;
					}

					e.stopPropagation();
					var headCell = $(e.target).closest(&quot;[&quot; + attrs.sortCol + &quot;]&quot;),
						v = e.data.col,
						newSortValue = heads.index(headCell[0]);

					clearOthers(
						headCell
							.closest(&quot;thead&quot;)
							.find(&quot;th&quot;)
							.filter(function() {
								return this !== headCell[0];
							})
					);
					if (headCell.is(&quot;.&quot; + classes.descend) || !headCell.is(&quot;.&quot; + classes.ascend)) {
						el[pluginName](&quot;sortBy&quot;, v, true);
						newSortValue += &quot;_asc&quot;;
					} else {
						el[pluginName](&quot;sortBy&quot;, v);
						newSortValue += &quot;_desc&quot;;
					}
					if ($switcher) {
						$switcher
							.find(&quot;select&quot;)
							.val(newSortValue)
							.trigger(&quot;refresh&quot;);
					}

					e.preventDefault();
				}

				function handleDefault(heads) {
					$.each(heads, function(idx, el) {
						var $el = $(el);
						if ($el.is(&quot;[&quot; + attrs.defaultCol + &quot;]&quot;)) {
							if (!$el.is(&quot;.&quot; + classes.descend)) {
								$el.addClass(classes.ascend);
							}
						}
					});
				}

				function addSwitcher(heads) {
					$switcher = $(&quot;&lt;div&gt;&quot;)
						.addClass(classes.switcher)
						.addClass(classes.tableToolbar);

					var html = [&quot;&lt;label&gt;&quot; + Tablesaw.i18n.sort + &quot;:&quot;];

					// TODO next major version: remove .btn
					html.push('&lt;span class=&quot;btn tablesaw-btn&quot;&gt;&lt;select&gt;');
					heads.each(function(j) {
						var $t = $(this);
						var isDefaultCol = $t.is(&quot;[&quot; + attrs.defaultCol + &quot;]&quot;);
						var isDescending = $t.is(&quot;.&quot; + classes.descend);

						var hasNumericAttribute = $t.is(&quot;[&quot; + attrs.numericCol + &quot;]&quot;);
						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(attrs.numericCol, isNumeric ? &quot;&quot; : &quot;false&quot;);
						}

						html.push(
							&quot;&lt;option&quot; +
								(isDefaultCol &amp;&amp; !isDescending ? &quot; selected&quot; : &quot;&quot;) +
								' value=&quot;' +
								j +
								'_asc&quot;&gt;' +
								$t.text() +
								&quot; &quot; +
								(isNumeric ? &quot;&amp;#x2191;&quot; : &quot;(A-Z)&quot;) +
								&quot;&lt;/option&gt;&quot;
						);
						html.push(
							&quot;&lt;option&quot; +
								(isDefaultCol &amp;&amp; isDescending ? &quot; selected&quot; : &quot;&quot;) +
								' value=&quot;' +
								j +
								'_desc&quot;&gt;' +
								$t.text() +
								&quot; &quot; +
								(isNumeric ? &quot;&amp;#x2193;&quot; : &quot;(Z-A)&quot;) +
								&quot;&lt;/option&gt;&quot;
						);
					});
					html.push(&quot;&lt;/select&gt;&lt;/span&gt;&lt;/label&gt;&quot;);

					$switcher.html(html.join(&quot;&quot;));

					var $firstChild = tblsaw.$toolbar.children().eq(0);
					if ($firstChild.length) {
						$switcher.insertBefore($firstChild);
					} else {
						$switcher.appendTo(tblsaw.$toolbar);
					}
					$switcher.find(&quot;.tablesaw-btn&quot;).tablesawbtn();
					$switcher.find(&quot;select&quot;).on(&quot;change&quot;, function() {
						var val = $(this)
								.val()
								.split(&quot;_&quot;),
							head = heads.eq(val[0]);

						clearOthers(head.siblings());
						el[pluginName](&quot;sortBy&quot;, head.get(0), val[1] === &quot;asc&quot;);
					});
				}

				el.addClass(pluginName);

				heads = el
					.children()
					.filter(&quot;thead&quot;)
					.find(&quot;th[&quot; + attrs.sortCol + &quot;]&quot;);

				addClassToHeads(heads);
				makeHeadsActionable(heads, headsOnAction);
				handleDefault(heads);

				if (el.is(sortableSwitchSelector)) {
					addSwitcher(heads);
				}
			},
			sortRows: function(rows, colNum, ascending, col, tbody) {
				function convertCells(cellArr, belongingToTbody) {
					var cells = [];
					$.each(cellArr, function(i, cell) {
						var row = cell.parentNode;
						var $row = $(row);
						// next row is a subrow
						var subrows = [];
						var $next = $row.next();
						while ($next.is(&quot;[&quot; + attrs.subRow + &quot;]&quot;)) {
							subrows.push($next[0]);
							$next = $next.next();
						}

						var tbody = row.parentNode;

						// current row is a subrow
						if ($row.is(&quot;[&quot; + attrs.subRow + &quot;]&quot;)) {
						} else if (tbody === belongingToTbody) {
							cells.push({
								element: cell,
								cell: getSortValue(cell),
								row: row,
								subrows: subrows.length ? subrows : null,
								ignored: $row.is(&quot;[&quot; + attrs.ignoreRow + &quot;]&quot;)
							});
						}
					});
					return cells;
				}

				function getSortFxn(ascending, forceNumeric) {
					var fn,
						regex = /[^\-\+\d\.]/g;
					if (ascending) {
						fn = function(a, b) {
							if (a.ignored || b.ignored) {
								return 0;
							}
							if (forceNumeric) {
								return (
									parseFloat(a.cell.replace(regex, &quot;&quot;)) - parseFloat(b.cell.replace(regex, &quot;&quot;))
								);
							} else {
								return a.cell.toLowerCase() &gt; b.cell.toLowerCase() ? 1 : -1;
							}
						};
					} else {
						fn = function(a, b) {
							if (a.ignored || b.ignored) {
								return 0;
							}
							if (forceNumeric) {
								return (
									parseFloat(b.cell.replace(regex, &quot;&quot;)) - parseFloat(a.cell.replace(regex, &quot;&quot;))
								);
							} else {
								return a.cell.toLowerCase() &lt; b.cell.toLowerCase() ? 1 : -1;
							}
						};
					}
					return fn;
				}

				function convertToRows(sorted) {
					var newRows = [],
						i,
						l;
					for (i = 0, l = sorted.length; i &lt; l; i++) {
						newRows.push(sorted[i].row);
						if (sorted[i].subrows) {
							newRows.push(sorted[i].subrows);
						}
					}
					return newRows;
				}

				var fn;
				var sorted;
				var cells = convertCells(col.cells, tbody);

				var customFn = $(col).data(&quot;tablesaw-sort&quot;);

				fn =
					(customFn &amp;&amp; typeof customFn === &quot;function&quot; ? customFn(ascending) : false) ||
					getSortFxn(
						ascending,
						$(col).is(&quot;[&quot; + attrs.numericCol + &quot;]&quot;) &amp;&amp;
							!$(col).is(&quot;[&quot; + attrs.numericCol + '=&quot;false&quot;]')
					);

				sorted = cells.sort(fn);

				rows = convertToRows(sorted);

				return 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);
				var colNum;
				var tbl = el.data(&quot;tablesaw&quot;);
				tbl.$tbody.each(function() {
					var tbody = this;
					var $tbody = $(this);
					var rows = tbl.getBodyRows(tbody);
					var sortedRows;
					var map = tbl.headerMapping[0];
					var j, k;

					// find the column number that we’re sorting
					for (j = 0, k = map.length; j &lt; k; j++) {
						if (map[j] === col) {
							colNum = j;
							break;
						}
					}

					sortedRows = el[pluginName](&quot;sortRows&quot;, rows, colNum, ascending, col, tbody);

					// replace Table rows
					for (j = 0, k = sortedRows.length; j &lt; k; j++) {
						$tbody.append(sortedRows[j]);
					}
				});

				el[pluginName](&quot;makeColDefault&quot;, col, ascending);

				el.trigger(&quot;tablesaw-sorted&quot;);
			}
		};

	// 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;-active&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(Tablesaw.events.create, function(e, Tablesaw) {
		if (Tablesaw.$table.is(initSelector)) {
			Tablesaw.$table[pluginName]();
		}
	});

	// TODO OOP this and add to Tablesaw object
})();

(function() {
	var classes = {
		hideBtn: &quot;disabled&quot;,
		persistWidths: &quot;tablesaw-fix-persist&quot;,
		hiddenCol: &quot;tablesaw-swipe-cellhidden&quot;,
		persistCol: &quot;tablesaw-swipe-cellpersist&quot;,
		allColumnsVisible: &quot;tablesaw-all-cols-visible&quot;
	};
	var attrs = {
		disableTouchEvents: &quot;data-tablesaw-no-touch&quot;,
		ignorerow: &quot;data-tablesaw-ignorerow&quot;,
		subrow: &quot;data-tablesaw-subrow&quot;
	};

	function createSwipeTable(tbl, $table) {
		var tblsaw = $table.data(&quot;tablesaw&quot;);

		var $btns = $(&quot;&lt;div class='tablesaw-advance'&gt;&lt;/div&gt;&quot;);
		// TODO next major version: remove .btn
		var $prevBtn = $(
			&quot;&lt;a href='#' class='btn tablesaw-nav-btn tablesaw-btn btn-micro left'&gt;&quot; +
				Tablesaw.i18n.swipePreviousColumn +
				&quot;&lt;/a&gt;&quot;
		).appendTo($btns);
		// TODO next major version: remove .btn
		var $nextBtn = $(
			&quot;&lt;a href='#' class='btn tablesaw-nav-btn tablesaw-btn btn-micro right'&gt;&quot; +
				Tablesaw.i18n.swipeNextColumn +
				&quot;&lt;/a&gt;&quot;
		).appendTo($btns);

		var $headerCells = tbl._getPrimaryHeaderCells();
		var $headerCellsNoPersist = $headerCells.not('[data-tablesaw-priority=&quot;persist&quot;]');
		var headerWidths = [];
		var headerWidthsNoPersist = [];
		var $head = $(document.head || &quot;head&quot;);
		var tableId = $table.attr(&quot;id&quot;);

		if (!$headerCells.length) {
			throw new Error(&quot;tablesaw swipe: no header cells found.&quot;);
		}

		$table.addClass(&quot;tablesaw-swipe&quot;);

		function initMinHeaderWidths() {
			$table.css({
				width: &quot;1px&quot;
			});

			// remove any hidden columns
			$table.find(&quot;.&quot; + classes.hiddenCol).removeClass(classes.hiddenCol);

			headerWidths = [];
			headerWidthsNoPersist = [];
			// Calculate initial widths
			$headerCells.each(function() {
				var width = this.offsetWidth;
				headerWidths.push(width);
				if (!isPersistent(this)) {
					headerWidthsNoPersist.push(width);
				}
			});

			// reset props
			$table.css({
				width: &quot;&quot;
			});
		}

		initMinHeaderWidths();

		$btns.appendTo(tblsaw.$toolbar);

		if (!tableId) {
			tableId = &quot;tableswipe-&quot; + Math.round(Math.random() * 10000);
			$table.attr(&quot;id&quot;, tableId);
		}

		function showColumn(headerCell) {
			tblsaw._$getCells(headerCell).removeClass(classes.hiddenCol);
		}

		function hideColumn(headerCell) {
			tblsaw._$getCells(headerCell).addClass(classes.hiddenCol);
		}

		function persistColumn(headerCell) {
			tblsaw._$getCells(headerCell).addClass(classes.persistCol);
		}

		function isPersistent(headerCell) {
			return $(headerCell).is('[data-tablesaw-priority=&quot;persist&quot;]');
		}

		function unmaintainWidths() {
			$table.removeClass(classes.persistWidths);
			$(&quot;#&quot; + tableId + &quot;-persist&quot;).remove();
		}

		function maintainWidths() {
			var prefix = &quot;#&quot; + tableId + &quot;.tablesaw-swipe &quot;;
			var styles = [];
			var tableWidth = $table.width();
			var tableWidthNoPersistantColumns = tableWidth;
			var hash = [];
			var newHash;

			// save persistent column widths (as long as they take up less than 75% of table width)
			$headerCells.each(function(index) {
				var width;
				if (isPersistent(this)) {
					width = this.offsetWidth;
					tableWidthNoPersistantColumns -= width;

					if (width &lt; tableWidth * 0.75) {
						hash.push(index + &quot;-&quot; + width);
						styles.push(
							prefix +
								&quot; .&quot; +
								classes.persistCol +
								&quot;:nth-child(&quot; +
								(index + 1) +
								&quot;) { width: &quot; +
								width +
								&quot;px; }&quot;
						);
					}
				}
			});
			newHash = hash.join(&quot;_&quot;);

			if (styles.length) {
				$table.addClass(classes.persistWidths);
				var $style = $(&quot;#&quot; + tableId + &quot;-persist&quot;);
				// If style element not yet added OR if the widths have changed
				if (!$style.length || $style.data(&quot;tablesaw-hash&quot;) !== newHash) {
					// Remove existing
					$style.remove();

					$(&quot;&lt;style&gt;&quot; + styles.join(&quot;\n&quot;) + &quot;&lt;/style&gt;&quot;)
						.attr(&quot;id&quot;, tableId + &quot;-persist&quot;)
						.data(&quot;tablesaw-hash&quot;, newHash)
						.appendTo($head);
				}
			}

			return tableWidthNoPersistantColumns;
		}

		function getNext() {
			var next = [];
			var checkFound;
			$headerCellsNoPersist.each(function(i) {
				var $t = $(this);
				var isHidden = $t.css(&quot;display&quot;) === &quot;none&quot; || $t.is(&quot;.&quot; + classes.hiddenCol);

				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 canNavigate(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 window &amp;&amp; window.matchMedia(matchMedia).matches);
		}

		function fakeBreakpoints() {
			if (!matchesMedia()) {
				return;
			}

			var 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];
				sums.push(sum);

				// is persistent or is hidden
				if (isPersist || sum &gt; containerWidth) {
					visibleNonPersistantCount--;
				}
			});

			// We need at least one column to swipe.
			var needsNonPersistentColumn = visibleNonPersistantCount === 0;

			$headerCells.each(function(index) {
				if (sums[index] &gt; containerWidth) {
					hideColumn(this);
				}
			});

			var firstPersist = true;
			$headerCells.each(function(index) {
				if (persist[index]) {
					// for visual box-shadow
					persistColumn(this);

					if (firstPersist) {
						tblsaw._$getCells(this).css(&quot;width&quot;, sums[index] + &quot;px&quot;);
						firstPersist = false;
					}
					return;
				}

				if (sums[index] &lt;= containerWidth || needsNonPersistentColumn) {
					needsNonPersistentColumn = false;
					showColumn(this);
					tblsaw.updateColspanCells(classes.hiddenCol, this, true);
				}
			});

			unmaintainWidths();

			$table.trigger(&quot;tablesawcolumns&quot;);
		}

		function goForward() {
			navigate(true);
		}
		function goBackward() {
			navigate(false);
		}

		function navigate(isNavigateForward) {
			var pair;
			if (isNavigateForward) {
				pair = getNext();
			} else {
				pair = getPrev();
			}

			if (canNavigate(pair)) {
				if (isNaN(pair[0])) {
					if (isNavigateForward) {
						pair[0] = 0;
					} else {
						pair[0] = $headerCellsNoPersist.length - 1;
					}
				}

				var roomForColumnsWidth = maintainWidths();
				var hideColumnIndex = pair[0];
				var showColumnIndex = pair[1];

				// Hide one column, show one or more based on how much space was freed up
				var columnToShow;
				var columnToHide = $headerCellsNoPersist.get(hideColumnIndex);
				var wasAtLeastOneColumnShown = false;
				var atLeastOneColumnIsVisible = false;

				hideColumn(columnToHide);
				tblsaw.updateColspanCells(classes.hiddenCol, columnToHide, true);

				var columnIndex = hideColumnIndex + (isNavigateForward ? 1 : -1);
				while (columnIndex &gt;= 0 &amp;&amp; columnIndex &lt; headerWidthsNoPersist.length) {
					roomForColumnsWidth -= headerWidthsNoPersist[columnIndex];

					var $columnToShow = $headerCellsNoPersist.eq(columnIndex);
					if ($columnToShow.is(&quot;.tablesaw-swipe-cellhidden&quot;)) {
						if (roomForColumnsWidth &gt; 0) {
							columnToShow = $columnToShow.get(0);
							wasAtLeastOneColumnShown = true;
							atLeastOneColumnIsVisible = true;
							showColumn(columnToShow);
							tblsaw.updateColspanCells(classes.hiddenCol, columnToShow, false);
						}
					} else {
						atLeastOneColumnIsVisible = true;
					}

					if (isNavigateForward) {
						columnIndex++;
					} else {
						columnIndex--;
					}
				}

				if (!atLeastOneColumnIsVisible) {
					// if no columns are showing, at least show the first one we were aiming for.
					columnToShow = $headerCellsNoPersist.get(showColumnIndex);
					showColumn(columnToShow);
					tblsaw.updateColspanCells(classes.hiddenCol, columnToShow, false);
				} else if (
					!wasAtLeastOneColumnShown &amp;&amp;
					canNavigate(isNavigateForward ? getNext() : getPrev())
				) {
					// if our one new column was hidden but no new columns were shown, let’s navigate again automatically.
					navigate(isNavigateForward);
				}
				$table.trigger(&quot;tablesawcolumns&quot;);
			}
		}

		$prevBtn.add($nextBtn).on(&quot;click&quot;, function(e) {
			if (!!$(e.target).closest($nextBtn).length) {
				goForward();
			} else {
				goBackward();
			}
			e.preventDefault();
		});

		function getCoord(event, key) {
			return (event.touches || event.originalEvent.touches)[0][key];
		}

		if (!$table.is(&quot;[&quot; + attrs.disableTouchEvents + &quot;]&quot;)) {
			$table.on(&quot;touchstart.swipetoggle&quot;, function(e) {
				var originX = getCoord(e, &quot;pageX&quot;);
				var originY = getCoord(e, &quot;pageY&quot;);
				var x;
				var y;
				var scrollTop = window.pageYOffset;

				$(window).off(Tablesaw.events.resize, fakeBreakpoints);

				$(this)
					.on(&quot;touchmove.swipetoggle&quot;, function(e) {
						x = getCoord(e, &quot;pageX&quot;);
						y = getCoord(e, &quot;pageY&quot;);
					})
					.on(&quot;touchend.swipetoggle&quot;, function() {
						var cfg = tbl.getConfig({
							swipeHorizontalThreshold: 30,
							swipeVerticalThreshold: 30
						});

						// This config code is a little awkward because shoestring doesn’t support deep $.extend
						// Trying to work around when devs only override one of (not both) horizontalThreshold or
						// verticalThreshold in their TablesawConfig.
						// @TODO major version bump: remove cfg.swipe, move to just use the swipePrefix keys
						var verticalThreshold = cfg.swipe
							? cfg.swipe.verticalThreshold
							: cfg.swipeVerticalThreshold;
						var horizontalThreshold = cfg.swipe
							? cfg.swipe.horizontalThreshold
							: cfg.swipeHorizontalThreshold;

						var isPageScrolled = Math.abs(window.pageYOffset - scrollTop) &gt;= verticalThreshold;
						var isVerticalSwipe = Math.abs(y - originY) &gt;= verticalThreshold;

						if (!isVerticalSwipe &amp;&amp; !isPageScrolled) {
							if (x - originX &lt; -1 * horizontalThreshold) {
								goForward();
							}
							if (x - originX &gt; horizontalThreshold) {
								goBackward();
							}
						}

						window.setTimeout(function() {
							$(window).on(Tablesaw.events.resize, fakeBreakpoints);
						}, 300);

						$(this).off(&quot;touchmove.swipetoggle touchend.swipetoggle&quot;);
					});
			});
		}

		$table
			.on(&quot;tablesawcolumns.swipetoggle&quot;, function() {
				var canGoPrev = canNavigate(getPrev());
				var canGoNext = canNavigate(getNext());
				$prevBtn[canGoPrev ? &quot;removeClass&quot; : &quot;addClass&quot;](classes.hideBtn);
				$nextBtn[canGoNext ? &quot;removeClass&quot; : &quot;addClass&quot;](classes.hideBtn);

				tblsaw.$toolbar[!canGoPrev &amp;&amp; !canGoNext ? &quot;addClass&quot; : &quot;removeClass&quot;](
					classes.allColumnsVisible
				);
			})
			.on(&quot;tablesawnext.swipetoggle&quot;, function() {
				goForward();
			})
			.on(&quot;tablesawprev.swipetoggle&quot;, function() {
				goBackward();
			})
			.on(Tablesaw.events.destroy + &quot;.swipetoggle&quot;, function() {
				var $t = $(this);

				$t.removeClass(&quot;tablesaw-swipe&quot;);
				tblsaw.$toolbar.find(&quot;.tablesaw-advance&quot;).remove();
				$(window).off(Tablesaw.events.resize, fakeBreakpoints);

				$t.off(&quot;.swipetoggle&quot;);
			})
			.on(Tablesaw.events.refresh, function() {
				unmaintainWidths();
				initMinHeaderWidths();
				fakeBreakpoints();
			});

		fakeBreakpoints();
		$(window).on(Tablesaw.events.resize, fakeBreakpoints);
	}

	// on tablecreate, init
	$(document).on(Tablesaw.events.create, function(e, tablesaw) {
		if (tablesaw.mode === &quot;swipe&quot;) {
			createSwipeTable(tablesaw, tablesaw.$table);
		}
	});

	// TODO OOP this and add to Tablesaw object
})();

(function() {
	var MiniMap = {
		attr: {
			init: &quot;data-tablesaw-minimap&quot;
		},
		show: function(table) {
			var mq = table.getAttribute(MiniMap.attr.init);

			if (mq === &quot;&quot;) {
				// value-less but exists
				return true;
			} else if (mq &amp;&amp; &quot;matchMedia&quot; in window) {
				// has a mq value
				return window.matchMedia(mq).matches;
			}

			return false;
		}
	};

	function createMiniMap($table) {
		var tblsaw = $table.data(&quot;tablesaw&quot;);
		var $btns = $('&lt;div class=&quot;tablesaw-advance minimap&quot;&gt;');
		var $dotNav = $('&lt;ul class=&quot;tablesaw-advance-dots&quot;&gt;').appendTo($btns);
		var hideDot = &quot;tablesaw-advance-dots-hide&quot;;
		var $headerCells = $table.data(&quot;tablesaw&quot;)._getPrimaryHeaderCells();

		// populate dots
		$headerCells.each(function() {
			$dotNav.append(&quot;&lt;li&gt;&lt;i&gt;&lt;/i&gt;&lt;/li&gt;&quot;);
		});

		$btns.appendTo(tblsaw.$toolbar);

		function showHideNav() {
			if (!MiniMap.show($table[0])) {
				$btns.css(&quot;display&quot;, &quot;none&quot;);
				return;
			}
			$btns.css(&quot;display&quot;, &quot;block&quot;);

			// 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();
		$(window).on(Tablesaw.events.resize, showHideNav);

		$table
			.on(&quot;tablesawcolumns.minimap&quot;, function() {
				showHideNav();
			})
			.on(Tablesaw.events.destroy + &quot;.minimap&quot;, function() {
				var $t = $(this);

				tblsaw.$toolbar.find(&quot;.tablesaw-advance&quot;).remove();
				$(window).off(Tablesaw.events.resize, showHideNav);

				$t.off(&quot;.minimap&quot;);
			});
	}

	// on tablecreate, init
	$(document).on(Tablesaw.events.create, function(e, tablesaw) {
		if (
			(tablesaw.mode === &quot;swipe&quot; || tablesaw.mode === &quot;columntoggle&quot;) &amp;&amp;
			tablesaw.$table.is(&quot;[ &quot; + MiniMap.attr.init + &quot;]&quot;)
		) {
			createMiniMap(tablesaw.$table);
		}
	});

	// TODO OOP this better
	Tablesaw.MiniMap = MiniMap;
})();

(function() {
	var S = {
		selectors: {
			init: &quot;table[data-tablesaw-mode-switch]&quot;
		},
		attributes: {
			excludeMode: &quot;data-tablesaw-mode-exclude&quot;
		},
		classes: {
			main: &quot;tablesaw-modeswitch&quot;,
			toolbar: &quot;tablesaw-bar-section&quot;
		},
		modes: [&quot;stack&quot;, &quot;swipe&quot;, &quot;columntoggle&quot;],
		init: function(table) {
			var $table = $(table);
			var tblsaw = $table.data(&quot;tablesaw&quot;);
			var ignoreMode = $table.attr(S.attributes.excludeMode);
			var $toolbar = tblsaw.$toolbar;
			var $switcher = $(&quot;&lt;div&gt;&quot;).addClass(S.classes.main + &quot; &quot; + S.classes.toolbar);

			var html = [
					'&lt;label&gt;&lt;span class=&quot;abbreviated&quot;&gt;' +
						Tablesaw.i18n.modeSwitchColumnsAbbreviated +
						'&lt;/span&gt;&lt;span class=&quot;longform&quot;&gt;' +
						Tablesaw.i18n.modeSwitchColumns +
						&quot;&lt;/span&gt;:&quot;
				],
				dataMode = $table.attr(&quot;data-tablesaw-mode&quot;),
				isSelected;

			// TODO next major version: remove .btn
			html.push('&lt;span class=&quot;btn tablesaw-btn&quot;&gt;&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];

				html.push(
					&quot;&lt;option&quot; +
						(isSelected ? &quot; selected&quot; : &quot;&quot;) +
						' value=&quot;' +
						S.modes[j] +
						'&quot;&gt;' +
						Tablesaw.i18n.modes[j] +
						&quot;&lt;/option&gt;&quot;
				);
			}
			html.push(&quot;&lt;/select&gt;&lt;/span&gt;&lt;/label&gt;&quot;);

			$switcher.html(html.join(&quot;&quot;));

			var $otherToolbarItems = $toolbar.find(&quot;.tablesaw-advance&quot;).eq(0);
			if ($otherToolbarItems.length) {
				$switcher.insertBefore($otherToolbarItems);
			} else {
				$switcher.appendTo($toolbar);
			}

			$switcher.find(&quot;.tablesaw-btn&quot;).tablesawbtn();
			$switcher.find(&quot;select&quot;).on(&quot;change&quot;, function(event) {
				return S.onModeChange.call(table, event, $(this).val());
			});
		},
		onModeChange: function(event, val) {
			var $table = $(this);
			var tblsaw = $table.data(&quot;tablesaw&quot;);
			var $switcher = tblsaw.$toolbar.find(&quot;.&quot; + S.classes.main);

			$switcher.remove();
			tblsaw.destroy();

			$table.attr(&quot;data-tablesaw-mode&quot;, val);
			$table.tablesaw();
		}
	};

	$(document).on(Tablesaw.events.create, function(e, Tablesaw) {
		if (Tablesaw.$table.is(S.selectors.init)) {
			S.init(Tablesaw.table);
		}
	});

	// TODO OOP this and add to Tablesaw object
})();

(function() {
	var pluginName = &quot;tablesawCheckAll&quot;;

	function CheckAll(tablesaw) {
		this.tablesaw = tablesaw;
		this.$table = tablesaw.$table;

		this.attr = &quot;data-tablesaw-checkall&quot;;
		this.checkAllSelector = &quot;[&quot; + this.attr + &quot;]&quot;;
		this.forceCheckedSelector = &quot;[&quot; + this.attr + &quot;-checked]&quot;;
		this.forceUncheckedSelector = &quot;[&quot; + this.attr + &quot;-unchecked]&quot;;
		this.checkboxSelector = 'input[type=&quot;checkbox&quot;]';

		this.$triggers = null;
		this.$checkboxes = null;

		if (this.$table.data(pluginName)) {
			return;
		}
		this.$table.data(pluginName, this);
		this.init();
	}

	CheckAll.prototype._filterCells = function($checkboxes) {
		return $checkboxes
			.filter(function() {
				return !$(this)
					.closest(&quot;tr&quot;)
					.is(&quot;[data-tablesaw-subrow],[data-tablesaw-ignorerow]&quot;);
			})
			.find(this.checkboxSelector)
			.not(this.checkAllSelector);
	};

	// With buttons you can use a scoping selector like: data-tablesaw-checkall=&quot;#my-scoped-id input[type='checkbox']&quot;
	CheckAll.prototype.getCheckboxesForButton = function(button) {
		return this._filterCells($($(button).attr(this.attr)));
	};

	CheckAll.prototype.getCheckboxesForCheckbox = function(checkbox) {
		return this._filterCells($($(checkbox).closest(&quot;th&quot;)[0].cells));
	};

	CheckAll.prototype.init = function() {
		var self = this;
		this.$table.find(this.checkAllSelector).each(function() {
			var $trigger = $(this);
			if ($trigger.is(self.checkboxSelector)) {
				self.addCheckboxEvents(this);
			} else {
				self.addButtonEvents(this);
			}
		});
	};

	CheckAll.prototype.addButtonEvents = function(trigger) {
		var self = this;

		// Update body checkboxes when header checkbox is changed
		$(trigger).on(&quot;click&quot;, function(event) {
			event.preventDefault();

			var $checkboxes = self.getCheckboxesForButton(this);

			var allChecked = true;
			$checkboxes.each(function() {
				if (!this.checked) {
					allChecked = false;
				}
			});

			var setChecked;
			if ($(this).is(self.forceCheckedSelector)) {
				setChecked = true;
			} else if ($(this).is(self.forceUncheckedSelector)) {
				setChecked = false;
			} else {
				setChecked = allChecked ? false : true;
			}

			$checkboxes.each(function() {
				this.checked = setChecked;

				$(this).trigger(&quot;change.&quot; + pluginName);
			});
		});
	};

	CheckAll.prototype.addCheckboxEvents = function(trigger) {
		var self = this;

		// Update body checkboxes when header checkbox is changed
		$(trigger).on(&quot;change&quot;, function() {
			var setChecked = this.checked;

			self.getCheckboxesForCheckbox(this).each(function() {
				this.checked = setChecked;
			});
		});

		var $checkboxes = self.getCheckboxesForCheckbox(trigger);

		// Update header checkbox when body checkboxes are changed
		$checkboxes.on(&quot;change.&quot; + pluginName, function() {
			var checkedCount = 0;
			$checkboxes.each(function() {
				if (this.checked) {
					checkedCount++;
				}
			});

			var allSelected = checkedCount === $checkboxes.length;

			trigger.checked = allSelected;

			// only indeterminate if some are selected (not all and not none)
			trigger.indeterminate = checkedCount !== 0 &amp;&amp; !allSelected;
		});
	};

	// on tablecreate, init
	$(document).on(Tablesaw.events.create, function(e, tablesaw) {
		new CheckAll(tablesaw);
	});

	Tablesaw.CheckAll = CheckAll;
})();

	return Tablesaw;
}));
</textarea><br>
    <input type="submit" value="Save">
</form>