jquery-tablesorter 1.16.5 → 1.17.0

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

@@ -1,13 +1,13 @@
-/*! Widget: filter - updated 3/26/2015 (v2.21.3) *//*
+/*! Widget: filter - updated 5/17/2015 (v2.22.0) *//*
  * Requires tablesorter v2.8+ and jQuery 1.7+
  * by Rob Garrison
  */
-;(function ($) {
+;( function ( $ ) {
 'use strict';
-var ts = $.tablesorter = $.tablesorter || {},
+var ts = $.tablesorter || {},
 	tscss = ts.css;
 
-$.extend(tscss, {
+$.extend( tscss, {
 	filterRow      : 'tablesorter-filter-row',
 	filter         : 'tablesorter-filter',
 	filterDisabled : 'disabled',
@@ -15,26 +15,27 @@ $.extend(tscss, {
 });
 
 ts.addWidget({
-	id: "filter",
+	id: 'filter',
 	priority: 50,
 	options : {
 		filter_childRows     : false, // if true, filter includes child row content in the search
+		filter_childByColumn : false, // ( filter_childRows must be true ) if true = search child rows by column; false = search all child row text grouped
 		filter_columnFilters : true,  // if true, a filter will be added to the top of each table column
-		filter_columnAnyMatch: true,  // if true, allows using "#:{query}" in AnyMatch searches (column:query)
-		filter_cellFilter    : '',    // css class name added to the filter cell (string or array)
-		filter_cssFilter     : '',    // css class name added to the filter row & each input in the row (tablesorter-filter is ALWAYS added)
-		filter_defaultFilter : {},    // add a default column filter type "~{query}" to make fuzzy searches default; "{q1} AND {q2}" to make all searches use a logical AND.
+		filter_columnAnyMatch: true,  // if true, allows using '#:{query}' in AnyMatch searches ( column:query )
+		filter_cellFilter    : '',    // css class name added to the filter cell ( string or array )
+		filter_cssFilter     : '',    // css class name added to the filter row & each input in the row ( tablesorter-filter is ALWAYS added )
+		filter_defaultFilter : {},    // add a default column filter type '~{query}' to make fuzzy searches default; '{q1} AND {q2}' to make all searches use a logical AND.
 		filter_excludeFilter : {},    // filters to exclude, per column
-		filter_external      : '',    // jQuery selector string (or jQuery object) of external filters
+		filter_external      : '',    // jQuery selector string ( or jQuery object ) of external filters
 		filter_filteredRow   : 'filtered', // class added to filtered rows; needed by pager plugin
 		filter_formatter     : null,  // add custom filter elements to the filter row
 		filter_functions     : null,  // add custom filter functions using this option
 		filter_hideEmpty     : true,  // hide filter row when table is empty
 		filter_hideFilters   : false, // collapse filter row when mouse leaves the area
 		filter_ignoreCase    : true,  // if true, make all searches case-insensitive
-		filter_liveSearch    : true,  // if true, search column content while the user types (with a delay)
-		filter_onlyAvail     : 'filter-onlyAvail', // a header with a select dropdown & this class name will only show available (visible) options within the drop down
-		filter_placeholder   : { search : '', select : '' }, // default placeholder text (overridden by any header "data-placeholder" setting)
+		filter_liveSearch    : true,  // if true, search column content while the user types ( with a delay )
+		filter_onlyAvail     : 'filter-onlyAvail', // a header with a select dropdown & this class name will only show available ( visible ) options within the drop down
+		filter_placeholder   : { search : '', select : '' }, // default placeholder text ( overridden by any header 'data-placeholder' setting )
 		filter_reset         : null,  // jQuery selector string of an element used to reset the filters
 		filter_saveFilters   : false, // Use the $.tablesorter.storage utility to save the most recent filters
 		filter_searchDelay   : 300,   // typing delay in milliseconds before starting a search
@@ -46,37 +47,38 @@ ts.addWidget({
 		filter_defaultAttrib : 'data-value', // data attribute in the header cell that contains the default filter value
 		filter_selectSourceSeparator : '|' // filter_selectSource array text left of the separator is added to the option value, right into the option text
 	},
-	format: function(table, c, wo) {
-		if (!c.$table.hasClass('hasFilters')) {
-			ts.filter.init(table, c, wo);
+	format: function( table, c, wo ) {
+		if ( !c.$table.hasClass( 'hasFilters' ) ) {
+			ts.filter.init( table, c, wo );
 		}
 	},
-	remove: function(table, c, wo, refreshing) {
+	remove: function( table, c, wo, refreshing ) {
 		var tbodyIndex, $tbody,
 			$table = c.$table,
 			$tbodies = c.$tbodies,
-			events = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter ');
+			events = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '
+				.split( ' ' ).join( c.namespace + 'filter ' );
 		$table
-			.removeClass('hasFilters')
+			.removeClass( 'hasFilters' )
 			// add .tsfilter namespace to all BUT search
-			.unbind( events.replace(/\s+/g, ' ') )
+			.unbind( events.replace( /\s+/g, ' ' ) )
 			// remove the filter row even if refreshing, because the column might have been moved
-			.find('.' + tscss.filterRow).remove();
-		if (refreshing) { return; }
-		for (tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
-			$tbody = ts.processTbody(table, $tbodies.eq(tbodyIndex), true); // remove tbody
-			$tbody.children().removeClass(wo.filter_filteredRow).show();
-			ts.processTbody(table, $tbody, false); // restore tbody
+			.find( '.' + tscss.filterRow ).remove();
+		if ( refreshing ) { return; }
+		for ( tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
+			$tbody = ts.processTbody( table, $tbodies.eq( tbodyIndex ), true ); // remove tbody
+			$tbody.children().removeClass( wo.filter_filteredRow ).show();
+			ts.processTbody( table, $tbody, false ); // restore tbody
 		}
-		if (wo.filter_reset) {
-			$(document).undelegate(wo.filter_reset, 'click.tsfilter');
+		if ( wo.filter_reset ) {
+			$( document ).undelegate( wo.filter_reset, 'click.tsfilter' );
 		}
 	}
 });
 
 ts.filter = {
 
-	// regex used in filter "check" functions - not for general use and not documented
+	// regex used in filter 'check' functions - not for general use and not documented
 	regex: {
 		regex     : /^\/((?:\\\/|[^\/])+)\/([mig]{0,3})?$/, // regex to test for regex
 		child     : /tablesorter-childRow/, // child row class name; this gets updated in the script
@@ -89,22 +91,33 @@ ts.filter = {
 	},
 		// function( c, data ) { }
 		// c = table.config
-		// data.filter = array of filter input values;
-		// data.iFilter = same array, except lowercase (if wo.filter_ignoreCase is true)
-		// data.exact = table cell text (or parsed data if column parser enabled)
-		// data.iExact = same as data.exact, except lowercase (if wo.filter_ignoreCase is true)
-		// data.cache = table cell text from cache, so it has been parsed (& in all lower case if config.ignoreCase is true)
-		// data.index = column index; table = table element (DOM)
-		// data.parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
+		// data.$row = jQuery object of the row currently being processed
+		// data.$cells = jQuery object of all cells within the current row
+		// data.filters = array of filters for all columns ( some may be undefined )
+		// data.filter = filter for the current column
+		// data.iFilter = same as data.filter, except lowercase ( if wo.filter_ignoreCase is true )
+		// data.exact = table cell text ( or parsed data if column parser enabled )
+		// data.iExact = same as data.exact, except lowercase ( if wo.filter_ignoreCase is true )
+		// data.cache = table cell text from cache, so it has been parsed ( & in all lower case if c.ignoreCase is true )
+		// data.cacheArray = An array of parsed content from each table cell in the row being processed
+		// data.index = column index; table = table element ( DOM )
+		// data.parsed = array ( by column ) of boolean values ( from filter_useParsedData or 'filter-parsed' class )
 	types: {
 		// Look for regex
 		regex: function( c, data ) {
-			if ( ts.filter.regex.regex.test(data.iFilter) ) {
+			if ( ts.filter.regex.regex.test( data.filter ) ) {
 				var matches,
-					regex = ts.filter.regex.regex.exec(data.iFilter);
+					// cache regex per column for optimal speed
+					regex = data.filter_regexCache[ data.index ] || ts.filter.regex.regex.exec( data.filter ),
+					isRegex = regex instanceof RegExp;
 				try {
-					matches = new RegExp(regex[1], regex[2]).test( data.iExact );
-				} catch (error) {
+					if ( !isRegex ) {
+						// force case insensitive search if ignoreCase option set?
+						// if ( c.ignoreCase && !regex[2] ) { regex[2] = 'i'; }
+						data.filter_regexCache[ data.index ] = regex = new RegExp( regex[1], regex[2] );
+					}
+					matches = regex.test( data.exact );
+				} catch ( error ) {
 					matches = false;
 				}
 				return matches;
@@ -113,46 +126,56 @@ ts.filter = {
 		},
 		// Look for operators >, >=, < or <=
 		operators: function( c, data ) {
-			if ( /^[<>]=?/.test(data.iFilter) ) {
-				var cachedValue, result,
+			// ignore empty strings... because '' < 10 is true
+			if ( /^[<>]=?/.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( ts.filter.regex.operators, '' ), table ),
 					parser = c.parsers[index],
 					savedSearch = query;
-				// parse filter value in case we're comparing numbers (dates)
-				if (parsed || parser.type === 'numeric') {
-					result = ts.filter.parseFilter(c, $.trim('' + data.iFilter.replace(ts.filter.regex.operators, '')), index, parsed, true);
-					query = ( typeof result === "number" && result !== '' && !isNaN(result) ) ? result : 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 );
+					query = ( typeof result === 'number' && result !== '' && !isNaN( result ) ) ? result : query;
 				}
-
 				// iExact may be numeric - see issue #149;
-				// check if cached is defined, because sometimes j goes out of range? (numeric columns)
-				cachedValue = ( parsed || parser.type === 'numeric' ) && !isNaN(query) && typeof data.cache !== 'undefined' ? data.cache :
-					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
-					ts.formatFloat( data.iExact, table );
-
-				if ( />/.test(data.iFilter) ) { result = />=/.test(data.iFilter) ? cachedValue >= query : cachedValue > query; }
-				if ( /</.test(data.iFilter) ) { result = /<=/.test(data.iFilter) ? cachedValue <= query : cachedValue < query; }
+				// check if cached is defined, because sometimes j goes out of range? ( numeric columns )
+				if ( ( parsed || parser.type === 'numeric' ) && !isNaN( query ) &&
+					typeof data.cache !== 'undefined' ) {
+					cachedValue = data.cache;
+				} else {
+					txt = isNaN( data.iExact ) ? data.iExact.replace( ts.filter.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;
+				}
 				// keep showing all rows if nothing follows the operator
-				if ( !result && savedSearch === '' ) { result = true; }
+				if ( !result && savedSearch === '' ) {
+					result = true;
+				}
 				return result;
 			}
 			return null;
 		},
 		// Look for a not match
 		notMatch: function( c, data ) {
-			if ( /^\!/.test(data.iFilter) ) {
+			if ( /^\!/.test( data.iFilter ) ) {
 				var indx,
-					filter = ts.filter.parseFilter(c, data.iFilter.replace('!', ''), data.index, data.parsed[data.index]) || '';
-				if (ts.filter.regex.exact.test(filter)) {
+					txt = data.iFilter.replace( '!', '' ),
+					filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+				if ( ts.filter.regex.exact.test( filter ) ) {
 					// look for exact not matches - see #628
-					filter = filter.replace(ts.filter.regex.exact, '');
-					return filter === '' ? true : $.trim(filter) !== data.iExact;
+					filter = filter.replace( ts.filter.regex.exact, '' );
+					return filter === '' ? true : $.trim( filter ) !== data.iExact;
 				} else {
-					indx = data.iExact.search( $.trim(filter) );
-					return filter === '' ? true : !(c.widgetOptions.filter_startsWith ? indx === 0 : indx >= 0);
+					indx = data.iExact.search( $.trim( filter ) );
+					return filter === '' ? true : !( c.widgetOptions.filter_startsWith ? indx === 0 : indx >= 0 );
 				}
 			}
 			return null;
@@ -160,84 +183,101 @@ ts.filter = {
 		// 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 filter = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.exact, ''), data.index, data.parsed[data.index]) || '';
-				return data.anyMatch ? $.inArray(filter, data.rowArray) >= 0 : filter == data.iExact;
+			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] ) || '';
+				return data.anyMatch ? $.inArray( filter, data.rowArray ) >= 0 : filter == data.iExact;
 			}
 			return null;
 		},
-		// Look for an AND or && operator (logical and)
+		// Look for an AND or && operator ( logical and )
 		and : function( c, data ) {
-			if ( ts.filter.regex.andTest.test(data.filter) ) {
+			if ( ts.filter.regex.andTest.test( data.filter ) ) {
 				var index = data.index,
 					parsed = data.parsed[index],
 					query = data.iFilter.split( ts.filter.regex.andSplit ),
-					result = data.iExact.search( $.trim( ts.filter.parseFilter(c, query[0], index, parsed) ) ) >= 0,
+					result = data.iExact.search( $.trim( ts.filter.parseFilter( c, query[0], index, parsed ) ) ) >= 0,
 					indx = query.length - 1;
-				while (result && indx) {
-					result = result && data.iExact.search( $.trim( ts.filter.parseFilter(c, query[indx], index, parsed) ) ) >= 0;
+				while ( result && indx ) {
+					result = result &&
+						data.iExact.search( $.trim( ts.filter.parseFilter( c, query[indx], index, parsed ) ) ) >= 0;
 					indx--;
 				}
 				return result;
 			}
 			return null;
 		},
-		// Look for a range (using " to " or " - ") - see issue #166; thanks matzhu!
+		// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
 		range : function( c, data ) {
-			if ( ts.filter.regex.toTest.test(data.iFilter) ) {
-				var result, tmp,
+			if ( ts.filter.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 ),
-					range1 = ts.formatFloat( ts.filter.parseFilter(c, query[0].replace(ts.filter.regex.nondigit, '') || '', index, parsed), table ),
-					range2 = ts.formatFloat( ts.filter.parseFilter(c, query[1].replace(ts.filter.regex.nondigit, '') || '', 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);
-					range1 = (result !== '' && !isNaN(result)) ? result : range1;
-					result = c.parsers[index].format('' + query[1], table, c.$headers.eq(index), index);
-					range2 = (result !== '' && !isNaN(result)) ? result : range2;
+					query = data.iFilter.split( ts.filter.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 );
+				// 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 );
+					range1 = ( result !== '' && !isNaN( result ) ) ? result : range1;
+					result = c.parsers[ index ].format( '' + query[1], table, c.$headers.eq( index ), index );
+					range2 = ( result !== '' && !isNaN( result ) ) ? result : range2;
+				}
+				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;
+					result = ts.formatFloat( tmp, table );
+				}
+				if ( range1 > range2 ) {
+					tmp = range1; range1 = range2; range2 = tmp; // swap
 				}
-				result = ( parsed || c.parsers[index].type === 'numeric' ) && !isNaN(range1) && !isNaN(range2) ? data.cache :
-					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
-					ts.formatFloat( data.iExact, table );
-				if (range1 > range2) { tmp = range1; range1 = range2; range2 = tmp; } // swap
-				return (result >= range1 && result <= range2) || (range1 === '' || range2 === '');
+				return ( result >= range1 && result <= range2 ) || ( range1 === '' || range2 === '' );
 			}
 			return null;
 		},
 		// Look for wild card: ? = single, * = multiple, or | = logical OR
 		wild : function( c, data ) {
-			if ( /[\?\*\|]/.test(data.iFilter) || ts.filter.regex.orReplace.test(data.filter) ) {
+			if ( /[\?\*\|]/.test( data.iFilter ) || ts.filter.regex.orReplace.test( data.filter ) ) {
 				var index = data.index,
-					parsed = data.parsed[index],
-					query = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.orReplace, "|"), index, parsed) || '';
-				// look for an exact match with the "or" unless the "filter-match" class is found
-				if (!c.$headerIndexed[index].hasClass('filter-match') && /\|/.test(query)) {
+					parsed = data.parsed[ index ],
+					txt = data.iFilter.replace( ts.filter.regex.orReplace, '|' ),
+					query = ts.filter.parseFilter( c, txt, index, parsed ) || '';
+				// look for an exact match with the 'or' unless the 'filter-match' class is found
+				if ( !c.$headerIndexed[ index ].hasClass( 'filter-match' ) && /\|/.test( query ) ) {
 					// show all results while using filter match. Fixes #727
-					if (query[ query.length - 1 ] === '|') { query += '*'; }
-					query = data.anyMatch && $.isArray(data.rowArray) ? '(' + query + ')' : '^(' + query + ')$';
+					if ( query[ query.length - 1 ] === '|' ) {
+						query += '*';
+					}
+					query = data.anyMatch && $.isArray( data.rowArray ) ?
+						'(' + query + ')' :
+						'^(' + query + ')$';
 				}
 				// parsing the filter may not work properly when using wildcards =/
-				return new RegExp( query.replace(/\?/g, '\\S{1}').replace(/\*/g, '\\S*') ).test(data.iExact);
+				return new RegExp( query.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' ) )
+					.test( data.iExact );
 			}
 			return null;
 		},
-		// fuzzy text search; modified from https://github.com/mattyork/fuzzy (MIT license)
+		// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
 		fuzzy: function( c, data ) {
-			if ( /^~/.test(data.iFilter) ) {
+			if ( /^~/.test( data.iFilter ) ) {
 				var indx,
 					patternIndx = 0,
 					len = data.iExact.length,
-					pattern = ts.filter.parseFilter(c, data.iFilter.slice(1), data.index, data.parsed[data.index]) || '';
-				for (indx = 0; indx < len; indx++) {
-					if (data.iExact[indx] === pattern[patternIndx]) {
+					txt = data.iFilter.slice( 1 ),
+					pattern = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+				for ( indx = 0; indx < len; indx++ ) {
+					if ( data.iExact[ indx ] === pattern[ patternIndx ] ) {
 						patternIndx += 1;
 					}
 				}
-				if (patternIndx === pattern.length) {
+				if ( patternIndx === pattern.length ) {
 					return true;
 				}
 				return false;
@@ -245,17 +285,17 @@ ts.filter = {
 			return null;
 		}
 	},
-	init: function(table, c, wo) {
+	init: function( table, c, wo ) {
 		// filter language options
-		ts.language = $.extend(true, {}, {
+		ts.language = $.extend( true, {}, {
 			to  : 'to',
 			or  : 'or',
 			and : 'and'
-		}, ts.language);
+		}, ts.language );
 
 		var options, string, txt, $header, column, filters, val, fxn, noSelect,
 			regex = ts.filter.regex;
-		c.$table.addClass('hasFilters');
+		c.$table.addClass( 'hasFilters' );
 
 		// define timers so using clearTimeout won't cause an undefined error
 		wo.searchTimer = null;
@@ -265,512 +305,566 @@ ts.filter = {
 		wo.filter_anyColumnSelector = '[data-column="all"],[data-column="any"]';
 		wo.filter_multipleColumnSelector = '[data-column*="-"],[data-column*=","]';
 
-		txt = '\\{' + ts.filter.regex.query + '\\}';
+		val = '\\{' + ts.filter.regex.query + '\\}';
 		$.extend( regex, {
-			child : new RegExp(c.cssChildRow),
-			filtered : new RegExp(wo.filter_filteredRow),
-			alreadyFiltered : new RegExp('(\\s+(' + ts.language.or + '|-|' + ts.language.to + ')\\s+)', 'i'),
-			toTest : new RegExp('\\s+(-|' + ts.language.to + ')\\s+', 'i'),
-			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'),
-			orReplace : new RegExp('\\s+(' + ts.language.or + ')\\s+', 'gi'),
-			iQuery : new RegExp(txt, 'i'),
-			igQuery : new RegExp(txt, 'ig')
+			child : new RegExp( c.cssChildRow ),
+			filtered : new RegExp( wo.filter_filteredRow ),
+			alreadyFiltered : new RegExp( '(\\s+(' + ts.language.or + '|-|' + ts.language.to + ')\\s+)', 'i' ),
+			toTest : new RegExp( '\\s+(-|' + ts.language.to + ')\\s+', 'i' ),
+			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' ),
+			orReplace : new RegExp( '\\s+(' + ts.language.or + ')\\s+', 'gi' ),
+			iQuery : new RegExp( val, 'i' ),
+			igQuery : new RegExp( val, 'ig' )
 		});
 
-		// don't build filter row if columnFilters is false or all columns are set to "filter-false" - issue #156
-		if (wo.filter_columnFilters !== false && c.$headers.filter('.filter-false, .parser-false').length !== c.$headers.length) {
+		// don't build filter row if columnFilters is false or all columns are set to 'filter-false'
+		// see issue #156
+		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);
+			ts.filter.buildRow( table, c, wo );
 		}
 
-		txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter ');
-		c.$table.bind( txt, function(event, filter) {
-			val = (wo.filter_hideEmpty && $.isEmptyObject(c.cache) && !(c.delayInit && event.type === 'appendCache'));
-			// hide filter row using the "filtered" class name
-			c.$table.find('.' + tscss.filterRow).toggleClass(wo.filter_filteredRow, val ); // fixes #450
-			if ( !/(search|filter)/.test(event.type) ) {
+		txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '
+			.split( ' ' ).join( c.namespace + 'filter ' );
+		c.$table.bind( txt, function( event, filter ) {
+			val = wo.filter_hideEmpty &&
+				$.isEmptyObject( c.cache ) &&
+				!( c.delayInit && event.type === 'appendCache' );
+			// hide filter row using the 'filtered' class name
+			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);
+				ts.filter.buildDefault( table, true );
 			}
-			if (event.type === 'filterReset') {
-				c.$table.find('.' + tscss.filter).add(wo.filter_$externalFilters).val('');
-				ts.filter.searching(table, []);
-			} else if (event.type === 'filterEnd') {
-				ts.filter.buildDefault(table, true);
+			if ( event.type === 'filterReset' ) {
+				c.$table.find( '.' + tscss.filter ).add( wo.filter_$externalFilters ).val( '' );
+				ts.filter.searching( table, [] );
+			} else if ( event.type === 'filterEnd' ) {
+				ts.filter.buildDefault( table, true );
 			} else {
-				// send false argument to force a new search; otherwise if the filter hasn't changed, it will return
-				filter = event.type === 'search' ? filter : event.type === 'updateComplete' ? c.$table.data('lastSearch') : '';
-				if (/(update|add)/.test(event.type) && event.type !== "updateComplete") {
+				// send false argument to force a new search; otherwise if the filter hasn't changed,
+				// it will return
+				filter = event.type === 'search' ? filter :
+					event.type === 'updateComplete' ? c.$table.data( 'lastSearch' ) : '';
+				if ( /(update|add)/.test( event.type ) && event.type !== 'updateComplete' ) {
 					// force a new search since content has changed
 					c.lastCombinedFilter = null;
 					c.lastSearch = [];
 				}
-				// 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);
+				// 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 );
 			}
 			return false;
 		});
 
 		// reset button/link
-		if (wo.filter_reset) {
-			if (wo.filter_reset instanceof $) {
+		if ( wo.filter_reset ) {
+			if ( wo.filter_reset instanceof $ ) {
 				// reset contains a jQuery object, bind to it
-				wo.filter_reset.click(function(){
-					c.$table.trigger('filterReset');
+				wo.filter_reset.click( function() {
+					c.$table.trigger( 'filterReset' );
 				});
-			} else if ($(wo.filter_reset).length) {
+			} else if ( $( wo.filter_reset ).length ) {
 				// reset is a jQuery selector, use event delegation
-				$(document)
-				.undelegate(wo.filter_reset, 'click.tsfilter')
-				.delegate(wo.filter_reset, 'click.tsfilter', function() {
-					// trigger a reset event, so other functions (filter_formatter) know when to reset
-					c.$table.trigger('filterReset');
-				});
+				$( document )
+					.undelegate( wo.filter_reset, 'click.tsfilter' )
+					.delegate( wo.filter_reset, 'click.tsfilter', function() {
+						// trigger a reset event, so other functions ( filter_formatter ) know when to reset
+						c.$table.trigger( 'filterReset' );
+					});
 			}
 		}
-		if (wo.filter_functions) {
-			for (column = 0; column < c.columns; column++) {
+		if ( wo.filter_functions ) {
+			for ( column = 0; column < c.columns; column++ ) {
 				fxn = ts.getColumnData( table, wo.filter_functions, column );
-				if (fxn) {
-					// remove "filter-select" from header otherwise the options added here are replaced with all options
-					$header = c.$headerIndexed[column].removeClass('filter-select');
-					// don't build select if "filter-false" or "parser-false" set
-					noSelect = !($header.hasClass('filter-false') || $header.hasClass('parser-false'));
+				if ( fxn ) {
+					// remove 'filter-select' from header otherwise the options added here are replaced with
+					// all options
+					$header = c.$headerIndexed[ column ].removeClass( 'filter-select' );
+					// don't build select if 'filter-false' or 'parser-false' set
+					noSelect = !( $header.hasClass( 'filter-false' ) || $header.hasClass( 'parser-false' ) );
 					options = '';
 					if ( fxn === true && noSelect ) {
-						ts.filter.buildSelect(table, column);
+						ts.filter.buildSelect( table, column );
 					} else if ( typeof fxn === 'object' && noSelect ) {
 						// add custom drop down list
-						for (string in fxn) {
-							if (typeof string === 'string') {
+						for ( string in fxn ) {
+							if ( typeof string === 'string' ) {
 								options += options === '' ?
-									'<option value="">' + ($header.data('placeholder') || $header.attr('data-placeholder') || wo.filter_placeholder.select || '') + '</option>' : '';
+									'<option value="">' +
+										( $header.data( 'placeholder' ) ||
+											$header.attr( 'data-placeholder' ) ||
+											wo.filter_placeholder.select ||
+											''
+										) +
+									'</option>' : '';
 								val = string;
 								txt = string;
-								if (string.indexOf(wo.filter_selectSourceSeparator) >= 0) {
-									val = string.split(wo.filter_selectSourceSeparator);
+								if ( string.indexOf( wo.filter_selectSourceSeparator ) >= 0 ) {
+									val = string.split( wo.filter_selectSourceSeparator );
 									txt = val[1];
 									val = val[0];
 								}
-								options += '<option ' + (txt === val ? '' : 'data-function-name="' + string + '" ') + 'value="' + val + '">' + txt + '</option>';
+								options += '<option ' +
+									( txt === val ? '' : 'data-function-name="' + string + '" ' ) +
+									'value="' + val + '">' + txt + '</option>';
 							}
 						}
-						c.$table.find('thead').find('select.' + tscss.filter + '[data-column="' + column + '"]').append(options);
+						c.$table
+							.find( 'thead' )
+							.find( 'select.' + tscss.filter + '[data-column="' + column + '"]' )
+							.append( options );
 						txt = wo.filter_selectSource;
-						fxn = $.isFunction(txt) ? true : ts.getColumnData( table, txt, column );
-						if (fxn) {
+						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));
+							ts.filter.buildSelect( c.table, column, '', true, $header.hasClass( wo.filter_onlyAvail ) );
 						}
 					}
 				}
 			}
 		}
-		// 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);
+		// 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 );
 
-		ts.filter.bindSearch( table, c.$table.find('.' + tscss.filter), true );
-		if (wo.filter_external) {
+		ts.filter.bindSearch( table, c.$table.find( '.' + tscss.filter ), true );
+		if ( wo.filter_external ) {
 			ts.filter.bindSearch( table, wo.filter_external );
 		}
 
-		if (wo.filter_hideFilters) {
-			ts.filter.hideFilters(table, c);
+		if ( wo.filter_hideFilters ) {
+			ts.filter.hideFilters( table, c );
 		}
 
 		// show processing icon
-		if (c.showProcessing) {
+		if ( c.showProcessing ) {
+			txt = 'filterStart filterEnd '.split( ' ' ).join( c.namespace + 'filter ' );
 			c.$table
-				.unbind( ('filterStart filterEnd '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
-				.bind( 'filterStart filterEnd '.split(' ').join(c.namespace + 'filter '), function(event, columns) {
+				.unbind( txt.replace( /\s+/g, ' ' ) )
+				.bind( txt, function( event, columns ) {
 				// only add processing to certain columns to all columns
-				$header = (columns) ? c.$table.find('.' + tscss.header).filter('[data-column]').filter(function() {
-					return columns[$(this).data('column')] !== '';
-				}) : '';
-				ts.isProcessing(table, event.type === 'filterStart', columns ? $header : '');
+				$header = ( columns ) ?
+					c.$table
+						.find( '.' + tscss.header )
+						.filter( '[data-column]' )
+						.filter( function() {
+							return columns[ $( this ).data( 'column' ) ] !== '';
+						}) : '';
+				ts.isProcessing( table, event.type === 'filterStart', columns ? $header : '' );
 			});
 		}
 
-		// set filtered rows count (intially unfiltered)
+		// set filtered rows count ( intially unfiltered )
 		c.filteredRows = c.totalRows;
 
 		// add default values
+		txt = 'tablesorter-initialized pagerBeforeInitialized '.split( ' ' ).join( c.namespace + 'filter ' );
 		c.$table
-		.unbind( ('tablesorter-initialized pagerBeforeInitialized '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
-		.bind( 'tablesorter-initialized pagerBeforeInitialized '.split(' ').join(c.namespace + 'filter '), function() {
-			// redefine "wo" as it does not update properly inside this callback
+		.unbind( txt.replace( /\s+/g, ' ' ) )
+		.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) || [];
-			if (filters.length) {
+			filters = ts.filter.setDefaults( table, c, wo ) || [];
+			if ( filters.length ) {
 				// prevent delayInit from triggering a cache build if filters are empty
-				if ( !(c.delayInit && filters.join('') === '') ) {
-					ts.setFilters(table, filters, true);
+				if ( !( c.delayInit && filters.join( '' ) === '' ) ) {
+					ts.setFilters( table, filters, true );
 				}
 			}
-			c.$table.trigger('filterFomatterUpdate');
+			c.$table.trigger( 'filterFomatterUpdate' );
 			// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
-			setTimeout(function(){
-				if (!wo.filter_initialized) {
-					ts.filter.filterInitComplete(c);
+			setTimeout( function() {
+				if ( !wo.filter_initialized ) {
+					ts.filter.filterInitComplete( c );
 				}
-			}, 100);
+			}, 100 );
 		});
 		// if filter widget is added after pager has initialized; then set filter init flag
-		if (c.pager && c.pager.initialized && !wo.filter_initialized) {
-			c.$table.trigger('filterFomatterUpdate');
-			setTimeout(function(){
-				ts.filter.filterInitComplete(c);
-			}, 100);
+		if ( c.pager && c.pager.initialized && !wo.filter_initialized ) {
+			c.$table.trigger( 'filterFomatterUpdate' );
+			setTimeout( function() {
+				ts.filter.filterInitComplete( c );
+			}, 100 );
 		}
 	},
-	// $cell parameter, but not the config, is passed to the
-	// filter_formatters, so we have to work with it instead
-	formatterUpdated: function($cell, column) {
-		var wo = $cell.closest('table')[0].config.widgetOptions;
-		if (!wo.filter_initialized) {
+	// $cell parameter, but not the config, is passed to the filter_formatters,
+	// so we have to work with it instead
+	formatterUpdated: function( $cell, column ) {
+		var wo = $cell.closest( 'table' )[0].config.widgetOptions;
+		if ( !wo.filter_initialized ) {
 			// add updates by column since this function
 			// may be called numerous times before initialization
-			wo.filter_formatterInit[column] = 1;
+			wo.filter_formatterInit[ column ] = 1;
 		}
 	},
-	filterInitComplete: function(c){
+	filterInitComplete: function( c ) {
 		var indx, len,
 			wo = c.widgetOptions,
 			count = 0,
-			completed = function(){
+			completed = function() {
 				wo.filter_initialized = true;
-				c.$table.trigger('filterInit', c);
-				ts.filter.findRows(c.table, c.$table.data('lastSearch') || []);
+				c.$table.trigger( 'filterInit', c );
+				ts.filter.findRows( c.table, c.$table.data( 'lastSearch' ) || [] );
 			};
 		if ( $.isEmptyObject( wo.filter_formatter ) ) {
 			completed();
 		} else {
 			len = wo.filter_formatterInit.length;
-			for (indx = 0; indx < len; indx++) {
-				if (wo.filter_formatterInit[indx] === 1) {
+			for ( indx = 0; indx < len; indx++ ) {
+				if ( wo.filter_formatterInit[ indx ] === 1 ) {
 					count++;
 				}
 			}
-			clearTimeout(wo.filter_initTimer);
-			if (!wo.filter_initialized && count === wo.filter_formatterCount) {
+			clearTimeout( wo.filter_initTimer );
+			if ( !wo.filter_initialized && count === wo.filter_formatterCount ) {
 				// filter widget initialized
 				completed();
-			} else if (!wo.filter_initialized) {
+			} else if ( !wo.filter_initialized ) {
 				// fall back in case a filter_formatter doesn't call
-				// $.tablesorter.filter.formatterUpdated($cell, column), and the count is off
-				wo.filter_initTimer = setTimeout(function(){
+				// $.tablesorter.filter.formatterUpdated( $cell, column ), and the count is off
+				wo.filter_initTimer = setTimeout( function() {
 					completed();
-				}, 500);
+				}, 500 );
 			}
 		}
 	},
 
-	setDefaults: function(table, c, wo) {
+	setDefaults: function( table, c, wo ) {
 		var isArray, saved, indx, col, $filters,
-			// get current (default) filters
-			filters = ts.getFilters(table) || [];
-		if (wo.filter_saveFilters && ts.storage) {
+			// get current ( default ) filters
+			filters = ts.getFilters( table ) || [];
+		if ( wo.filter_saveFilters && ts.storage ) {
 			saved = ts.storage( table, 'tablesorter-filters' ) || [];
-			isArray = $.isArray(saved);
+			isArray = $.isArray( saved );
 			// make sure we're not just getting an empty array
-			if ( !(isArray && saved.join('') === '' || !isArray) ) { filters = saved; }
+			if ( !( isArray && saved.join( '' ) === '' || !isArray ) ) {
+				filters = saved;
+			}
 		}
 		// if no filters saved, then check default settings
-		if (filters.join('') === '') {
+		if ( filters.join( '' ) === '' ) {
 			// allow adding default setting to external filters
-			$filters = c.$headers.add( wo.filter_$externalFilters ).filter('[' + wo.filter_defaultAttrib + ']');
-			for (indx = 0; indx <= c.columns; indx++) {
-				// include data-column="all" external filters
+			$filters = c.$headers.add( wo.filter_$externalFilters )
+				.filter( '[' + wo.filter_defaultAttrib + ']' );
+			for ( indx = 0; indx <= c.columns; indx++ ) {
+				// include data-column='all' external filters
 				col = indx === c.columns ? 'all' : indx;
-				filters[indx] = $filters.filter('[data-column="' + col + '"]').attr(wo.filter_defaultAttrib) || filters[indx] || '';
+				filters[indx] = $filters
+					.filter( '[data-column="' + col + '"]' )
+					.attr( wo.filter_defaultAttrib ) || filters[indx] || '';
 			}
 		}
-		c.$table.data('lastSearch', filters);
+		c.$table.data( 'lastSearch', filters );
 		return filters;
 	},
-	parseFilter: function(c, filter, column, parsed, forceParse){
-		return forceParse || parsed ?
-			c.parsers[column].format( filter, c.table, [], column ) :
-			filter;
+	parseFilter: function( c, filter, column, parsed ) {
+		return parsed ? c.parsers[column].format( filter, c.table, [], column ) : filter;
 	},
-	buildRow: function(table, c, wo) {
-		var col, column, $header, buildSelect, disabled, name, ffxn,
+	buildRow: function( table, c, wo ) {
+		var col, column, $header, buildSelect, disabled, name, ffxn, tmp,
 			// c.columns defined in computeThIndexes()
+			cellFilter = wo.filter_cellFilter,
 			columns = c.columns,
-			arry = $.isArray(wo.filter_cellFilter),
+			arry = $.isArray( cellFilter ),
 			buildFilter = '<tr role="row" class="' + tscss.filterRow + ' ' + c.cssIgnoreRow + '">';
-		for (column = 0; column < columns; column++) {
-			if (arry) {
-				buildFilter += '<td' + ( wo.filter_cellFilter[column] ? ' class="' + wo.filter_cellFilter[column] + '"' : '' ) + '></td>';
+		for ( column = 0; column < columns; column++ ) {
+			buildFilter += '<td';
+			if ( arry ) {
+				buildFilter += ( cellFilter[ column ] ? ' class="' + cellFilter[ column ] + '"' : '' );
 			} else {
-				buildFilter += '<td' + ( wo.filter_cellFilter !== '' ? ' class="' + wo.filter_cellFilter + '"' : '' ) + '></td>';
+				buildFilter += ( cellFilter !== '' ? ' class="' + cellFilter + '"' : '' );
 			}
+			buildFilter += '></td>';
 		}
-		c.$filters = $(buildFilter += '</tr>').appendTo( c.$table.children('thead').eq(0) ).find('td');
+		c.$filters = $( buildFilter += '</tr>' )
+			.appendTo( c.$table.children( 'thead' ).eq( 0 ) )
+			.find( 'td' );
 		// build each filter input
-		for (column = 0; column < columns; column++) {
+		for ( column = 0; column < columns; column++ ) {
 			disabled = false;
 			// assuming last cell of a column is the main column
-			$header = c.$headerIndexed[column];
+			$header = c.$headerIndexed[ column ];
 			ffxn = ts.getColumnData( table, wo.filter_functions, column );
-			buildSelect = (wo.filter_functions && ffxn && typeof ffxn !== "function" ) ||
-				$header.hasClass('filter-select');
+			buildSelect = ( wo.filter_functions && ffxn && typeof ffxn !== 'function' ) ||
+				$header.hasClass( 'filter-select' );
 			// get data from jQuery data, metadata, headers option or header class name
 			col = ts.getColumnData( table, c.headers, column );
-			disabled = ts.getData($header[0], col, 'filter') === 'false' || ts.getData($header[0], col, 'parser') === 'false';
+			disabled = ts.getData( $header[0], col, 'filter' ) === 'false' ||
+				ts.getData( $header[0], col, 'parser' ) === 'false';
 
-			if (buildSelect) {
-				buildFilter = $('<select>').appendTo( c.$filters.eq(column) );
+			if ( buildSelect ) {
+				buildFilter = $( '<select>' ).appendTo( c.$filters.eq( column ) );
 			} else {
 				ffxn = ts.getColumnData( table, wo.filter_formatter, column );
-				if (ffxn) {
+				if ( ffxn ) {
 					wo.filter_formatterCount++;
-					buildFilter = ffxn( c.$filters.eq(column), column );
+					buildFilter = ffxn( c.$filters.eq( column ), column );
 					// no element returned, so lets go find it
-					if (buildFilter && buildFilter.length === 0) {
-						buildFilter = c.$filters.eq(column).children('input');
+					if ( buildFilter && buildFilter.length === 0 ) {
+						buildFilter = c.$filters.eq( column ).children( 'input' );
 					}
 					// element not in DOM, so lets attach it
-					if ( buildFilter && (buildFilter.parent().length === 0 ||
-						(buildFilter.parent().length && buildFilter.parent()[0] !== c.$filters[column])) ) {
-						c.$filters.eq(column).append(buildFilter);
+					if ( buildFilter && ( buildFilter.parent().length === 0 ||
+						( buildFilter.parent().length && buildFilter.parent()[0] !== c.$filters[column] ) ) ) {
+						c.$filters.eq( column ).append( buildFilter );
 					}
 				} else {
-					buildFilter = $('<input type="search">').appendTo( c.$filters.eq(column) );
+					buildFilter = $( '<input type="search">' ).appendTo( c.$filters.eq( column ) );
 				}
-				if (buildFilter) {
-					buildFilter.attr('placeholder', $header.data('placeholder') || $header.attr('data-placeholder') || wo.filter_placeholder.search || '');
+				if ( buildFilter ) {
+					tmp = $header.data( 'placeholder' ) ||
+						$header.attr( 'data-placeholder' ) ||
+						wo.filter_placeholder.search || '';
+					buildFilter.attr( 'placeholder', tmp );
 				}
 			}
-			if (buildFilter) {
+			if ( buildFilter ) {
 				// add filter class name
-				name = ( $.isArray(wo.filter_cssFilter) ?
-					(typeof wo.filter_cssFilter[column] !== 'undefined' ? wo.filter_cssFilter[column] || '' : '') :
+				name = ( $.isArray( wo.filter_cssFilter ) ?
+					( typeof wo.filter_cssFilter[column] !== 'undefined' ? wo.filter_cssFilter[column] || '' : '' ) :
 					wo.filter_cssFilter ) || '';
-				buildFilter.addClass( tscss.filter + ' ' + name ).attr('data-column', column);
-				if (disabled) {
-					buildFilter.attr('placeholder', '').addClass(tscss.filterDisabled)[0].disabled = true; // disabled!
+				buildFilter.addClass( tscss.filter + ' ' + name ).attr( 'data-column', column );
+				if ( disabled ) {
+					buildFilter.attr( 'placeholder', '' ).addClass( tscss.filterDisabled )[0].disabled = true;
 				}
 			}
 		}
 	},
-	bindSearch: function(table, $el, internal) {
-		table = $(table)[0];
-		$el = $($el); // allow passing a selector string
-		if (!$el.length) { return; }
-		var c = table.config,
+	bindSearch: function( table, $el, internal ) {
+		table = $( table )[0];
+		$el = $( $el ); // allow passing a selector string
+		if ( !$el.length ) { return; }
+		var tmp,
+			c = table.config,
 			wo = c.widgetOptions,
+			namespace = c.namespace + 'filter',
 			$ext = wo.filter_$externalFilters;
-		if (internal !== true) {
+		if ( internal !== true ) {
 			// save anyMatch element
-			wo.filter_$anyMatch = $el.filter(wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector);
-			if ($ext && $ext.length) {
+			tmp = wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector;
+			wo.filter_$anyMatch = $el.filter( tmp );
+			if ( $ext && $ext.length ) {
 				wo.filter_$externalFilters = wo.filter_$externalFilters.add( $el );
 			} else {
 				wo.filter_$externalFilters = $el;
 			}
-			// update values (external filters added after table initialization)
-			ts.setFilters(table, c.$table.data('lastSearch') || [], internal === false);
+			// update values ( external filters added after table initialization )
+			ts.setFilters( table, c.$table.data( 'lastSearch' ) || [], internal === false );
 		}
+		// unbind events
+		tmp = ( 'keypress keyup search change '.split( ' ' ).join( namespace + ' ' ) );
 		$el
-		// use data attribute instead of jQuery data since the head is cloned without including the data/binding
-		.attr('data-lastSearchTime', new Date().getTime())
-		.unbind( ('keypress keyup search change '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
+		// 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, ' ' ) )
 		// include change for select - fixes #473
-		.bind('keyup' + c.namespace + 'filter', function(event) {
-			$(this).attr('data-lastSearchTime', new Date().getTime());
+		.bind( 'keyup' + namespace, function( event ) {
+			$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
 			// emulate what webkit does.... escape clears the filter
-			if (event.which === 27) {
+			if ( event.which === 27 ) {
 				this.value = '';
 			// live search
 			} else if ( wo.filter_liveSearch === false ) {
 				return;
-				// don't return if the search value is empty (all rows need to be revealed)
+				// don't return if the search value is empty ( all rows need to be revealed )
 			} else if ( this.value !== '' && (
 				// liveSearch can contain a min value length; ignore arrow and meta keys, but allow backspace
 				( typeof wo.filter_liveSearch === 'number' && this.value.length < wo.filter_liveSearch ) ||
 				// let return & backspace continue on, but ignore arrows & non-valid characters
-				( event.which !== 13 && event.which !== 8 && ( event.which < 32 || (event.which >= 37 && event.which <= 40) ) ) ) ) {
+				( event.which !== 13 && event.which !== 8 &&
+					( event.which < 32 || ( event.which >= 37 && event.which <= 40 ) ) ) ) ) {
 				return;
 			}
 			// change event = no delay; last true flag tells getFilters to skip newest timed input
 			ts.filter.searching( table, true, true );
 		})
-		.bind( 'search change keypress '.split(' ').join(c.namespace + 'filter '), function(event){
-			var column = $(this).data('column');
-			// 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]) {
+		.bind( 'search change keypress '.split( ' ' ).join( namespace + ' ' ), function( event ) {
+			var column = $( this ).data( 'column' );
+			// 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());
+				$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
 				ts.filter.searching( table, false, true );
 			}
 		});
 	},
-	searching: function(table, filter, skipFirst) {
+	searching: function( table, filter, skipFirst ) {
 		var wo = table.config.widgetOptions;
-		clearTimeout(wo.searchTimer);
-		if (typeof filter === 'undefined' || filter === true) {
+		clearTimeout( wo.searchTimer );
+		if ( typeof filter === 'undefined' || filter === true ) {
 			// delay filtering
-			wo.searchTimer = setTimeout(function() {
-				ts.filter.checkFilters(table, filter, skipFirst );
-			}, wo.filter_liveSearch ? wo.filter_searchDelay : 10);
+			wo.searchTimer = setTimeout( function() {
+				ts.filter.checkFilters( table, filter, skipFirst );
+			}, wo.filter_liveSearch ? wo.filter_searchDelay : 10 );
 		} else {
 			// skip delay
-			ts.filter.checkFilters(table, filter, skipFirst);
+			ts.filter.checkFilters( table, filter, skipFirst );
 		}
 	},
-	checkFilters: function(table, filter, skipFirst) {
+	checkFilters: function( table, filter, skipFirst ) {
 		var c = table.config,
 			wo = c.widgetOptions,
-			filterArray = $.isArray(filter),
-			filters = (filterArray) ? filter : ts.getFilters(table, true),
-			combinedFilters = (filters || []).join(''); // combined filter values
+			filterArray = $.isArray( filter ),
+			filters = ( filterArray ) ? filter : ts.getFilters( table, true ),
+			combinedFilters = ( filters || [] ).join( '' ); // combined filter values
 		// prevent errors if delay init is set
-		if ($.isEmptyObject(c.cache)) {
-			// 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);
-				}] );
+		if ( $.isEmptyObject( c.cache ) ) {
+			// 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 );
+				} ] );
 			}
 			return;
 		}
 		// add filter array back into inputs
-		if (filterArray) {
+		if ( filterArray ) {
 			ts.setFilters( table, filters, false, skipFirst !== true );
-			if (!wo.filter_initialized) { c.lastCombinedFilter = ''; }
+			if ( !wo.filter_initialized ) { c.lastCombinedFilter = ''; }
 		}
-		if (wo.filter_hideFilters) {
+		if ( wo.filter_hideFilters ) {
 			// show/hide filter row as needed
-			c.$table.find('.' + tscss.filterRow).trigger( combinedFilters === '' ? 'mouseleave' : 'mouseenter' );
+			c.$table
+				.find( '.' + tscss.filterRow )
+				.trigger( combinedFilters === '' ? 'mouseleave' : 'mouseenter' );
 		}
 		// return if the last search is the same; but filter === false when updating the search
 		// see example-widget-filter.html filter toggle buttons
-		if (c.lastCombinedFilter === combinedFilters && filter !== false) {
+		if ( c.lastCombinedFilter === combinedFilters && filter !== false ) {
 			return;
-		} else if (filter === false) {
+		} else if ( filter === false ) {
 			// force filter refresh
 			c.lastCombinedFilter = null;
 			c.lastSearch = [];
 		}
-		if (wo.filter_initialized) { c.$table.trigger('filterStart', [filters]); }
-		if (c.showProcessing) {
+		if ( wo.filter_initialized ) {
+			c.$table.trigger( 'filterStart', [filters] );
+		}
+		if ( c.showProcessing ) {
 			// give it time for the processing icon to kick in
-			setTimeout(function() {
-				ts.filter.findRows(table, filters, combinedFilters);
+			setTimeout( function() {
+				ts.filter.findRows( table, filters, combinedFilters );
 				return false;
-			}, 30);
+			}, 30 );
 		} else {
-			ts.filter.findRows(table, filters, combinedFilters);
+			ts.filter.findRows( table, filters, combinedFilters );
 			return false;
 		}
 	},
-	hideFilters: function(table, c) {
+	hideFilters: function( table, c ) {
 		var $filterRow, $filterRow2, timer;
-		$(table)
-			.find('.' + tscss.filterRow)
-			.addClass(tscss.filterRowHide)
-			.bind('mouseenter mouseleave', function(e) {
+		$( table )
+			.find( '.' + tscss.filterRow )
+			.addClass( tscss.filterRowHide )
+			.bind( 'mouseenter mouseleave', function( e ) {
 				// save event object - http://bugs.jquery.com/ticket/12140
 				var event = e;
-				$filterRow = $(this);
-				clearTimeout(timer);
-				timer = setTimeout(function() {
-					if ( /enter|over/.test(event.type) ) {
-						$filterRow.removeClass(tscss.filterRowHide);
+				$filterRow = $( this );
+				clearTimeout( timer );
+				timer = setTimeout( function() {
+					if ( /enter|over/.test( event.type ) ) {
+						$filterRow.removeClass( tscss.filterRowHide );
 					} else {
 						// don't hide if input has focus
-						// $(':focus') needs jQuery 1.6+
-						if ( $(document.activeElement).closest('tr')[0] !== $filterRow[0] ) {
+						// $( ':focus' ) needs jQuery 1.6+
+						if ( $( document.activeElement ).closest( 'tr' )[0] !== $filterRow[0] ) {
 							// don't hide row if any filter has a value
-							if (c.lastCombinedFilter === '') {
-								$filterRow.addClass(tscss.filterRowHide);
+							if ( c.lastCombinedFilter === '' ) {
+								$filterRow.addClass( tscss.filterRowHide );
 							}
 						}
 					}
-				}, 200);
+				}, 200 );
 			})
-			.find('input, select').bind('focus blur', function(e) {
-				$filterRow2 = $(this).closest('tr');
-				clearTimeout(timer);
+			.find( 'input, select' ).bind( 'focus blur', function( e ) {
+				$filterRow2 = $( this ).closest( 'tr' );
+				clearTimeout( timer );
 				var event = e;
-				timer = setTimeout(function() {
+				timer = setTimeout( function() {
 					// don't hide row if any filter has a value
-					if (ts.getFilters(c.$table).join('') === '') {
-						$filterRow2[ event.type === 'focus' ? 'removeClass' : 'addClass'](tscss.filterRowHide);
+					if ( ts.getFilters( c.$table ).join( '' ) === '' ) {
+						$filterRow2.toggleClass( tscss.filterRowHide, event.type === 'focus' );
 					}
-				}, 200);
+				}, 200 );
 			});
 	},
-	defaultFilter: function(filter, mask){
-		if (filter === '') { return filter; }
+	defaultFilter: function( filter, mask ) {
+		if ( filter === '' ) { return filter; }
 		var regex = ts.filter.regex.iQuery,
 			maskLen = mask.match( ts.filter.regex.igQuery ).length,
-			query = maskLen > 1 ? $.trim(filter).split(/\s/) : [ $.trim(filter) ],
+			query = maskLen > 1 ? $.trim( filter ).split( /\s/ ) : [ $.trim( filter ) ],
 			len = query.length - 1,
 			indx = 0,
 			val = mask;
 		if ( len < 1 && maskLen > 1 ) {
-			// only one "word" in query but mask has >1 slots
+			// only one 'word' in query but mask has >1 slots
 			query[1] = query[0];
 		}
 		// replace all {query} with query words...
-		// if query = "Bob", then convert mask from "!{query}" to "!Bob"
-		// if query = "Bob Joe Frank", then convert mask "{q} OR {q}" to "Bob OR Joe OR Frank"
-		while (regex.test(val)) {
-			val = val.replace(regex, query[indx++] || '');
-			if (regex.test(val) && indx < len && (query[indx] || '') !== '') {
-				val = mask.replace(regex, val);
+		// if query = 'Bob', then convert mask from '!{query}' to '!Bob'
+		// if query = 'Bob Joe Frank', then convert mask '{q} OR {q}' to 'Bob OR Joe OR Frank'
+		while ( regex.test( val ) ) {
+			val = val.replace( regex, query[indx++] || '' );
+			if ( regex.test( val ) && indx < len && ( query[indx] || '' ) !== '' ) {
+				val = mask.replace( regex, val );
 			}
 		}
 		return val;
 	},
 	getLatestSearch: function( $input ) {
-		if ($input) {
-			return $input.sort(function(a, b) {
-				return $(b).attr('data-lastSearchTime') - $(a).attr('data-lastSearchTime');
+		if ( $input ) {
+			return $input.sort( function( a, b ) {
+				return $( b ).attr( 'data-lastSearchTime' ) - $( a ).attr( 'data-lastSearchTime' );
 			});
 		}
 		return $();
 	},
 	multipleColumns: function( c, $input ) {
-		// look for multiple columns "1-3,4-6,8" in data-column
+		// look for multiple columns '1-3,4-6,8' in data-column
 		var temp, ranges, range, start, end, singles, i, indx, len,
 			wo = c.widgetOptions,
-			// only target "all" column inputs on initialization
-			// & don't target "all" column inputs if they don't exist
-			targets = wo.filter_initialized || !$input.filter(wo.filter_anyColumnSelector).length,
+			// only target 'all' column inputs on initialization
+			// & 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( ts.filter.getLatestSearch( $input ).attr( 'data-column' ) || '' );
 		// process column range
 		if ( targets && /-/.test( val ) ) {
 			ranges = val.match( /(\d+)\s*-\s*(\d+)/g );
 			len = ranges.length;
-			for (indx = 0; indx < len; indx++) {
+			for ( indx = 0; indx < len; indx++ ) {
 				range = ranges[indx].split( /\s*-\s*/ );
 				start = parseInt( range[0], 10 ) || 0;
 				end = parseInt( range[1], 10 ) || ( c.columns - 1 );
-				if ( start > end ) { temp = start; start = end; end = temp; } // swap
-				if ( end >= c.columns ) { end = c.columns - 1; }
+				if ( start > end ) {
+					temp = start; start = end; end = temp; // swap
+				}
+				if ( end >= c.columns ) {
+					end = c.columns - 1;
+				}
 				for ( ; start <= end; start++ ) {
-					columns.push(start);
+					columns.push( start );
 				}
 				// remove processed range from val
-				val = val.replace( ranges[indx], '' );
+				val = val.replace( ranges[ indx ], '' );
 			}
 		}
 		// process single columns
 		if ( targets && /,/.test( val ) ) {
 			singles = val.split( /\s*,\s*/ );
 			len = singles.length;
-			for (i = 0; i < len; i++) {
-				if (singles[i] !== '') {
-					indx = parseInt( singles[i], 10 );
+			for ( i = 0; i < len; i++ ) {
+				if ( singles[ i ] !== '' ) {
+					indx = parseInt( singles[ i ], 10 );
 					if ( indx < c.columns ) {
 						columns.push( indx );
 					}
@@ -778,382 +872,472 @@ ts.filter = {
 			}
 		}
 		// return all columns
-		if (!columns.length) {
+		if ( !columns.length ) {
 			for ( indx = 0; indx < c.columns; indx++ ) {
 				columns.push( indx );
 			}
 		}
 		return columns;
 	},
-	findRows: function(table, filters, combinedFilters) {
-		if (table.config.lastCombinedFilter === combinedFilters || !table.config.widgetOptions.filter_initialized) { return; }
-		var len, norm_rows, $rows, rowIndex, tbodyIndex, $tbody, $cells, $cell, columnIndex,
-			childRow, lastSearch, hasSelect, matches, result, showRow, time, val, indx,
-			notFiltered, searchFiltered, filterMatched, excludeMatch, fxn, ffxn,
-			query, injected, res, id,
+	processRow: function( c, data, vars ) {
+		var $cell, columnIndex, hasSelect, matches, result, val, filterMatched, excludeMatch,
+			fxn, ffxn, txt,
+			regex = ts.filter.regex,
+			wo = c.widgetOptions,
+			showRow = true;
+		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 );
+			data.anyMatch = true;
+			data.rowArray = data.$cells.map( function( i ) {
+				if ( $.inArray( i, columnIndex ) > -1 ) {
+					if ( data.parsed[ i ] ) {
+						txt = data.cacheArray[ i ];
+					} else {
+						txt = data.rawArray[ i ];
+						txt = $.trim( wo.filter_ignoreCase ? txt.toLowerCase() : txt );
+						if ( c.sortLocaleCompare ) {
+							txt = ts.replaceAccents( txt );
+						}
+					}
+					return txt;
+				}
+			}).get();
+			data.filter = data.anyMatchFilter;
+			data.iFilter = data.iAnyMatchFilter;
+			data.exact = data.rowArray.join( ' ' );
+			data.iExact = wo.filter_ignoreCase ? data.exact.toLowerCase() : data.exact;
+			data.cache = data.cacheArray.slice( 0, -1 ).join( ' ' );
+			filterMatched = null;
+			matches = null;
+			for ( ffxn in ts.filter.types ) {
+				if ( $.inArray( ffxn, vars.noAnyMatch ) < 0 && matches === null ) {
+					matches = ts.filter.types[ffxn]( c, data );
+					if ( matches !== null ) {
+						filterMatched = matches;
+					}
+				}
+			}
+			if ( filterMatched !== null ) {
+				showRow = filterMatched;
+			} else {
+				if ( wo.filter_startsWith ) {
+					showRow = false;
+					columnIndex = c.columns;
+					while ( !showRow && columnIndex > 0 ) {
+						columnIndex--;
+						showRow = showRow || data.rowArray[ columnIndex ].indexOf( data.iFilter ) === 0;
+					}
+				} else {
+					showRow = ( data.iExact + data.childRowText ).indexOf( data.iFilter ) >= 0;
+				}
+			}
+			data.anyMatch = false;
+			// no other filters to process
+			if ( data.filters.join( '' ) === data.filter ) {
+				return showRow;
+			}
+		}
+
+		for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
+			data.filter = data.filters[ columnIndex ];
+			data.index = columnIndex;
+
+			// filter types to exclude, per column
+			excludeMatch = vars.excludeFilter[ columnIndex ];
+
+			// ignore if filter is empty or disabled
+			if ( data.filter ) {
+				data.cache = data.cacheArray[ columnIndex ];
+				// check if column data should be from the cell or from parsed data
+				if ( wo.filter_useParsedData || data.parsed[ columnIndex ] ) {
+					data.exact = data.cache;
+				} else {
+					result = data.rawArray[ columnIndex ] || '';
+					data.exact = c.sortLocaleCompare ? ts.replaceAccents( result ) : result; // issue #405
+				}
+				data.iExact = !regex.type.test( typeof data.exact ) && wo.filter_ignoreCase ?
+					data.exact.toLowerCase() : data.exact;
+				result = showRow; // if showRow is true, show that row
+
+				// in case select filter option has a different value vs text 'a - z|A through Z'
+				ffxn = wo.filter_columnFilters ?
+					c.$filters.add( c.$externalFilters )
+						.filter( '[data-column="'+ columnIndex + '"]' )
+						.find( 'select option:selected' )
+						.attr( 'data-function-name' ) || '' : '';
+				// replace accents - see #357
+				if ( c.sortLocaleCompare ) {
+					data.filter = ts.replaceAccents( data.filter );
+				}
+
+				val = true;
+				if ( wo.filter_defaultFilter && regex.iQuery.test( vars.defaultColFilter[ columnIndex ] ) ) {
+					data.filter = ts.filter.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;
+				}
+				// data.iFilter = case insensitive ( if wo.filter_ignoreCase is true ),
+				// data.filter = case sensitive
+				data.iFilter = wo.filter_ignoreCase ? ( data.filter || '' ).toLowerCase() : data.filter;
+				fxn = vars.functions[ columnIndex ];
+				$cell = c.$headerIndexed[ columnIndex ];
+				hasSelect = $cell.hasClass( 'filter-select' );
+				filterMatched = null;
+				if ( fxn || ( hasSelect && val ) ) {
+					if ( fxn === true || hasSelect ) {
+						// default selector uses exact match unless 'filter-match' class is found
+						filterMatched = $cell.hasClass( 'filter-match' ) ?
+							data.iExact.search( data.iFilter ) >= 0 :
+							data.filter === data.exact;
+					} else if ( typeof fxn === 'function' ) {
+						// filter callback( exact cell content, parser normalized content,
+						// filter input value, column index, jQuery row object )
+						filterMatched = fxn( data.exact, data.cache, data.filter, columnIndex, data.$row, c, data );
+					} else if ( typeof fxn[ ffxn || data.filter ] === 'function' ) {
+						// selector option function
+						txt = ffxn || data.filter;
+						filterMatched =
+							fxn[ txt ]( data.exact, data.cache, data.filter, columnIndex, data.$row, c, data );
+					}
+				}
+				if ( filterMatched === null ) {
+					// cycle through the different filters
+					// filters return a boolean or null if nothing matches
+					matches = null;
+					for ( ffxn in ts.filter.types ) {
+						if ( $.inArray( ffxn, excludeMatch ) < 0 && matches === null ) {
+							matches = ts.filter.types[ ffxn ]( c, data );
+							if ( matches !== null ) {
+								filterMatched = matches;
+							}
+						}
+					}
+					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 ] ) );
+						result = ( ( !wo.filter_startsWith && txt >= 0 ) || ( wo.filter_startsWith && txt === 0 ) );
+					}
+				} else {
+					result = filterMatched;
+				}
+				showRow = ( result ) ? showRow : false;
+			}
+		}
+		return showRow;
+	},
+	findRows: function( table, filters, combinedFilters ) {
+		if ( table.config.lastCombinedFilter === combinedFilters ||
+			!table.config.widgetOptions.filter_initialized ) {
+			return;
+		}
+		var len, norm_rows, rowData, $rows, rowIndex, tbodyIndex, $tbody, columnIndex,
+			isChild, childRow, lastSearch, showRow, time, val, indx,
+			notFiltered, searchFiltered, query, injected, res, id, txt,
+			storedFilters = $.extend( [], filters ),
 			regex = ts.filter.regex,
 			c = table.config,
 			wo = c.widgetOptions,
 			// data object passed to filters; anyMatch is a flag for the filters
-			data = { anyMatch: false },
-			// anyMatch really screws up with these types of filters
-			noAnyMatch = [ 'range', 'notMatch',  'operators' ];
+			data = {
+				anyMatch: false,
+				filters: filters,
+				// regex filter type cache
+				filter_regexCache : [],
+			},
+			vars = {
+				// anyMatch really screws up with these types of filters
+				noAnyMatch: [ 'range', 'notMatch',  'operators' ],
+				// cache filter variables that use ts.getColumnData in the main loop
+				functions : [],
+				excludeFilter : [],
+				defaultColFilter : [],
+				defaultAnyFilter : ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) || ''
+			};
 
 		// parse columns after formatter, in case the class is added at that point
-		data.parsed = c.$headers.map(function(columnIndex) {
-			return c.parsers && c.parsers[columnIndex] && c.parsers[columnIndex].parsed ||
-				// getData won't return "parsed" if other "filter-" class names exist (e.g. <th class="filter-select filter-parsed">)
-				ts.getData && ts.getData(c.$headerIndexed[columnIndex], ts.getColumnData( table, c.headers, columnIndex ), 'filter') === 'parsed' ||
-				$(this).hasClass('filter-parsed');
+		data.parsed = c.$headers.map( function( columnIndex ) {
+			return c.parsers && c.parsers[ columnIndex ] &&
+				// force parsing if parser type is numeric
+				( c.parsers[ columnIndex ].parsed || c.parsers[ columnIndex ].type === 'numeric' ) ||
+				// getData won't return 'parsed' if other 'filter-' class names exist
+				// ( e.g. <th class="filter-select filter-parsed"> )
+				ts.getData && ts.getData( c.$headerIndexed[ columnIndex ],
+					ts.getColumnData( table, c.headers, columnIndex ), 'filter' ) === 'parsed' ||
+				$( this ).hasClass( 'filter-parsed' );
 		}).get();
 
-		// cache filter variables that use ts.getColumnData in the main loop
-		wo.filter_indexed = {
-			functions : [],
-			excludeFilter : [],
-			defaultColFilter : [],
-			defaultAnyFilter : ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) || ''
-		};
 		for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
-			wo.filter_indexed.functions[ columnIndex ] = ts.getColumnData( table, wo.filter_functions, columnIndex );
-			wo.filter_indexed.defaultColFilter[ columnIndex ] = ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) || '';
-			wo.filter_indexed.excludeFilter[ columnIndex ] = ( ts.getColumnData( table, wo.filter_excludeFilter, columnIndex, true ) || '' ).split(/\s+/);
+			vars.functions[ columnIndex ] =
+				ts.getColumnData( table, wo.filter_functions, columnIndex );
+			vars.defaultColFilter[ columnIndex ] =
+				ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) || '';
+			vars.excludeFilter[ columnIndex ] =
+				( ts.getColumnData( table, wo.filter_excludeFilter, columnIndex, true ) || '' ).split( /\s+/ );
 		}
 
-		if (c.debug) {
-			ts.log('Filter: Starting filter widget search', filters);
+		if ( c.debug ) {
+			ts.log( 'Filter: Starting filter widget search', filters );
 			time = new Date();
 		}
 		// filtered rows count
 		c.filteredRows = 0;
 		c.totalRows = 0;
 		// combindedFilters are undefined on init
-		combinedFilters = (filters || []).join('');
+		combinedFilters = ( storedFilters || [] ).join( '' );
 
-		for (tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
-			$tbody = ts.processTbody(table, c.$tbodies.eq(tbodyIndex), true);
-			// skip child rows & widget added (removable) rows - fixes #448 thanks to @hempel!
-			// $rows = $tbody.children('tr').not(c.selectorRemove);
+		for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
+			$tbody = ts.processTbody( table, c.$tbodies.eq( tbodyIndex ), true );
+			// skip child rows & widget added ( removable ) rows - fixes #448 thanks to @hempel!
+			// $rows = $tbody.children( 'tr' ).not( c.selectorRemove );
 			columnIndex = c.columns;
 			// convert stored rows into a jQuery object
-			norm_rows = c.cache[tbodyIndex].normalized;
-			$rows = $( $.map(norm_rows, function(el){ return el[columnIndex].$row.get(); }) );
+			norm_rows = c.cache[ tbodyIndex ].normalized;
+			$rows = $( $.map( norm_rows, function( el ) {
+				return el[ columnIndex ].$row.get();
+			}) );
 
-			if (combinedFilters === '' || wo.filter_serversideFiltering) {
-				$rows.removeClass(wo.filter_filteredRow).not('.' + c.cssChildRow).css('display', '');
+			if ( combinedFilters === '' || wo.filter_serversideFiltering ) {
+				$rows
+					.removeClass( wo.filter_filteredRow )
+					.not( '.' + c.cssChildRow )
+					.css( 'display', '' );
 			} else {
 				// filter out child rows
-				$rows = $rows.not('.' + c.cssChildRow);
+				$rows = $rows.not( '.' + c.cssChildRow );
 				len = $rows.length;
 
-				if ( (wo.filter_$anyMatch && wo.filter_$anyMatch.length) || typeof filters[c.columns] !== 'undefined' ) {
+				if ( ( wo.filter_$anyMatch && wo.filter_$anyMatch.length ) ||
+					typeof filters[c.columns] !== 'undefined' ) {
 					data.anyMatchFlag = true;
-					data.anyMatchFilter = wo.filter_$anyMatch && ts.filter.getLatestSearch( wo.filter_$anyMatch ).val() || ( '' + filters[c.columns] ) || '';
-					if (wo.filter_columnAnyMatch) {
+					data.anyMatchFilter = '' + (
+						filters[ c.columns ] ||
+						wo.filter_$anyMatch && ts.filter.getLatestSearch( wo.filter_$anyMatch ).val() ||
+						''
+					);
+					if ( wo.filter_columnAnyMatch ) {
 						// specific columns search
-						query = data.anyMatchFilter.split( ts.filter.regex.andSplit );
+						query = data.anyMatchFilter.split( regex.andSplit );
 						injected = false;
-						for (indx = 0; indx < query.length; indx++) {
-							res = query[indx].split(':');
+						for ( indx = 0; indx < query.length; indx++ ) {
+							res = query[ indx ].split( ':' );
 							if ( res.length > 1 ) {
 								// make the column a one-based index ( non-developers start counting from one :P )
 								id = parseInt( res[0], 10 ) - 1;
 								if ( id >= 0 && id < c.columns ) { // if id is an integer
-									filters[id] = res[1];
-									query.splice(indx, 1);
+									filters[ id ] = res[1];
+									query.splice( indx, 1 );
 									indx--;
 									injected = true;
 								}
 							}
 						}
-						if (injected) {
-							data.anyMatchFilter = query.join(' && ');
+						if ( injected ) {
+							data.anyMatchFilter = query.join( ' && ' );
 						}
 					}
 				}
 
 				// optimize searching only through already filtered rows - see #313
 				searchFiltered = wo.filter_searchFiltered;
-				lastSearch = c.lastSearch || c.$table.data('lastSearch') || [];
-				if (searchFiltered) {
-					// cycle through all filters; include last (columnIndex + 1 = match any column). Fixes #669
-					for (indx = 0; indx < columnIndex + 1; indx++) {
+				lastSearch = c.lastSearch || c.$table.data( 'lastSearch' ) || [];
+				if ( searchFiltered ) {
+					// cycle through all filters; include last ( columnIndex + 1 = match any column ). Fixes #669
+					for ( indx = 0; indx < columnIndex + 1; indx++ ) {
 						val = filters[indx] || '';
 						// break out of loop if we've already determined not to search filtered rows
-						if (!searchFiltered) { indx = columnIndex; }
+						if ( !searchFiltered ) { indx = columnIndex; }
 						// search already filtered rows if...
 						searchFiltered = searchFiltered && lastSearch.length &&
 							// there are no changes from beginning of filter
-							val.indexOf(lastSearch[indx] || '') === 0 &&
-							// 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) &&
-							// don't search only filtered if the value is negative ('> -10' => '> -100' will ignore hidden rows)
-							!(/(>=?\s*-\d)/.test(val) || /(<=?\s*\d)/.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') );
+							val.indexOf( lastSearch[indx] || '' ) === 0 &&
+							// 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 ) &&
+							// don't search only filtered if the value is negative
+							// ( '> -10' => '> -100' will ignore hidden rows )
+							!( /(>=?\s*-\d)/.test( val ) || /(<=?\s*\d)/.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' ) );
 					}
 				}
-				notFiltered = $rows.not('.' + wo.filter_filteredRow).length;
+				notFiltered = $rows.not( '.' + wo.filter_filteredRow ).length;
 				// can't search when all rows are hidden - this happens when looking for exact matches
-				if (searchFiltered && notFiltered === 0) { searchFiltered = false; }
-				if (c.debug) {
-					ts.log( 'Filter: Searching through ' + ( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' );
+				if ( searchFiltered && notFiltered === 0 ) { searchFiltered = false; }
+				if ( c.debug ) {
+					ts.log( 'Filter: Searching through ' +
+						( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' );
 				}
-				if (data.anyMatchFlag) {
-					if (c.sortLocaleCompare) {
+				if ( data.anyMatchFlag ) {
+					if ( c.sortLocaleCompare ) {
 						// replace accents
-						data.anyMatchFilter = ts.replaceAccents(data.anyMatchFilter);
+						data.anyMatchFilter = ts.replaceAccents( data.anyMatchFilter );
 					}
-					if ( wo.filter_defaultFilter && regex.iQuery.test( wo.filter_indexed.defaultAnyFilter ) ) {
-						data.anyMatchFilter = ts.filter.defaultFilter( data.anyMatchFilter, wo.filter_indexed.defaultAnyFilter );
+					if ( wo.filter_defaultFilter && regex.iQuery.test( vars.defaultAnyFilter ) ) {
+						data.anyMatchFilter = ts.filter.defaultFilter( data.anyMatchFilter, vars.defaultAnyFilter );
 						// clear search filtered flag because default filters are not saved to the last search
 						searchFiltered = false;
 					}
 					// make iAnyMatchFilter lowercase unless both filter widget & core ignoreCase options are true
 					// when c.ignoreCase is true, the cache contains all lower case data
-					data.iAnyMatchFilter = !(wo.filter_ignoreCase && c.ignoreCase) ? data.anyMatchFilter : data.anyMatchFilter.toLocaleLowerCase();
+					data.iAnyMatchFilter = !( wo.filter_ignoreCase && c.ignoreCase ) ?
+						data.anyMatchFilter :
+						data.anyMatchFilter.toLowerCase();
 				}
 
 				// loop through the rows
-				for (rowIndex = 0; rowIndex < len; rowIndex++) {
+				for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
 
-					data.cacheArray = norm_rows[rowIndex];
-
-					childRow = $rows[rowIndex].className;
+					txt = $rows[ rowIndex ].className;
+					// the first row can never be a child row
+					isChild = rowIndex && regex.child.test( txt );
 					// skip child rows & already filtered rows
-					if ( regex.child.test(childRow) || (searchFiltered && regex.filtered.test(childRow)) ) { continue; }
-					showRow = true;
-					// *** nextAll/nextUntil not supported by Zepto! ***
-					childRow = $rows.eq(rowIndex).nextUntil('tr:not(.' + c.cssChildRow + ')');
-					// so, if "table.config.widgetOptions.filter_childRows" is true and there is
-					// a match anywhere in the child row, then it will make the row visible
-					// checked here so the option can be changed dynamically
-					data.childRowText = (childRow.length && wo.filter_childRows) ? childRow.text() : '';
-					data.childRowText = wo.filter_ignoreCase ? data.childRowText.toLocaleLowerCase() : data.childRowText;
-					$cells = $rows.eq(rowIndex).children();
-					if (data.anyMatchFlag) {
-						// look for multiple columns "1-3,4-6,8"
-						columnIndex = ts.filter.multipleColumns( c, wo.filter_$anyMatch );
-						data.anyMatch = true;
-						data.rowArray = $cells.map(function(i){
-							if ( $.inArray(i, columnIndex) > -1 ) {
-								var txt;
-								if (data.parsed[i]) {
-									txt = data.cacheArray[i];
-								} else {
-									txt = this ? this.getAttribute( c.textAttribute ) || this.textContent || $(this).text() : '';
-									txt = $.trim( wo.filter_ignoreCase ? txt.toLowerCase() : txt );
-									if (c.sortLocaleCompare) {
-										txt = ts.replaceAccents(txt);
-									}
-								}
-								return txt;
-							}
-						}).get();
-						data.filter = data.anyMatchFilter;
-						data.iFilter = data.iAnyMatchFilter;
-						data.exact = data.rowArray.join(' ');
-						data.iExact = wo.filter_ignoreCase ? data.exact.toLowerCase() : data.exact;
-						data.cache = data.cacheArray.slice(0,-1).join(' ');
-						filterMatched = null;
-						$.each(ts.filter.types, function(type, typeFunction) {
-							if ($.inArray(type, noAnyMatch) < 0) {
-								matches = typeFunction( c, data );
-								if (matches !== null) {
-									filterMatched = matches;
-									return false;
-								}
-							}
-						});
-						if (filterMatched !== null) {
-							showRow = filterMatched;
-						} else {
-							if (wo.filter_startsWith) {
-								showRow = false;
-								columnIndex = c.columns;
-								while (!showRow && columnIndex > 0) {
-									columnIndex--;
-									showRow = showRow || data.rowArray[columnIndex].indexOf(data.iFilter) === 0;
-								}
-							} else {
-								showRow = (data.iExact + data.childRowText).indexOf(data.iFilter) >= 0;
-							}
-						}
-						data.anyMatch = false;
+					if ( isChild || ( searchFiltered && regex.filtered.test( txt ) ) ) {
+						continue;
 					}
 
-					for (columnIndex = 0; columnIndex < c.columns; columnIndex++) {
-						data.filter = filters[columnIndex];
-						data.index = columnIndex;
-
-						// filter types to exclude, per column
-						excludeMatch = wo.filter_indexed.excludeFilter[ columnIndex ];
+					data.$row = $rows.eq( rowIndex );
+					data.cacheArray = norm_rows[ rowIndex ];
+					rowData = data.cacheArray[ c.columns ];
+					data.rawArray = rowData.raw;
+					data.childRowText = '';
 
-						// ignore if filter is empty or disabled
-						if (data.filter) {
-							data.cache = data.cacheArray[columnIndex];
-							// check if column data should be from the cell or from parsed data
-							if (wo.filter_useParsedData || data.parsed[columnIndex]) {
-								data.exact = data.cache;
-							} else {
-								val = $cells[columnIndex];
-								result = val ? $.trim( val.getAttribute( c.textAttribute ) || val.textContent || $cells.eq(columnIndex).text() ) : '';
-								data.exact = c.sortLocaleCompare ? ts.replaceAccents(result) : result; // issue #405
-							}
-							data.iExact = !regex.type.test(typeof data.exact) && wo.filter_ignoreCase ? data.exact.toLocaleLowerCase() : data.exact;
-							result = showRow; // if showRow is true, show that row
+					if ( !wo.filter_childByColumn ) {
+						txt = '';
+						// child row cached text
+						childRow = rowData.child;
+						// so, if 'table.config.widgetOptions.filter_childRows' is true and there is
+						// a match anywhere in the child row, then it will make the row visible
+						// checked here so the option can be changed dynamically
+						for ( indx = 0; indx < childRow.length; indx++ ) {
+							txt += ' ' + childRow[indx].join( '' ) || '';
+						}
+						data.childRowText = wo.filter_childRows ?
+							( wo.filter_ignoreCase ? txt.toLowerCase() : txt ) :
+							'';
+					}
 
-							// in case select filter option has a different value vs text "a - z|A through Z"
-							ffxn = wo.filter_columnFilters ?
-								c.$filters.add(c.$externalFilters).filter('[data-column="'+ columnIndex + '"]').find('select option:selected').attr('data-function-name') || '' : '';
-							// replace accents - see #357
-							if (c.sortLocaleCompare) {
-								data.filter = ts.replaceAccents(data.filter);
-							}
+					showRow = ts.filter.processRow( c, data, vars );
+					childRow = rowData.$row.filter( ':gt( 0 )' );
 
-							val = true;
-							if (wo.filter_defaultFilter && regex.iQuery.test( wo.filter_indexed.defaultColFilter[ columnIndex ] )) {
-								data.filter = ts.filter.defaultFilter( data.filter, wo.filter_indexed.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;
-							}
-							// data.iFilter = case insensitive (if wo.filter_ignoreCase is true), data.filter = case sensitive
-							data.iFilter = wo.filter_ignoreCase ? (data.filter || '').toLocaleLowerCase() : data.filter;
-							fxn = wo.filter_indexed.functions[ columnIndex ];
-							$cell = c.$headerIndexed[columnIndex];
-							hasSelect = $cell.hasClass('filter-select');
-							filterMatched = null;
-							if ( fxn || ( hasSelect && val ) ) {
-								if (fxn === true || hasSelect) {
-									// default selector uses exact match unless "filter-match" class is found
-									filterMatched = ($cell.hasClass('filter-match')) ? data.iExact.search(data.iFilter) >= 0 : data.filter === data.exact;
-								} else if (typeof fxn === 'function') {
-									// filter callback( exact cell content, parser normalized content, filter input value, column index, jQuery row object )
-									filterMatched = fxn(data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex), c);
-								} else if (typeof fxn[ffxn || data.filter] === 'function') {
-									// selector option function
-									filterMatched = fxn[ffxn || data.filter](data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex), c);
-								}
+					if ( wo.filter_childRows && childRow.length ) {
+						if ( wo.filter_childByColumn ) {
+							// cycle through each child row
+							for ( indx = 0; indx < childRow.length; indx++ ) {
+								data.$row = childRow.eq( indx );
+								data.cacheArray = rowData.child[ indx ];
+								data.rawArray = data.cacheArray;
+								// use OR comparison on child rows
+								showRow = showRow || ts.filter.processRow( c, data, vars );
 							}
-							if (filterMatched === null) {
-								// cycle through the different filters
-								// filters return a boolean or null if nothing matches
-								$.each(ts.filter.types, function(type, typeFunction) {
-									if ($.inArray(type, excludeMatch) < 0) {
-										matches = typeFunction( c, data );
-										if (matches !== null) {
-											filterMatched = matches;
-											return false;
-										}
-									}
-								});
-								if (filterMatched !== null) {
-									result = filterMatched;
-								// Look for match, and add child row data for matching
-								} else {
-									data.exact = (data.iExact + data.childRowText).indexOf( ts.filter.parseFilter(c, data.iFilter, columnIndex, data.parsed[columnIndex]) );
-									result = ( (!wo.filter_startsWith && data.exact >= 0) || (wo.filter_startsWith && data.exact === 0) );
-								}
-							} else {
-								result = filterMatched;
-							}
-							showRow = (result) ? showRow : false;
 						}
+						childRow.toggleClass( wo.filter_filteredRow, !showRow );
 					}
-					$rows.eq(rowIndex)
-						.toggleClass(wo.filter_filteredRow, !showRow)[0]
+
+					rowData.$row
+						.toggleClass( wo.filter_filteredRow, !showRow )[0]
 						.display = showRow ? '' : 'none';
-					if (childRow.length) {
-						childRow.toggleClass(wo.filter_filteredRow, !showRow);
-					}
 				}
 			}
-			c.filteredRows += $rows.not('.' + wo.filter_filteredRow).length;
+			c.filteredRows += $rows.not( '.' + wo.filter_filteredRow ).length;
 			c.totalRows += $rows.length;
-			ts.processTbody(table, $tbody, false);
+			ts.processTbody( table, $tbody, false );
 		}
 		c.lastCombinedFilter = combinedFilters; // save last search
-		c.lastSearch = filters;
-		c.$table.data('lastSearch', filters);
-		if (wo.filter_saveFilters && ts.storage) {
-			ts.storage( table, 'tablesorter-filters', filters );
+		// don't save 'filters' directly since it may have altered ( AnyMatch column searches )
+		c.lastSearch = storedFilters;
+		c.$table.data( 'lastSearch', storedFilters );
+		if ( wo.filter_saveFilters && ts.storage ) {
+			ts.storage( table, 'tablesorter-filters', storedFilters );
+		}
+		if ( c.debug ) {
+			ts.benchmark( 'Completed filter widget search', time );
 		}
-		if (c.debug) {
-			ts.benchmark("Completed filter widget search", time);
+		if ( wo.filter_initialized ) {
+			c.$table.trigger( 'filterEnd', c );
 		}
-		if (wo.filter_initialized) { c.$table.trigger('filterEnd', c ); }
-		setTimeout(function(){
-			c.$table.trigger('applyWidgets'); // make sure zebra widget is applied
-		}, 0);
+		setTimeout( function() {
+			c.$table.trigger( 'applyWidgets' ); // make sure zebra widget is applied
+		}, 0 );
 	},
-	getOptionSource: function(table, column, onlyAvail) {
-		table = $(table)[0];
+	getOptionSource: function( table, column, onlyAvail ) {
+		table = $( table )[0];
 		var cts, indx, len,
 			c = table.config,
 			wo = c.widgetOptions,
 			parsed = [],
 			arry = false,
 			source = wo.filter_selectSource,
-			last = c.$table.data('lastSearch') || [],
-			fxn = $.isFunction(source) ? true : ts.getColumnData( table, source, column );
+			last = c.$table.data( 'lastSearch' ) || [],
+			fxn = $.isFunction( source ) ? true : ts.getColumnData( table, source, column );
 
-		if (onlyAvail && last[column] !== '') {
+		if ( onlyAvail && last[column] !== '' ) {
 			onlyAvail = false;
 		}
 
 		// filter select source option
-		if (fxn === true) {
+		if ( fxn === true ) {
 			// OVERALL source
-			arry = source(table, column, onlyAvail);
-		} else if ( fxn instanceof $ || ($.type(fxn) === 'string' && fxn.indexOf('</option>') >= 0) ) {
+			arry = source( table, column, onlyAvail );
+		} else if ( fxn instanceof $ || ( $.type( fxn ) === 'string' && fxn.indexOf( '</option>' ) >= 0 ) ) {
 			// selectSource is a jQuery object or string of options
 			return fxn;
-		} else if ($.isArray(fxn)) {
+		} else if ( $.isArray( fxn ) ) {
 			arry = fxn;
-		} else if ($.type(source) === 'object' && fxn) {
+		} else if ( $.type( source ) === 'object' && fxn ) {
 			// custom select source function for a SPECIFIC COLUMN
-			arry = fxn(table, column, onlyAvail);
+			arry = fxn( table, column, onlyAvail );
 		}
-		if (arry === false) {
+		if ( arry === false ) {
 			// fall back to original method
-			arry = ts.filter.getOptions(table, column, onlyAvail);
+			arry = ts.filter.getOptions( table, column, onlyAvail );
 		}
 
 		// get unique elements and sort the list
-		// if $.tablesorter.sortText exists (not in the original tablesorter),
+		// if $.tablesorter.sortText exists ( not in the original tablesorter ),
 		// then natural sort the list otherwise use a basic sort
-		arry = $.grep(arry, function(value, indx) {
-			return $.inArray(value, arry) === indx;
+		arry = $.grep( arry, function( value, indx ) {
+			return $.inArray( value, arry ) === indx;
 		});
 
-		if (c.$headerIndexed[column].hasClass('filter-select-nosort')) {
+		if ( c.$headerIndexed[ column ].hasClass( 'filter-select-nosort' ) ) {
 			// unsorted select options
 			return arry;
 		} else {
 			len = arry.length;
 			// parse select option values
-			for (indx = 0; indx < len; indx++) {
+			for ( indx = 0; indx < len; indx++ ) {
 				// parse array data using set column parser; this DOES NOT pass the original
 				// table cell to the parser format function
-				parsed.push({ t : arry[indx], p : c.parsers && c.parsers[column].format( arry[indx], table, [], column ) });
+				parsed.push({
+					t : arry[ indx ],
+					p : c.parsers && c.parsers[ column ].format( arry[ indx ], table, [], column )
+				});
 			}
 
 			// sort parsed select options
 			cts = c.textSorter || '';
-			parsed.sort(function(a, b){
+			parsed.sort( function( a, b ) {
 				// sortNatural breaks if you don't pass it strings
-				var x = a.p.toString(), y = b.p.toString();
-				if ($.isFunction(cts)) {
+				var x = a.p.toString(),
+					y = b.p.toString();
+				if ( $.isFunction( cts ) ) {
 					// custom OVERALL text sorter
-					return cts(x, y, true, column, table);
-				} else if (typeof(cts) === 'object' && cts.hasOwnProperty(column)) {
+					return cts( x, y, true, column, table );
+				} else if ( typeof( cts ) === 'object' && cts.hasOwnProperty( column ) ) {
 					// custom text sorter for a SPECIFIC COLUMN
-					return cts[column](x, y, true, column, table);
-				} else if (ts.sortNatural) {
+					return cts[column]( x, y, true, column, table );
+				} else if ( ts.sortNatural ) {
 					// fall back to natural sort
-					return ts.sortNatural(x, y);
+					return ts.sortNatural( x, y );
 				}
 				// using an older version! do a basic sort
 				return true;
@@ -1161,184 +1345,221 @@ ts.filter = {
 			// rebuild arry from sorted parsed data
 			arry = [];
 			len = parsed.length;
-			for (indx = 0; indx < len; indx++) {
+			for ( indx = 0; indx < len; indx++ ) {
 				arry.push( parsed[indx].t );
 			}
 			return arry;
 		}
 	},
-	getOptions: function(table, column, onlyAvail) {
-		table = $(table)[0];
-		var rowIndex, tbodyIndex, len, row, cache, cell,
+	getOptions: function( table, column, onlyAvail ) {
+		table = $( table )[0];
+		var rowIndex, tbodyIndex, len, row, cache,
 			c = table.config,
 			wo = c.widgetOptions,
 			arry = [];
-		for (tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
+		for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
 			cache = c.cache[tbodyIndex];
 			len = c.cache[tbodyIndex].normalized.length;
 			// loop through the rows
-			for (rowIndex = 0; rowIndex < len; rowIndex++) {
-				// get cached row from cache.row (old) or row data object (new; last item in normalized array)
-				row = cache.row ? cache.row[rowIndex] : cache.normalized[rowIndex][c.columns].$row[0];
+			for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
+				// get cached row from cache.row ( old ) or row data object
+				// ( new; last item in normalized array )
+				row = cache.row ?
+					cache.row[ rowIndex ] :
+					cache.normalized[ rowIndex ][ c.columns ].$row[0];
 				// check if has class filtered
-				if (onlyAvail && row.className.match(wo.filter_filteredRow)) { continue; }
+				if ( onlyAvail && row.className.match( wo.filter_filteredRow ) ) {
+					continue;
+				}
 				// get non-normalized cell content
-				if (wo.filter_useParsedData || c.parsers[column].parsed || c.$headerIndexed[column].hasClass('filter-parsed')) {
-					arry.push( '' + cache.normalized[rowIndex][column] );
+				if ( wo.filter_useParsedData ||
+					c.parsers[column].parsed ||
+					c.$headerIndexed[column].hasClass( 'filter-parsed' ) ) {
+					arry.push( '' + cache.normalized[ rowIndex ][ column ] );
 				} else {
-					cell = row.cells[column];
-					if (cell) {
-						arry.push( $.trim( cell.getAttribute( c.textAttribute ) || cell.textContent || $(cell).text() ) );
-					}
+					// get raw cached data instead of content directly from the cells
+					arry.push( cache.normalized[ rowIndex ][ c.columns ].raw[ column ] );
 				}
 			}
 		}
 		return arry;
 	},
-	buildSelect: function(table, column, arry, updating, onlyAvail) {
-		table = $(table)[0];
-		column = parseInt(column, 10);
-		if (!table.config.cache || $.isEmptyObject(table.config.cache)) { return; }
+	buildSelect: function( table, column, arry, updating, onlyAvail ) {
+		table = $( table )[0];
+		column = parseInt( column, 10 );
+		if ( !table.config.cache || $.isEmptyObject( table.config.cache ) ) {
+			return;
+		}
 		var indx, val, txt, t, $filters, $filter,
 			c = table.config,
 			wo = c.widgetOptions,
-			node = c.$headerIndexed[column],
-			// t.data('placeholder') won't work in jQuery older than 1.4.3
-			options = '<option value="">' + ( node.data('placeholder') || node.attr('data-placeholder') || wo.filter_placeholder.select || '' ) + '</option>',
+			node = c.$headerIndexed[ column ],
+			// t.data( 'placeholder' ) won't work in jQuery older than 1.4.3
+			options = '<option value="">' +
+				( node.data( 'placeholder' ) ||
+					node.attr( 'data-placeholder' ) ||
+					wo.filter_placeholder.select || ''
+				) + '</option>',
 			// Get curent filter value
-			currentValue = c.$table.find('thead').find('select.' + tscss.filter + '[data-column="' + column + '"]').val();
-		// 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);
+			currentValue = c.$table
+				.find( 'thead' )
+				.find( 'select.' + tscss.filter + '[data-column="' + column + '"]' )
+				.val();
+		// 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 );
 		}
 
-		if ($.isArray(arry)) {
+		if ( $.isArray( arry ) ) {
 			// build option list
-			for (indx = 0; indx < arry.length; indx++) {
-				txt = arry[indx] = ('' + arry[indx]).replace(/\"/g, "&quot;");
+			for ( indx = 0; indx < arry.length; indx++ ) {
+				txt = arry[indx] = ( '' + arry[indx] ).replace( /\"/g, '&quot;' );
 				val = txt;
 				// allow including a symbol in the selectSource array
-				// "a-z|A through Z" so that "a-z" becomes the option value
-				// and "A through Z" becomes the option text
-				if (txt.indexOf(wo.filter_selectSourceSeparator) >= 0) {
-					t = txt.split(wo.filter_selectSourceSeparator);
+				// 'a-z|A through Z' so that 'a-z' becomes the option value
+				// and 'A through Z' becomes the option text
+				if ( txt.indexOf( wo.filter_selectSourceSeparator ) >= 0 ) {
+					t = txt.split( wo.filter_selectSourceSeparator );
 					val = t[0];
 					txt = t[1];
 				}
-				// replace quotes - fixes #242 & ignore empty strings - see http://stackoverflow.com/q/14990971/145346
-				options += arry[indx] !== '' ? '<option ' + (val === txt ? '' : 'data-function-name="' + arry[indx] + '" ') + 'value="' + val + '">' + txt + '</option>' : '';
+				// replace quotes - fixes #242 & ignore empty strings
+				// see http://stackoverflow.com/q/14990971/145346
+				options += arry[indx] !== '' ?
+					'<option ' +
+						( val === txt ? '' : 'data-function-name="' + arry[indx] + '" ' ) +
+						'value="' + val + '">' + txt +
+					'</option>' : '';
 			}
 			// clear arry so it doesn't get appended twice
 			arry = [];
 		}
 
-		// update all selects in the same column (clone thead in sticky headers & any external selects) - fixes 473
-		$filters = ( c.$filters ? c.$filters : c.$table.children('thead') ).find('.' + tscss.filter);
-		if (wo.filter_$externalFilters) {
-			$filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
+		// update all selects in the same column ( clone thead in sticky headers &
+		// any external selects ) - fixes 473
+		$filters = ( c.$filters ? c.$filters : c.$table.children( 'thead' ) )
+			.find( '.' + tscss.filter );
+		if ( wo.filter_$externalFilters ) {
+			$filters = $filters && $filters.length ?
+				$filters.add( wo.filter_$externalFilters ) :
+				wo.filter_$externalFilters;
 		}
-		$filter = $filters.filter('select[data-column="' + column + '"]');
+		$filter = $filters.filter( 'select[data-column="' + column + '"]' );
 
 		// make sure there is a select there!
-		if ($filter.length) {
-			$filter[ updating ? 'html' : 'append' ](options);
-			if (!$.isArray(arry)) {
+		if ( $filter.length ) {
+			$filter[ updating ? 'html' : 'append' ]( options );
+			if ( !$.isArray( arry ) ) {
 				// append options if arry is provided externally as a string or jQuery object
-				// options (default value) was already added
-				$filter.append(arry).val(currentValue);
+				// options ( default value ) was already added
+				$filter.append( arry ).val( currentValue );
 			}
-			$filter.val(currentValue);
+			$filter.val( currentValue );
 		}
 	},
-	buildDefault: function(table, updating) {
+	buildDefault: function( table, updating ) {
 		var columnIndex, $header, noSelect,
 			c = table.config,
 			wo = c.widgetOptions,
 			columns = c.columns;
 		// build default select dropdown
-		for (columnIndex = 0; columnIndex < columns; columnIndex++) {
+		for ( columnIndex = 0; columnIndex < columns; columnIndex++ ) {
 			$header = c.$headerIndexed[columnIndex];
-			noSelect = !($header.hasClass('filter-false') || $header.hasClass('parser-false'));
+			noSelect = !( $header.hasClass( 'filter-false' ) || $header.hasClass( 'parser-false' ) );
 			// 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));
+			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 ) );
 			}
 		}
 	}
 };
 
-ts.getFilters = function(table, getRaw, setFilters, skipFirst) {
+ts.getFilters = function( table, getRaw, setFilters, skipFirst ) {
 	var i, $filters, $column, cols,
 		filters = false,
-		c = table ? $(table)[0].config : '',
+		c = table ? $( table )[0].config : '',
 		wo = c ? c.widgetOptions : '';
-	if (getRaw !== true && wo && !wo.filter_columnFilters) {
-		return $(table).data('lastSearch');
+	if ( ( getRaw !== true && wo && !wo.filter_columnFilters ) ||
+		// setFilters called, but last search is exactly the same as the current
+		// fixes issue #733 & #903 where calling update causes the input values to reset
+		( $.isArray(setFilters) && setFilters.join('') === c.lastCombinedFilter ) ) {
+		return $( table ).data( 'lastSearch' );
 	}
-	if (c) {
-		if (c.$filters) {
-			$filters = c.$filters.find('.' + tscss.filter);
+	if ( c ) {
+		if ( c.$filters ) {
+			$filters = c.$filters.find( '.' + tscss.filter );
 		}
-		if (wo.filter_$externalFilters) {
-			$filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
+		if ( wo.filter_$externalFilters ) {
+			$filters = $filters && $filters.length ?
+				$filters.add( wo.filter_$externalFilters ) :
+				wo.filter_$externalFilters;
 		}
-		if ($filters && $filters.length) {
+		if ( $filters && $filters.length ) {
 			filters = setFilters || [];
-			for (i = 0; i < c.columns + 1; i++) {
+			for ( i = 0; i < c.columns + 1; i++ ) {
 				cols = ( i === c.columns ?
-					// "all" columns can now include a range or set of columms (data-column="0-2,4,6-7")
+					// 'all' columns can now include a range or set of columms ( data-column='0-2,4,6-7' )
 					wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector :
 					'[data-column="' + i + '"]' );
-				$column = $filters.filter(cols);
-				if ($column.length) {
+				$column = $filters.filter( cols );
+				if ( $column.length ) {
 					// move the latest search to the first slot in the array
 					$column = ts.filter.getLatestSearch( $column );
-					if ($.isArray(setFilters)) {
-						// skip first (latest input) to maintain cursor position while typing
-						if (skipFirst) { $column.slice(1); }
-						if (i === c.columns) {
-							// prevent data-column="all" from filling data-column="0,1" (etc)
-							cols = $column.filter(wo.filter_anyColumnSelector);
+					if ( $.isArray( setFilters ) ) {
+						// skip first ( latest input ) to maintain cursor position while typing
+						if ( skipFirst ) {
+							$column.slice( 1 );
+						}
+						if ( i === c.columns ) {
+							// prevent data-column='all' from filling data-column='0,1' ( etc )
+							cols = $column.filter( wo.filter_anyColumnSelector );
 							$column = cols.length ? cols : $column;
 						}
 						$column
-							.val( setFilters[i] )
-							.trigger('change.tsfilter');
+							.val( setFilters[ i ] )
+							.trigger( 'change.tsfilter' );
 					} else {
 						filters[i] = $column.val() || '';
 						// don't change the first... it will move the cursor
-						if (i === c.columns) {
-							// don't update range columns from "all" setting
-							$column.slice(1).filter('[data-column*="' + $column.attr('data-column') + '"]').val( filters[i] );
+						if ( i === c.columns ) {
+							// don't update range columns from 'all' setting
+							$column
+								.slice( 1 )
+								.filter( '[data-column*="' + $column.attr( 'data-column' ) + '"]' )
+								.val( filters[ i ] );
 						} else {
-							$column.slice(1).val( filters[i] );
+							$column
+								.slice( 1 )
+								.val( filters[ i ] );
 						}
 					}
 					// save any match input dynamically
-					if (i === c.columns && $column.length) {
+					if ( i === c.columns && $column.length ) {
 						wo.filter_$anyMatch = $column;
 					}
 				}
 			}
 		}
 	}
-	if (filters.length === 0) {
+	if ( filters.length === 0 ) {
 		filters = false;
 	}
 	return filters;
 };
 
-ts.setFilters = function(table, filter, apply, skipFirst) {
-	var c = table ? $(table)[0].config : '',
-		valid = ts.getFilters(table, true, filter, skipFirst);
-	if (c && apply) {
+ts.setFilters = function( table, filter, apply, skipFirst ) {
+	var c = table ? $( table )[0].config : '',
+		valid = ts.getFilters( table, true, filter, skipFirst );
+	if ( c && apply ) {
 		// 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);
-		c.$table.trigger('filterFomatterUpdate');
+		ts.filter.searching( c.table, filter, skipFirst );
+		c.$table.trigger( 'filterFomatterUpdate' );
 	}
 	return !!valid;
 };
 
-})(jQuery);
+})( jQuery );