jquery-tablesorter 1.18.1 → 1.18.2

data/vendor/assets/javascripts/jquery-tablesorter/jquery.tablesorter.js

@@ -1,4 +1,4 @@
-/*! TableSorter (FORK) v2.23.1 *//*
+/*! TableSorter (FORK) v2.23.2 *//*
 * Client-side table sorting with ease!
 * @requires jQuery v1.2.6+
 *
@@ -26,7 +26,7 @@
 
 			var ts = this;
 
-			ts.version = '2.23.1';
+			ts.version = '2.23.2';
 
 			ts.parsers = [];
 			ts.widgets = [];
@@ -151,6 +151,15 @@
 				nextNone : 'activate to remove the sort'
 			};
 
+			ts.regex = {
+				templateContent : /\{content\}/g,
+				templateIcon    : /\{icon\}/g,
+				templateName    : /\{name\}/i,
+				spaces          : /\s+/g,
+				nonWord         : /\W/g,
+				formElements    : /(input|select|button|textarea)/i
+			};
+
 			// These methods can be applied on table.config instance
 			ts.instanceMethods = {};
 
@@ -443,7 +452,9 @@
 					// if headerTemplate is empty, don't reformat the header cell
 					if ( c.headerTemplate !== '' && !$t.find('.' + ts.css.headerIn).length ) {
 						// set up header template
-						t = c.headerTemplate.replace(/\{content\}/g, $t.html()).replace(/\{icon\}/g, $t.find('.' + ts.css.icon).length ? '' : i);
+						t = c.headerTemplate
+							.replace(ts.regex.templateContent, $t.html())
+							.replace(ts.regex.templateIcon, $t.find('.' + ts.css.icon).length ? '' : i);
 						if (c.onRenderTemplate) {
 							h = c.onRenderTemplate.apply( $t, [ index, t ] );
 							if (h && typeof h === 'string') { t = h; } // only change t if something is returned
@@ -856,7 +867,7 @@
 						.join( c.namespace + ' ' );
 				// apply easy methods that trigger bound events
 				$table
-				.unbind( events.replace( /\s+/g, ' ' ) )
+				.unbind( events.replace( ts.regex.spaces, ' ' ) )
 				.bind( 'sortReset' + c.namespace, function( e, callback ) {
 					e.stopPropagation();
 					// using this.config to ensure functions are getting a non-cached version of the config
@@ -1003,7 +1014,7 @@
 					c.namespace = '.tablesorter' + Math.random().toString(16).slice(2);
 				} else {
 					// make sure namespace starts with a period & doesn't have weird characters
-					c.namespace = '.' + c.namespace.replace(/\W/g, '');
+					c.namespace = '.' + c.namespace.replace(ts.regex.nonWord, '');
 				}
 
 				c.$table.children().children('tr').attr('role', 'row');
@@ -1231,7 +1242,7 @@
 					}
 				}
 				t = ( c.pointerDown + ' ' + c.pointerUp + ' ' + c.pointerClick + ' sort keyup ' )
-					.replace(/\s+/g, ' ')
+					.replace(ts.regex.spaces, ' ')
 					.split(' ')
 					.join(c.namespace + ' ');
 				// apply event handling to headers and/or additional headers (stickyheaders, scroller, etc)
@@ -1265,7 +1276,7 @@
 					}
 					downTarget = null;
 					// prevent sort being triggered on form elements
-					if ( /(input|select|button|textarea)/i.test(e.target.nodeName) ||
+					if ( ts.regex.formElements.test(e.target.nodeName) ||
 						// nosort class name, or elements within a nosort container
 						$target.hasClass(c.cssNoSort) || $target.parents('.' + c.cssNoSort).length > 0 ||
 						// elements within a button
@@ -1551,13 +1562,13 @@
 					.join(c.namespace + ' ');
 				$t
 					.removeData('tablesorter')
-					.unbind( events.replace(/\s+/g, ' ') );
+					.unbind( events.replace(ts.regex.spaces, ' ') );
 				c.$headers.add($f)
 					.removeClass( [ ts.css.header, c.cssHeader, c.cssAsc, c.cssDesc, ts.css.sortAsc, ts.css.sortDesc, ts.css.sortNone ].join(' ') )
 					.removeAttr('data-column')
 					.removeAttr('aria-label')
 					.attr('aria-disabled', 'true');
-				$r.find(c.selectorSort).unbind( ('mousedown mouseup keypress '.split(' ').join(c.namespace + ' ')).replace(/\s+/g, ' ') );
+				$r.find(c.selectorSort).unbind( ('mousedown mouseup keypress '.split(' ').join(c.namespace + ' ')).replace(ts.regex.spaces, ' ') );
 				ts.restoreHeaders(table);
 				$t.toggleClass(ts.css.table + ' ' + c.tableClass + ' tablesorter-' + c.theme, removeClasses === false);
 				// clear flag in case the plugin is initialized again
@@ -1573,11 +1584,9 @@
 
 			// *** sort functions ***
 			// regex used in natural sort
-			ts.regex = {
-				chunk : /(^([+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?)?$|^0x[0-9a-f]+$|\d+)/gi, // chunk/tokenize numbers & letters
-				chunks: /(^\\0|\\0$)/, // replace chunks @ ends
-				hex: /^0x[0-9a-f]+$/i // hex
-			};
+			ts.regex.chunk = /(^([+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?)?$|^0x[0-9a-f]+$|\d+)/gi; // chunk/tokenize numbers & letters
+			ts.regex.chunks = /(^\\0|\\0$)/; // replace chunks @ ends
+			ts.regex.hex = /^0x[0-9a-f]+$/i; // hex
 
 			// Natural sort - https://github.com/overset/javascript-natural-sort (date sorting removed)
 			// this function will only accept strings, or you'll see 'TypeError: undefined is not a function'
@@ -1804,7 +1813,7 @@
 				if (c.debug) { time = new Date(); }
 				// look for widgets to apply from in table class
 				// stop using \b otherwise this matches 'ui-widget-content' & adds 'content' widget
-				wd = new RegExp( '\\s' + c.widgetClass.replace( /\{name\}/i, '([\\w-]+)' ) + '\\s', 'g' );
+				wd = new RegExp( '\\s' + c.widgetClass.replace( ts.regex.templateName, '([\\w-]+)' ) + '\\s', 'g' );
 				if ( tableClass.match( wd ) ) {
 					// extract out the widget id from the table class (widget id's can include dashes)
 					w = tableClass.match( wd );
@@ -2030,6 +2039,10 @@
 				return $.trim(val);
 			};
 
+			ts.regex.comma = /,/g;
+			ts.regex.digitNonUS = /[\s|\.]/g;
+			ts.regex.digitNegativeTest = /^\s*\([.\d]+\)/;
+			ts.regex.digitNegativeReplace = /^\s*\(([.\d]+)\)/;
 			ts.formatFloat = function(s, table) {
 				if (typeof s !== 'string' || s === '') { return s; }
 				// allow using formatFloat without a table; defaults to US number format
@@ -2038,24 +2051,28 @@
 						typeof table !== 'undefined' ? table : true;
 				if (t) {
 					// US Format - 1,234,567.89 -> 1234567.89
-					s = s.replace(/,/g, '');
+					s = s.replace(ts.regex.comma, '');
 				} else {
 					// German Format = 1.234.567,89 -> 1234567.89
 					// French Format = 1 234 567,89 -> 1234567.89
-					s = s.replace(/[\s|\.]/g, '').replace(/,/g, '.');
+					s = s.replace(ts.regex.digitNonUS, '').replace(ts.regex.comma, '.');
 				}
-				if (/^\s*\([.\d]+\)/.test(s)) {
+				if (ts.regex.digitNegativeTest.test(s)) {
 					// make (#) into a negative number -> (10) = -10
-					s = s.replace(/^\s*\(([.\d]+)\)/, '-$1');
+					s = s.replace(ts.regex.digitNegativeReplace, '-$1');
 				}
 				i = parseFloat(s);
 				// return the text instead of zero
 				return isNaN(i) ? $.trim(s) : i;
 			};
 
+			ts.regex.digitTest = /^[\-+(]?\d+[)]?$/;
+			ts.regex.digitReplace = /[,.'"\s]/g;
 			ts.isDigit = function(s) {
 				// replace all unwanted chars and match
-				return isNaN(s) ? (/^[\-+(]?\d+[)]?$/).test(s.toString().replace(/[,.'"\s]/g, '')) : s !== '';
+				return isNaN(s) ?
+					ts.regex.digitTest.test( s.toString().replace( ts.regex.digitReplace, '' ) ) :
+					s !== '';
 			};
 
 		}()
@@ -2114,65 +2131,76 @@
 		type: 'text'
 	});
 
+	ts.regex.nondigit = /[^\w,. \-()]/g;
 	ts.addParser({
 		id: 'digit',
 		is: function(s) {
 			return ts.isDigit(s);
 		},
 		format: function(s, table) {
-			var n = ts.formatFloat((s || '').replace(/[^\w,. \-()]/g, ''), table);
+			var n = ts.formatFloat((s || '').replace(ts.regex.nondigit, ''), table);
 			return s && typeof n === 'number' ? n :
 				s ? $.trim( s && table.config.ignoreCase ? s.toLocaleLowerCase() : s ) : s;
 		},
 		type: 'numeric'
 	});
 
+	ts.regex.currencyReplace = /[+\-,. ]/g;
+	ts.regex.currencyTest = /^\(?\d+[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]|[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]\d+\)?$/;
 	ts.addParser({
 		id: 'currency',
 		is: function(s) {
-			s = (s || '').replace(/[+\-,. ]/g, '');
+			s = (s || '').replace(ts.regex.currencyReplace, '');
 			// test for £$€¤¥¢
-			return (/^\(?\d+[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]|[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]\d+\)?$/).test(s);
+			return ts.regex.currencyTest.test(s);
 		},
 		format: function(s, table) {
-			var n = ts.formatFloat((s || '').replace(/[^\w,. \-()]/g, ''), table);
+			var n = ts.formatFloat((s || '').replace(ts.regex.nondigit, ''), table);
 			return s && typeof n === 'number' ? n :
 				s ? $.trim( s && table.config.ignoreCase ? s.toLocaleLowerCase() : s ) : s;
 		},
 		type: 'numeric'
 	});
 
+	// too many protocols to add them all https://en.wikipedia.org/wiki/URI_scheme
+	// now, this regex can be updated before initialization
+	ts.regex.urlProtocolTest =   /^(https?|ftp|file):\/\//;
+	ts.regex.urlProtocolReplace = /(https?|ftp|file):\/\//;
 	ts.addParser({
 		id: 'url',
 		is: function(s) {
-			return (/^(https?|ftp|file):\/\//).test(s);
+			return ts.regex.urlProtocolTest.test(s);
 		},
 		format: function(s) {
-			return s ? $.trim(s.replace(/(https?|ftp|file):\/\//, '')) : s;
+			return s ? $.trim(s.replace(ts.regex.urlProtocolReplace, '')) : s;
 		},
 		parsed : true, // filter widget flag
 		type: 'text'
 	});
 
+	ts.regex.dash = /-/g;
+	ts.regex.isoDate = /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}/;
 	ts.addParser({
 		id: 'isoDate',
 		is: function(s) {
-			return (/^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}/).test(s);
+			return ts.regex.isoDate.test(s);
 		},
 		format: function(s, table) {
-			var date = s ? new Date( s.replace(/-/g, '/') ) : s;
+			var date = s ? new Date( s.replace(ts.regex.dash, '/') ) : s;
 			return date instanceof Date && isFinite(date) ? date.getTime() : s;
 		},
 		type: 'numeric'
 	});
 
+	ts.regex.percent = /%/g;
+	ts.regex.percentTest = /(\d\s*?%|%\s*?\d)/;
 	ts.addParser({
 		id: 'percent',
 		is: function(s) {
-			return (/(\d\s*?%|%\s*?\d)/).test(s) && s.length < 15;
+			return ts.regex.percentTest.test(s) && s.length < 15;
 		},
 		format: function(s, table) {
-			return s ? ts.formatFloat(s.replace(/%/g, ''), table) : s;
+			return s ? ts.formatFloat(s.replace(ts.regex.percent, ''), table) : s;
 		},
 		type: 'numeric'
 	});
@@ -2190,27 +2218,35 @@
 		type: 'text'
 	});
 
+	ts.regex.dateReplace = /(\S)([AP]M)$/i; // used by usLongDate & time parser
+	ts.regex.usLongDateTest1 = /^[A-Z]{3,10}\.?\s+\d{1,2},?\s+(\d{4})(\s+\d{1,2}:\d{2}(:\d{2})?(\s+[AP]M)?)?$/i;
+	ts.regex.usLongDateTest2 = /^\d{1,2}\s+[A-Z]{3,10}\s+\d{4}/i;
 	ts.addParser({
 		id: 'usLongDate',
 		is: function(s) {
 			// two digit years are not allowed cross-browser
 			// Jan 01, 2013 12:34:56 PM or 01 Jan 2013
-			return (/^[A-Z]{3,10}\.?\s+\d{1,2},?\s+(\d{4})(\s+\d{1,2}:\d{2}(:\d{2})?(\s+[AP]M)?)?$/i).test(s) ||
-				(/^\d{1,2}\s+[A-Z]{3,10}\s+\d{4}/i).test(s);
+			return ts.regex.usLongDateTest1.test(s) || ts.regex.usLongDateTest2.test(s);
 		},
 		format: function(s, table) {
-			var date = s ? new Date( s.replace(/(\S)([AP]M)$/i, '$1 $2') ) : s;
+			var date = s ? new Date( s.replace(ts.regex.dateReplace, '$1 $2') ) : s;
 			return date instanceof Date && isFinite(date) ? date.getTime() : s;
 		},
 		type: 'numeric'
 	});
 
+	// testing for ##-##-#### or ####-##-##, so it's not perfect; time can be included
+	ts.regex.shortDateTest = /(^\d{1,2}[\/\s]\d{1,2}[\/\s]\d{4})|(^\d{4}[\/\s]\d{1,2}[\/\s]\d{1,2})/;
+	// escaped "-" because JSHint in Firefox was showing it as an error
+	ts.regex.shortDateReplace = /[\-.,]/g;
+	// XXY covers MDY & DMY formats
+	ts.regex.shortDateXXY = /(\d{1,2})[\/\s](\d{1,2})[\/\s](\d{4})/;
+	ts.regex.shortDateYMD = /(\d{4})[\/\s](\d{1,2})[\/\s](\d{1,2})/;
 	ts.addParser({
 		id: 'shortDate', // 'mmddyyyy', 'ddmmyyyy' or 'yyyymmdd'
 		is: function(s) {
-			s = (s || '').replace(/\s+/g, ' ').replace(/[\-.,]/g, '/');
-			// testing for ##-##-#### or ####-##-##, so it's not perfect; time can be included
-			return (/(^\d{1,2}[\/\s]\d{1,2}[\/\s]\d{4})|(^\d{4}[\/\s]\d{1,2}[\/\s]\d{1,2})/).test(s);
+			s = (s || '').replace(ts.regex.spaces, ' ').replace(ts.regex.shortDateReplace, '/');
+			return ts.regex.shortDateTest.test(s);
 		},
 		format: function(s, table, cell, cellIndex) {
 			if (s) {
@@ -2220,14 +2256,13 @@
 					format = ci.length && ci[0].dateFormat ||
 						ts.getData( ci, ts.getColumnData( table, c.headers, cellIndex ), 'dateFormat') ||
 						c.dateFormat;
-				// escaped "-" because JSHint in Firefox was showing it as an error
-				d = s.replace(/\s+/g, ' ').replace(/[\-.,]/g, '/');
+				d = s.replace(ts.regex.spaces, ' ').replace(ts.regex.shortDateReplace, '/');
 				if (format === 'mmddyyyy') {
-					d = d.replace(/(\d{1,2})[\/\s](\d{1,2})[\/\s](\d{4})/, '$3/$1/$2');
+					d = d.replace(ts.regex.shortDateXXY, '$3/$1/$2');
 				} else if (format === 'ddmmyyyy') {
-					d = d.replace(/(\d{1,2})[\/\s](\d{1,2})[\/\s](\d{4})/, '$3/$2/$1');
+					d = d.replace(ts.regex.shortDateXXY, '$3/$2/$1');
 				} else if (format === 'yyyymmdd') {
-					d = d.replace(/(\d{4})[\/\s](\d{1,2})[\/\s](\d{1,2})/, '$1/$2/$3');
+					d = d.replace(ts.regex.shortDateYMD, '$1/$2/$3');
 				}
 				date = new Date(d);
 				return date instanceof Date && isFinite(date) ? date.getTime() : s;
@@ -2237,13 +2272,14 @@
 		type: 'numeric'
 	});
 
+	ts.regex.timeTest = /^(([0-2]?\d:[0-5]\d)|([0-1]?\d:[0-5]\d\s?([AP]M)))$/i;
 	ts.addParser({
 		id: 'time',
 		is: function(s) {
-			return (/^(([0-2]?\d:[0-5]\d)|([0-1]?\d:[0-5]\d\s?([AP]M)))$/i).test(s);
+			return ts.regex.timeTest.test(s);
 		},
 		format: function(s, table) {
-			var date = s ? new Date( '2000/01/01 ' + s.replace(/(\S)([AP]M)$/i, '$1 $2') ) : s;
+			var date = s ? new Date( '2000/01/01 ' + s.replace(ts.regex.dateReplace, '$1 $2') ) : s;
 			return date instanceof Date && isFinite(date) ? date.getTime() : s;
 		},
 		type: 'numeric'

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

@@ -4,7 +4,7 @@
 ██  ██ ██  ██   ██  ██ ██  ██   ██     ██ ██ ██ ██  ██ ██  ██ ██ ██▀▀   ▀▀▀▀██
 █████▀ ▀████▀   ██  ██ ▀████▀   ██     ██ ██ ██ ▀████▀ █████▀ ██ ██     █████▀
 */
