jquery-tablesorter 1.18.1 → 1.18.2

data/vendor/assets/javascripts/jquery-tablesorter/widgets/widget-columnSelector.js

@@ -1,4 +1,4 @@
-/* Widget: columnSelector (responsive table widget) - updated 8/17/2015 (v2.23.0) *//*
+/* Widget: columnSelector (responsive table widget) - updated 8/23/2015 (v2.23.2) *//*
  * Requires tablesorter v2.8+ and jQuery 1.7+
  * by Justin Hallett & Rob Garrison
  */
@@ -224,7 +224,7 @@
 			}
 			// trigger columnUpdate if auto is true (it gets skipped in updateCols()
 			if (colSel.auto) {
-				c.$table.trigger('columnUpdate');
+				c.$table.trigger(wo.columnSelector_updated);
 			}
 		},
 
@@ -299,7 +299,7 @@
 			if (wo.columnSelector_saveColumns && ts.storage) {
 				ts.storage( c.$table[0], 'tablesorter-columnSelector', colSel.states );
 			}
-			c.$table.trigger('columnUpdate');
+			c.$table.trigger(wo.columnSelector_updated);
 		},
 
 		attachTo : function(table, elm) {
@@ -370,7 +370,9 @@
 			columnSelector_priority : 'data-priority',
 			// class name added to checked checkboxes - this fixes an issue with Chrome not updating FontAwesome
 			// applied icons; use this class name (input.checked) instead of input:checked
-			columnSelector_cssChecked : 'checked'
+			columnSelector_cssChecked : 'checked',
+			// event triggered when columnSelector completes
+			columnSelector_updated : 'columnUpdate'
 
 		},
 		init: function(table, thisWidget, c, wo) {

data/vendor/assets/javascripts/jquery-tablesorter/widgets/widget-filter.js

@@ -1,11 +1,12 @@
-/*! Widget: filter - updated 8/17/2015 (v2.23.0) *//*
+/*! Widget: filter - updated 8/23/2015 (v2.23.2) *//*
  * Requires tablesorter v2.8+ and jQuery 1.7+
  * by Rob Garrison
  */
 ;( function ( $ ) {
 	'use strict';
-	var ts = $.tablesorter || {},
-	tscss = ts.css;
+	var tsf,
+		ts = $.tablesorter || {},
+		tscss = ts.css;
 
 	$.extend( tscss, {
 		filterRow      : 'tablesorter-filter-row',
@@ -49,7 +50,7 @@
 		},
 		format: function( table, c, wo ) {
 			if ( !c.$table.hasClass( 'hasFilters' ) ) {
-				ts.filter.init( table, c, wo );
+				tsf.init( table, c, wo );
 			}
 		},
 		remove: function( table, c, wo, refreshing ) {
@@ -61,7 +62,7 @@
 			$table
 				.removeClass( 'hasFilters' )
 				// add .tsfilter namespace to all BUT search
-				.unbind( events.replace( /\s+/g, ' ' ) )
+				.unbind( events.replace( ts.regex.spaces, ' ' ) )
 				// remove the filter row even if refreshing, because the column might have been moved
 				.find( '.' + tscss.filterRow ).remove();
 			if ( refreshing ) { return; }
@@ -76,7 +77,7 @@
 		}
 	});
 
-	ts.filter = {
+	tsf = ts.filter = {
 
 		// regex used in filter 'check' functions - not for general use and not documented
 		regex: {
@@ -85,9 +86,13 @@
 			filtered  : /filtered/, // filtered (hidden) row class name; updated in the script
 			type      : /undefined|number/, // check type
 			exact     : /(^[\"\'=]+)|([\"\'=]+$)/g, // exact match (allow '==')
-			nondigit  : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
 			operators : /[<>=]/g, // replace operators
-			query     : '(q|query)' // replace filter queries
+			query     : '(q|query)', // replace filter queries
+			wild01    : /\?/g, // wild card match 0 or 1
+			wild0More : /\*/g, // wild care match 0 or more
+			quote     : /\"/g,
+			isNeg1    : /(>=?\s*-\d)/,
+			isNeg2    : /(<=?\s*\d)/
 		},
 		// function( c, data ) { }
 		// c = table.config
@@ -104,27 +109,27 @@
 		// data.parsed = array ( by column ) of boolean values ( from filter_useParsedData or 'filter-parsed' class )
 		types: {
 			or : function( c, data, vars ) {
-				if ( /\|/.test( data.iFilter ) || ts.filter.regex.orSplit.test( data.filter ) ) {
+				if ( tsf.regex.orTest.test( data.iFilter ) || tsf.regex.orSplit.test( data.filter ) ) {
 					var indx, filterMatched, query, regex,
 						// duplicate data but split filter
 						data2 = $.extend( {}, data ),
 						index = data.index,
 						parsed = data.parsed[ index ],
-						filter = data.filter.split( ts.filter.regex.orSplit ),
-						iFilter = data.iFilter.split( ts.filter.regex.orSplit ),
+						filter = data.filter.split( tsf.regex.orSplit ),
+						iFilter = data.iFilter.split( tsf.regex.orSplit ),
 						len = filter.length;
 					for ( indx = 0; indx < len; indx++ ) {
 						data2.nestedFilters = true;
-						data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
-						data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
-						query = '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')';
+						data2.filter = '' + ( tsf.parseFilter( c, filter[ indx ], index, parsed ) || '' );
+						data2.iFilter = '' + ( tsf.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
+						query = '(' + ( tsf.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')';
 						try {
 							// use try/catch, because query may not be a valid regex if "|" is contained within a partial regex search,
 							// e.g "/(Alex|Aar" -> Uncaught SyntaxError: Invalid regular expression: /(/(Alex)/: Unterminated group
 							regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
 							// filterMatched = data2.filter === '' && indx > 0 ? true
 							// look for an exact match with the 'or' unless the 'filter-match' class is found
-							filterMatched = regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars );
+							filterMatched = regex.test( data2.exact ) || tsf.processTypes( c, data2, vars );
 							if ( filterMatched ) {
 								return filterMatched;
 							}
@@ -139,27 +144,27 @@
 			},
 			// Look for an AND or && operator ( logical and )
 			and : function( c, data, vars ) {
-				if ( ts.filter.regex.andTest.test( data.filter ) ) {
+				if ( tsf.regex.andTest.test( data.filter ) ) {
 					var indx, filterMatched, result, query, regex,
 						// duplicate data but split filter
 						data2 = $.extend( {}, data ),
 						index = data.index,
 						parsed = data.parsed[ index ],
-						filter = data.filter.split( ts.filter.regex.andSplit ),
-						iFilter = data.iFilter.split( ts.filter.regex.andSplit ),
+						filter = data.filter.split( tsf.regex.andSplit ),
+						iFilter = data.iFilter.split( tsf.regex.andSplit ),
 						len = filter.length;
 					for ( indx = 0; indx < len; indx++ ) {
 						data2.nestedFilters = true;
-						data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
-						data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
-						query = ( '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')' )
+						data2.filter = '' + ( tsf.parseFilter( c, filter[ indx ], index, parsed ) || '' );
+						data2.iFilter = '' + ( tsf.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
+						query = ( '(' + ( tsf.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')' )
 							// replace wild cards since /(a*)/i will match anything
-							.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' );
+							.replace( tsf.regex.wild01, '\\S{1}' ).replace( tsf.regex.wild0More, '\\S*' );
 						try {
 							// use try/catch just in case RegExp is invalid
 							regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
 							// look for an exact match with the 'and' unless the 'filter-match' class is found
-							result = ( regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars ) );
+							result = ( regex.test( data2.exact ) || tsf.processTypes( c, data2, vars ) );
 							if ( indx === 0 ) {
 								filterMatched = result;
 							} else {
@@ -176,10 +181,10 @@
 			},
 			// Look for regex
 			regex: function( c, data ) {
-				if ( ts.filter.regex.regex.test( data.filter ) ) {
+				if ( tsf.regex.regex.test( data.filter ) ) {
 					var matches,
 						// cache regex per column for optimal speed
-						regex = data.filter_regexCache[ data.index ] || ts.filter.regex.regex.exec( data.filter ),
+						regex = data.filter_regexCache[ data.index ] || tsf.regex.regex.exec( data.filter ),
 						isRegex = regex instanceof RegExp;
 					try {
 						if ( !isRegex ) {
@@ -198,18 +203,18 @@
 			// Look for operators >, >=, < or <=
 			operators: function( c, data ) {
 				// ignore empty strings... because '' < 10 is true
-				if ( /^[<>]=?/.test( data.iFilter ) && data.iExact !== '' ) {
+				if ( tsf.regex.operTest.test( data.iFilter ) && data.iExact !== '' ) {
 					var cachedValue, result, txt,
 						table = c.table,
 						index = data.index,
 						parsed = data.parsed[index],
-						query = ts.formatFloat( data.iFilter.replace( ts.filter.regex.operators, '' ), table ),
+						query = ts.formatFloat( data.iFilter.replace( tsf.regex.operators, '' ), table ),
 						parser = c.parsers[index],
 						savedSearch = query;
 					// parse filter value in case we're comparing numbers ( dates )
 					if ( parsed || parser.type === 'numeric' ) {
-						txt = $.trim( '' + data.iFilter.replace( ts.filter.regex.operators, '' ) );
-						result = ts.filter.parseFilter( c, txt, index, true );
+						txt = $.trim( '' + data.iFilter.replace( tsf.regex.operators, '' ) );
+						result = tsf.parseFilter( c, txt, index, true );
 						query = ( typeof result === 'number' && result !== '' && !isNaN( result ) ) ? result : query;
 					}
 					// iExact may be numeric - see issue #149;
@@ -218,13 +223,13 @@
 						typeof data.cache !== 'undefined' ) {
 						cachedValue = data.cache;
 					} else {
-						txt = isNaN( data.iExact ) ? data.iExact.replace( ts.filter.regex.nondigit, '' ) : data.iExact;
+						txt = isNaN( data.iExact ) ? data.iExact.replace( ts.regex.nondigit, '' ) : data.iExact;
 						cachedValue = ts.formatFloat( txt, table );
 					}
-					if ( />/.test( data.iFilter ) ) {
-						result = />=/.test( data.iFilter ) ? cachedValue >= query : cachedValue > query;
-					} else if ( /</.test( data.iFilter ) ) {
-						result = /<=/.test( data.iFilter ) ? cachedValue <= query : cachedValue < query;
+					if ( tsf.regex.gtTest.test( data.iFilter ) ) {
+						result = tsf.regex.gteTest.test( data.iFilter ) ? cachedValue >= query : cachedValue > query;
+					} else if ( tsf.regex.ltTest.test( data.iFilter ) ) {
+						result = tsf.regex.lteTest.test( data.iFilter ) ? cachedValue <= query : cachedValue < query;
 					}
 					// keep showing all rows if nothing follows the operator
 					if ( !result && savedSearch === '' ) {
@@ -236,13 +241,13 @@
 			},
 			// Look for a not match
 			notMatch: function( c, data ) {
-				if ( /^\!/.test( data.iFilter ) ) {
+				if ( tsf.regex.notTest.test( data.iFilter ) ) {
 					var indx,
 						txt = data.iFilter.replace( '!', '' ),
-						filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
-					if ( ts.filter.regex.exact.test( filter ) ) {
+						filter = tsf.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+					if ( tsf.regex.exact.test( filter ) ) {
 						// look for exact not matches - see #628
-						filter = filter.replace( ts.filter.regex.exact, '' );
+						filter = filter.replace( tsf.regex.exact, '' );
 						return filter === '' ? true : $.trim( filter ) !== data.iExact;
 					} else {
 						indx = data.iExact.search( $.trim( filter ) );
@@ -254,27 +259,27 @@
 			// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
 			exact: function( c, data ) {
 				/*jshint eqeqeq:false */
-				if ( ts.filter.regex.exact.test( data.iFilter ) ) {
-					var txt = data.iFilter.replace( ts.filter.regex.exact, '' ),
-						filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+				if ( tsf.regex.exact.test( data.iFilter ) ) {
+					var txt = data.iFilter.replace( tsf.regex.exact, '' ),
+						filter = tsf.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
 					return data.anyMatch ? $.inArray( filter, data.rowArray ) >= 0 : filter == data.iExact;
 				}
 				return null;
 			},
 			// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
 			range : function( c, data ) {
-				if ( ts.filter.regex.toTest.test( data.iFilter ) ) {
+				if ( tsf.regex.toTest.test( data.iFilter ) ) {
 					var result, tmp, range1, range2,
 						table = c.table,
 						index = data.index,
 						parsed = data.parsed[index],
 						// make sure the dash is for a range and not indicating a negative number
-						query = data.iFilter.split( ts.filter.regex.toSplit );
+						query = data.iFilter.split( tsf.regex.toSplit );
 
-					tmp = query[0].replace( ts.filter.regex.nondigit, '' ) || '';
-					range1 = ts.formatFloat( ts.filter.parseFilter( c, tmp, index, parsed ), table );
-					tmp = query[1].replace( ts.filter.regex.nondigit, '' ) || '';
-					range2 = ts.formatFloat( ts.filter.parseFilter( c, tmp, index, parsed ), table );
+					tmp = query[0].replace( ts.regex.nondigit, '' ) || '';
+					range1 = ts.formatFloat( tsf.parseFilter( c, tmp, index, parsed ), table );
+					tmp = query[1].replace( ts.regex.nondigit, '' ) || '';
+					range2 = ts.formatFloat( tsf.parseFilter( c, tmp, index, parsed ), table );
 					// parse filter value in case we're comparing numbers ( dates )
 					if ( parsed || c.parsers[index].type === 'numeric' ) {
 						result = c.parsers[ index ].format( '' + query[0], table, c.$headers.eq( index ), index );
@@ -285,7 +290,7 @@
 					if ( ( parsed || c.parsers[ index ].type === 'numeric' ) && !isNaN( range1 ) && !isNaN( range2 ) ) {
 						result = data.cache;
 					} else {
-						tmp = isNaN( data.iExact ) ? data.iExact.replace( ts.filter.regex.nondigit, '' ) : data.iExact;
+						tmp = isNaN( data.iExact ) ? data.iExact.replace( ts.regex.nondigit, '' ) : data.iExact;
 						result = ts.formatFloat( tmp, table );
 					}
 					if ( range1 > range2 ) {
@@ -297,18 +302,18 @@
 			},
 			// Look for wild card: ? = single, * = multiple, or | = logical OR
 			wild : function( c, data ) {
-				if ( /[\?\*\|]/.test( data.iFilter ) ) {
+				if ( tsf.regex.wildOrTest.test( data.iFilter ) ) {
 					var index = data.index,
 						parsed = data.parsed[ index ],
-						query = '' + ( ts.filter.parseFilter( c, data.iFilter, index, parsed ) || '' );
+						query = '' + ( tsf.parseFilter( c, data.iFilter, index, parsed ) || '' );
 					// look for an exact match with the 'or' unless the 'filter-match' class is found
-					if ( !/\?\*/.test( query ) && data.nestedFilters ) {
+					if ( !tsf.regex.wildTest.test( query ) && data.nestedFilters ) {
 						query = data.isMatch ? query : '^(' + query + ')$';
 					}
 					// parsing the filter may not work properly when using wildcards =/
 					try {
 						return new RegExp(
-							query.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' ),
+							query.replace( tsf.regex.wild01, '\\S{1}' ).replace( tsf.regex.wild0More, '\\S*' ),
 							c.widgetOptions.filter_ignoreCase ? 'i' : ''
 						)
 						.test( data.exact );
@@ -320,12 +325,12 @@
 			},
 			// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
 			fuzzy: function( c, data ) {
-				if ( /^~/.test( data.iFilter ) ) {
+				if ( tsf.regex.fuzzyTest.test( data.iFilter ) ) {
 					var indx,
 						patternIndx = 0,
 						len = data.iExact.length,
 						txt = data.iFilter.slice( 1 ),
-						pattern = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+						pattern = tsf.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
 					for ( indx = 0; indx < len; indx++ ) {
 						if ( data.iExact[ indx ] === pattern[ patternIndx ] ) {
 							patternIndx += 1;
@@ -348,7 +353,7 @@
 			}, ts.language );
 
 			var options, string, txt, $header, column, filters, val, fxn, noSelect,
-				regex = ts.filter.regex;
+				regex = tsf.regex;
 			c.$table.addClass( 'hasFilters' );
 
 			// define timers so using clearTimeout won't cause an undefined error
@@ -359,7 +364,7 @@
 			wo.filter_anyColumnSelector = '[data-column="all"],[data-column="any"]';
 			wo.filter_multipleColumnSelector = '[data-column*="-"],[data-column*=","]';
 
-			val = '\\{' + ts.filter.regex.query + '\\}';
+			val = '\\{' + tsf.regex.query + '\\}';
 			$.extend( regex, {
 				child : new RegExp( c.cssChildRow ),
 				filtered : new RegExp( wo.filter_filteredRow ),
@@ -368,9 +373,20 @@
 				toSplit : new RegExp( '(?:\\s+(?:-|' + ts.language.to + ')\\s+)', 'gi' ),
 				andTest : new RegExp( '\\s+(' + ts.language.and + '|&&)\\s+', 'i' ),
 				andSplit : new RegExp( '(?:\\s+(?:' + ts.language.and + '|&&)\\s+)', 'gi' ),
+				orTest : /\|/,
 				orSplit : new RegExp( '(?:\\s+(?:' + ts.language.or + ')\\s+|\\|)', 'gi' ),
 				iQuery : new RegExp( val, 'i' ),
-				igQuery : new RegExp( val, 'ig' )
+				igQuery : new RegExp( val, 'ig' ),
+				operTest : /^[<>]=?/,
+				gtTest  : />/,
+				gteTest : />=/,
+				ltTest  : /</,
+				lteTest : /<=/,
+				notTest : /^\!/,
+				wildOrTest : /[\?\*\|]/,
+				wildTest : /\?\*/,
+				fuzzyTest : /^~/,
+				exactTest : /[=\"\|!]/
 			});
 
 			// don't build filter row if columnFilters is false or all columns are set to 'filter-false'
@@ -378,7 +394,7 @@
 			val = c.$headers.filter( '.filter-false, .parser-false' ).length;
 			if ( wo.filter_columnFilters !== false && val !== c.$headers.length ) {
 				// build filter row
-				ts.filter.buildRow( table, c, wo );
+				tsf.buildRow( table, c, wo );
 			}
 
 			txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '
@@ -391,13 +407,13 @@
 				c.$table.find( '.' + tscss.filterRow ).toggleClass( wo.filter_filteredRow, val ); // fixes #450
 				if ( !/(search|filter)/.test( event.type ) ) {
 					event.stopPropagation();
-					ts.filter.buildDefault( table, true );
+					tsf.buildDefault( table, true );
 				}
 				if ( event.type === 'filterReset' ) {
 					c.$table.find( '.' + tscss.filter ).add( wo.filter_$externalFilters ).val( '' );
-					ts.filter.searching( table, [] );
+					tsf.searching( table, [] );
 				} else if ( event.type === 'filterEnd' ) {
-					ts.filter.buildDefault( table, true );
+					tsf.buildDefault( table, true );
 				} else {
 					// send false argument to force a new search; otherwise if the filter hasn't changed,
 					// it will return
@@ -411,7 +427,7 @@
 					// pass true ( skipFirst ) to prevent the tablesorter.setFilters function from skipping the first
 					// input ensures all inputs are updated when a search is triggered on the table
 					// $( 'table' ).trigger( 'search', [...] );
-					ts.filter.searching( table, filter, true );
+					tsf.searching( table, filter, true );
 				}
 				return false;
 			});
@@ -444,7 +460,7 @@
 						noSelect = !( $header.hasClass( 'filter-false' ) || $header.hasClass( 'parser-false' ) );
 						options = '';
 						if ( fxn === true && noSelect ) {
-							ts.filter.buildSelect( table, column );
+							tsf.buildSelect( table, column );
 						} else if ( typeof fxn === 'object' && noSelect ) {
 							// add custom drop down list
 							for ( string in fxn ) {
@@ -477,7 +493,7 @@
 							fxn = $.isFunction( txt ) ? true : ts.getColumnData( table, txt, column );
 							if ( fxn ) {
 								// updating so the extra options are appended
-								ts.filter.buildSelect( c.table, column, '', true, $header.hasClass( wo.filter_onlyAvail ) );
+								tsf.buildSelect( c.table, column, '', true, $header.hasClass( wo.filter_onlyAvail ) );
 							}
 						}
 					}
@@ -485,22 +501,22 @@
 			}
 			// not really updating, but if the column has both the 'filter-select' class &
 			// filter_functions set to true, it would append the same options twice.
-			ts.filter.buildDefault( table, true );
+			tsf.buildDefault( table, true );
 
-			ts.filter.bindSearch( table, c.$table.find( '.' + tscss.filter ), true );
+			tsf.bindSearch( table, c.$table.find( '.' + tscss.filter ), true );
 			if ( wo.filter_external ) {
-				ts.filter.bindSearch( table, wo.filter_external );
+				tsf.bindSearch( table, wo.filter_external );
 			}
 
 			if ( wo.filter_hideFilters ) {
-				ts.filter.hideFilters( table, c );
+				tsf.hideFilters( table, c );
 			}
 
 			// show processing icon
 			if ( c.showProcessing ) {
 				txt = 'filterStart filterEnd '.split( ' ' ).join( c.namespace + 'filter ' );
 				c.$table
-					.unbind( txt.replace( /\s+/g, ' ' ) )
+					.unbind( txt.replace( ts.regex.spaces, ' ' ) )
 					.bind( txt, function( event, columns ) {
 					// only add processing to certain columns to all columns
 					$header = ( columns ) ?
@@ -520,11 +536,11 @@
 			// add default values
 			txt = 'tablesorter-initialized pagerBeforeInitialized '.split( ' ' ).join( c.namespace + 'filter ' );
 			c.$table
-			.unbind( txt.replace( /\s+/g, ' ' ) )
+			.unbind( txt.replace( ts.regex.spaces, ' ' ) )
 			.bind( txt, function() {
 				// redefine 'wo' as it does not update properly inside this callback
 				var wo = this.config.widgetOptions;
-				filters = ts.filter.setDefaults( table, c, wo ) || [];
+				filters = tsf.setDefaults( table, c, wo ) || [];
 				if ( filters.length ) {
 					// prevent delayInit from triggering a cache build if filters are empty
 					if ( !( c.delayInit && filters.join( '' ) === '' ) ) {
@@ -535,7 +551,7 @@
 				// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
 				setTimeout( function() {
 					if ( !wo.filter_initialized ) {
-						ts.filter.filterInitComplete( c );
+						tsf.filterInitComplete( c );
 					}
 				}, 100 );
 			});
@@ -543,7 +559,7 @@
 			if ( c.pager && c.pager.initialized && !wo.filter_initialized ) {
 				c.$table.trigger( 'filterFomatterUpdate' );
 				setTimeout( function() {
-					ts.filter.filterInitComplete( c );
+					tsf.filterInitComplete( c );
 				}, 100 );
 			}
 		},
@@ -564,7 +580,7 @@
 				completed = function() {
 					wo.filter_initialized = true;
 					c.$table.trigger( 'filterInit', c );
-					ts.filter.findRows( c.table, c.$table.data( 'lastSearch' ) || [] );
+					tsf.findRows( c.table, c.$table.data( 'lastSearch' ) || [] );
 				};
 			if ( $.isEmptyObject( wo.filter_formatter ) ) {
 				completed();
@@ -716,7 +732,7 @@
 			// use data attribute instead of jQuery data since the head is cloned without including
 			// the data/binding
 			.attr( 'data-lastSearchTime', new Date().getTime() )
-			.unbind( tmp.replace( /\s+/g, ' ' ) )
+			.unbind( tmp.replace( ts.regex.spaces, ' ' ) )
 			// include change for select - fixes #473
 			.bind( 'keyup' + namespace, function( event ) {
 				$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
@@ -736,17 +752,18 @@
 					return;
 				}
 				// change event = no delay; last true flag tells getFilters to skip newest timed input
-				ts.filter.searching( table, true, true );
+				tsf.searching( table, true, true );
 			})
 			.bind( 'search change keypress '.split( ' ' ).join( namespace + ' ' ), function( event ) {
-				var column = $( this ).data( 'column' );
+				// don't get cached data, in case data-column changes dynamically
+				var column = parseInt( $( this ).attr( 'data-column' ), 10 );
 				// don't allow 'change' event to process if the input value is the same - fixes #685
 				if ( event.which === 13 || event.type === 'search' ||
 					event.type === 'change' && this.value !== c.lastSearch[column] ) {
 					event.preventDefault();
 					// init search with no delay
 					$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
-					ts.filter.searching( table, false, true );
+					tsf.searching( table, false, true );
 				}
 			});
 		},
@@ -756,11 +773,11 @@
 			if ( typeof filter === 'undefined' || filter === true ) {
 				// delay filtering
 				wo.searchTimer = setTimeout( function() {
-					ts.filter.checkFilters( table, filter, skipFirst );
+					tsf.checkFilters( table, filter, skipFirst );
 				}, wo.filter_liveSearch ? wo.filter_searchDelay : 10 );
 			} else {
 				// skip delay
-				ts.filter.checkFilters( table, filter, skipFirst );
+				tsf.checkFilters( table, filter, skipFirst );
 			}
 		},
 		checkFilters: function( table, filter, skipFirst ) {
@@ -774,7 +791,7 @@
 				// update cache if delayInit set & pager has initialized ( after user initiates a search )
 				if ( c.delayInit && c.pager && c.pager.initialized ) {
 					c.$table.trigger( 'updateCache', [ function() {
-						ts.filter.checkFilters( table, false, skipFirst );
+						tsf.checkFilters( table, false, skipFirst );
 					} ] );
 				}
 				return;
@@ -805,11 +822,11 @@
 			if ( c.showProcessing ) {
 				// give it time for the processing icon to kick in
 				setTimeout( function() {
-					ts.filter.findRows( table, filters, combinedFilters );
+					tsf.findRows( table, filters, combinedFilters );
 					return false;
 				}, 30 );
 			} else {
-				ts.filter.findRows( table, filters, combinedFilters );
+				tsf.findRows( table, filters, combinedFilters );
 				return false;
 			}
 		},
@@ -852,8 +869,8 @@
 		},
 		defaultFilter: function( filter, mask ) {
 			if ( filter === '' ) { return filter; }
-			var regex = ts.filter.regex.iQuery,
-				maskLen = mask.match( ts.filter.regex.igQuery ).length,
+			var regex = tsf.regex.iQuery,
+				maskLen = mask.match( tsf.regex.igQuery ).length,
 				query = maskLen > 1 ? $.trim( filter ).split( /\s/ ) : [ $.trim( filter ) ],
 				len = query.length - 1,
 				indx = 0,
@@ -889,7 +906,10 @@
 				// & don't target 'all' column inputs if they don't exist
 				targets = wo.filter_initialized || !$input.filter( wo.filter_anyColumnSelector ).length,
 				columns = [],
-				val = $.trim( ts.filter.getLatestSearch( $input ).attr( 'data-column' ) || '' );
+				val = $.trim( tsf.getLatestSearch( $input ).attr( 'data-column' ) || '' );
+			if ( !/[,-]/.test(val) && val.length === 1 ) {
+				return parseInt( val, 10 );
+			}
 			// process column range
 			if ( targets && /-/.test( val ) ) {
 				ranges = val.match( /(\d+)\s*-\s*(\d+)/g );
@@ -936,9 +956,9 @@
 			var ffxn,
 				filterMatched = null,
 				matches = null;
-			for ( ffxn in ts.filter.types ) {
+			for ( ffxn in tsf.types ) {
 				if ( $.inArray( ffxn, vars.excludeMatch ) < 0 && matches === null ) {
-					matches = ts.filter.types[ffxn]( c, data, vars );
+					matches = tsf.types[ffxn]( c, data, vars );
 					if ( matches !== null ) {
 						filterMatched = matches;
 					}
@@ -947,16 +967,23 @@
 			return filterMatched;
 		},
 		processRow: function( c, data, vars ) {
-			var columnIndex, hasSelect, result, val, filterMatched,
+			var hasSelect, result, val, filterMatched,
 				fxn, ffxn, txt,
-				regex = ts.filter.regex,
+				regex = tsf.regex,
 				wo = c.widgetOptions,
-				showRow = true;
+				showRow = true,
+
+				// if wo.filter_$anyMatch data-column attribute is changed dynamically
+				// we don't want to do an "anyMatch" search on one column using data
+				// for the entire row - see #998
+				columnIndex = wo.filter_$anyMatch && wo.filter_$anyMatch.length ?
+					// look for multiple columns '1-3,4-6,8'
+					tsf.multipleColumns( c, wo.filter_$anyMatch ) :
+					[];
+
 			data.$cells = data.$row.children();
 
-			if ( data.anyMatchFlag ) {
-				// look for multiple columns '1-3,4-6,8'
-				columnIndex = ts.filter.multipleColumns( c, wo.filter_$anyMatch );
+			if ( data.anyMatchFlag && columnIndex.length > 1 ) {
 				data.anyMatch = true;
 				data.isMatch = true;
 				data.rowArray = data.$cells.map( function( i ) {
@@ -980,7 +1007,7 @@
 				data.cache = data.cacheArray.slice( 0, -1 ).join( ' ' );
 
 				vars.excludeMatch = vars.noAnyMatch;
-				filterMatched = ts.filter.processTypes( c, data, vars );
+				filterMatched = tsf.processTypes( c, data, vars );
 
 				if ( filterMatched !== null ) {
 					showRow = filterMatched;
@@ -1041,7 +1068,7 @@
 
 					val = true;
 					if ( wo.filter_defaultFilter && regex.iQuery.test( vars.defaultColFilter[ columnIndex ] ) ) {
-						data.filter = ts.filter.defaultFilter( data.filter, vars.defaultColFilter[ columnIndex ] );
+						data.filter = tsf.defaultFilter( data.filter, vars.defaultColFilter[ columnIndex ] );
 						// val is used to indicate that a filter select is using a default filter;
 						// so we override the exact & partial matches
 						val = false;
@@ -1072,13 +1099,13 @@
 					if ( filterMatched === null ) {
 						// cycle through the different filters
 						// filters return a boolean or null if nothing matches
-						filterMatched = ts.filter.processTypes( c, data, vars );
+						filterMatched = tsf.processTypes( c, data, vars );
 						if ( filterMatched !== null ) {
 							result = filterMatched;
 						// Look for match, and add child row data for matching
 						} else {
 							txt = ( data.iExact + data.childRowText )
-								.indexOf( ts.filter.parseFilter( c, data.iFilter, columnIndex, data.parsed[ columnIndex ] ) );
+								.indexOf( tsf.parseFilter( c, data.iFilter, columnIndex, data.parsed[ columnIndex ] ) );
 							result = ( ( !wo.filter_startsWith && txt >= 0 ) || ( wo.filter_startsWith && txt === 0 ) );
 						}
 					} else {
@@ -1098,7 +1125,7 @@
 				isChild, childRow, lastSearch, showRow, time, val, indx,
 				notFiltered, searchFiltered, query, injected, res, id, txt,
 				storedFilters = $.extend( [], filters ),
-				regex = ts.filter.regex,
+				regex = tsf.regex,
 				c = table.config,
 				wo = c.widgetOptions,
 				// data object passed to filters; anyMatch is a flag for the filters
@@ -1175,7 +1202,7 @@
 						data.anyMatchFlag = true;
 						data.anyMatchFilter = '' + (
 							filters[ c.columns ] ||
-							wo.filter_$anyMatch && ts.filter.getLatestSearch( wo.filter_$anyMatch ).val() ||
+							wo.filter_$anyMatch && tsf.getLatestSearch( wo.filter_$anyMatch ).val() ||
 							''
 						);
 						if ( wo.filter_columnAnyMatch ) {
@@ -1217,10 +1244,10 @@
 								// if there is NOT a logical 'or', or range ( 'to' or '-' ) in the string
 								!regex.alreadyFiltered.test( val ) &&
 								// if we are not doing exact matches, using '|' ( logical or ) or not '!'
-								!/[=\"\|!]/.test( val ) &&
+								!regex.exactTest.test( val ) &&
 								// don't search only filtered if the value is negative
 								// ( '> -10' => '> -100' will ignore hidden rows )
-								!( /(>=?\s*-\d)/.test( val ) || /(<=?\s*\d)/.test( val ) ) &&
+								!( regex.isNeg1.test( val ) || regex.isNeg2.test( val ) ) &&
 								// if filtering using a select without a 'filter-match' class ( exact match ) - fixes #593
 								!( val !== '' && c.$filters && c.$filters.eq( indx ).find( 'select' ).length &&
 									!c.$headerIndexed[indx].hasClass( 'filter-match' ) );
@@ -1239,7 +1266,7 @@
 							data.anyMatchFilter = ts.replaceAccents( data.anyMatchFilter );
 						}
 						if ( wo.filter_defaultFilter && regex.iQuery.test( vars.defaultAnyFilter ) ) {
-							data.anyMatchFilter = ts.filter.defaultFilter( data.anyMatchFilter, vars.defaultAnyFilter );
+							data.anyMatchFilter = tsf.defaultFilter( data.anyMatchFilter, vars.defaultAnyFilter );
 							// clear search filtered flag because default filters are not saved to the last search
 							searchFiltered = false;
 						}
@@ -1282,7 +1309,7 @@
 								'';
 						}
 
-						showRow = ts.filter.processRow( c, data, vars );
+						showRow = tsf.processRow( c, data, vars );
 						childRow = rowData.$row.filter( ':gt( 0 )' );
 
 						if ( wo.filter_childRows && childRow.length ) {
@@ -1293,7 +1320,7 @@
 									data.cacheArray = rowData.child[ indx ];
 									data.rawArray = data.cacheArray;
 									// use OR comparison on child rows
-									showRow = showRow || ts.filter.processRow( c, data, vars );
+									showRow = showRow || tsf.processRow( c, data, vars );
 								}
 							}
 							childRow.toggleClass( wo.filter_filteredRow, !showRow );
@@ -1355,7 +1382,7 @@
 			}
 			if ( arry === false ) {
 				// fall back to original method
-				arry = ts.filter.getOptions( table, column, onlyAvail );
+				arry = tsf.getOptions( table, column, onlyAvail );
 			}
 
 			// get unique elements and sort the list
@@ -1467,13 +1494,13 @@
 			// nothing included in arry ( external source ), so get the options from
 			// filter_selectSource or column data
 			if ( typeof arry === 'undefined' || arry === '' ) {
-				arry = ts.filter.getOptionSource( table, column, onlyAvail );
+				arry = tsf.getOptionSource( table, column, onlyAvail );
 			}
 
 			if ( $.isArray( arry ) ) {
 				// build option list
 				for ( indx = 0; indx < arry.length; indx++ ) {
-					txt = arry[indx] = ( '' + arry[indx] ).replace( /\"/g, '&quot;' );
+					txt = arry[indx] = ( '' + arry[indx] ).replace( tsf.regex.quote, '&quot;' );
 					val = txt;
 					// allow including a symbol in the selectSource array
 					// 'a-z|A through Z' so that 'a-z' becomes the option value
@@ -1529,7 +1556,7 @@
 				// look for the filter-select class; build/update it if found
 				if ( ( $header.hasClass( 'filter-select' ) ||
 					ts.getColumnData( table, wo.filter_functions, columnIndex ) === true ) && noSelect ) {
-					ts.filter.buildSelect( table, columnIndex, '', updating, $header.hasClass( wo.filter_onlyAvail ) );
+					tsf.buildSelect( table, columnIndex, '', updating, $header.hasClass( wo.filter_onlyAvail ) );
 				}
 			}
 		}
@@ -1565,7 +1592,7 @@
 					$column = $filters.filter( cols );
 					if ( $column.length ) {
 						// move the latest search to the first slot in the array
-						$column = ts.filter.getLatestSearch( $column );
+						$column = tsf.getLatestSearch( $column );
 						if ( $.isArray( setFilters ) ) {
 							// skip first ( latest input ) to maintain cursor position while typing
 							if ( skipFirst && $column.length > 1 ) {
@@ -1615,7 +1642,7 @@
 			// ensure new set filters are applied, even if the search is the same
 			c.lastCombinedFilter = null;
 			c.lastSearch = [];
-			ts.filter.searching( c.table, filter, skipFirst );
+			tsf.searching( c.table, filter, skipFirst );
 			c.$table.trigger( 'filterFomatterUpdate' );
 		}
 		return !!valid;