-/*! tablesorter (FORK) - updated 08-19-2015 (v2.23.1)*/
+/*! tablesorter (FORK) - updated 08-23-2015 (v2.23.2)*/
 /* Includes widgets ( storage,uitheme,columns,filter,stickyHeaders,resizable,saveSort ) */
 (function(factory) {
 	if (typeof define === 'function' && define.amd) {
@@ -372,14 +372,15 @@
 
 })(jQuery);
 
-/*! 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',
@@ -423,7 +424,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 ) {
@@ -435,7 +436,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; }
@@ -450,7 +451,7 @@
 		}
 	});
 
-	ts.filter = {
+	tsf = ts.filter = {
 
 		// regex used in filter 'check' functions - not for general use and not documented
 		regex: {
@@ -459,9 +460,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
@@ -478,27 +483,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;
 							}
@@ -513,27 +518,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 {
@@ -550,10 +555,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 ) {
@@ -572,18 +577,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;
@@ -592,13 +597,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 === '' ) {
@@ -610,13 +615,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 ) );
@@ -628,27 +633,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 );
@@ -659,7 +664,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 ) {
@@ -671,18 +676,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 );
@@ -694,12 +699,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;
@@ -722,7 +727,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
@@ -733,7 +738,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 ),
@@ -742,9 +747,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'
@@ -752,7 +768,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 '
@@ -765,13 +781,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
@@ -785,7 +801,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;
 			});
@@ -818,7 +834,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 ) {
@@ -851,7 +867,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 ) );
 							}
 						}
 					}
@@ -859,22 +875,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 ) ?
@@ -894,11 +910,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( '' ) === '' ) ) {
@@ -909,7 +925,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 );
 			});
@@ -917,7 +933,7 @@
 			if ( c.pager && c.pager.initialized && !wo.filter_initialized ) {
 				c.$table.trigger( 'filterFomatterUpdate' );
 				setTimeout( function() {
-					ts.filter.filterInitComplete( c );
+					tsf.filterInitComplete( c );
 				}, 100 );
 			}
 		},
@@ -938,7 +954,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();
@@ -1090,7 +1106,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() );
@@ -1110,17 +1126,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 );
 				}
 			});
 		},
@@ -1130,11 +1147,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 ) {
@@ -1148,7 +1165,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;
@@ -1179,11 +1196,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;
 			}
 		},
@@ -1226,8 +1243,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,
@@ -1263,7 +1280,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 );
@@ -1310,9 +1330,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;
 					}
@@ -1321,16 +1341,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 ) {
@@ -1354,7 +1381,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;
@@ -1415,7 +1442,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;
@@ -1446,13 +1473,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 {
@@ -1472,7 +1499,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
@@ -1549,7 +1576,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 ) {
@@ -1591,10 +1618,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' ) );
@@ -1613,7 +1640,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;
 						}
@@ -1656,7 +1683,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 ) {
@@ -1667,7 +1694,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 );
@@ -1729,7 +1756,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
@@ -1841,13 +1868,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
@@ -1903,7 +1930,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 ) );
 				}
 			}
 		}
@@ -1939,7 +1966,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 ) {
@@ -1989,7 +2016,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;