jquery-tablesorter 1.17.2 → 1.17.3

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

@@ -4,146 +4,146 @@
 /*jshint browser:true, jquery:true, unused:false */
 /*global jQuery: false */
 ;(function($){
-"use strict";
+	'use strict';
 
-var ts = $.tablesorter || {};
-ts.filterFormatter = ts.filterFormatter || {};
+	var ts = $.tablesorter || {};
+	ts.filterFormatter = ts.filterFormatter || {};
 
-/************************\
- Select2 Filter Formatter
-\************************/
-ts.filterFormatter.select2 = function($cell, indx, select2Def) {
-	var o = $.extend({
-		// select2 filter formatter options
-		cellText : '', // Text (wrapped in a label element)
-		match : true, // adds "filter-match" to header
-		value : '',
-		// include ANY select2 options below
-		multiple : true,
-		width : '100%'
+	/************************\
+	 Select2 Filter Formatter
+	\************************/
+	ts.filterFormatter.select2 = function($cell, indx, select2Def) {
+		var o = $.extend({
+			// select2 filter formatter options
+			cellText : '', // Text (wrapped in a label element)
+			match : true, // adds 'filter-match' to header
+			value : '',
+			// include ANY select2 options below
+			multiple : true,
+			width : '100%'
 
-	}, select2Def ),
-	arry, data,
-	c = $cell.closest('table')[0].config,
-	wo = c.widgetOptions,
-	// Add a hidden input to hold the range values
-	$input = $('<input class="filter" type="hidden">')
-		.appendTo($cell)
-		// hidden filter update namespace trigger by filter widget
-		.bind('change' + c.namespace + 'filter', function(){
-			var val = this.value;
-			val = val.replace(/[/()$^]/g, '').split('|');
-			$cell.find('.select2').select2('val', val);
-			updateSelect2();
-		}),
-	$header = c.$headerIndexed[indx],
-	onlyAvail = $header.hasClass(wo.filter_onlyAvail),
-	$shcell = [],
-	matchPrefix = o.match ? '' : '^',
-	matchSuffix = o.match ? '' : '$',
-
-	// this function updates the hidden input and adds the current values to the header cell text
-	updateSelect2 = function() {
-		var arry = false,
-			v = $cell.find('.select2').select2('val') || o.value || '';
-		// convert array to string
-		if ($.isArray(v)) {
-			arry = true;
-			v = v.join('\u0000');
-		}
-		// escape special regex characters (http://stackoverflow.com/a/9310752/145346)
-		v = v.replace(/[-[\]{}()*+?.,/\\^$|#\s]/g, '\\$&');
-		// convert string back into an array
-		if (arry) {
-			v = v.split('\u0000');
-		}
-		$input
-			// add regex, so we filter exact numbers
-			.val( $.isArray(v) && v.length && v.join('') !== '' ? '/(' + matchPrefix + (v || []).join(matchSuffix + '|' + matchPrefix) + matchSuffix + ')/' : '' )
-			.trigger('search').end()
-			.find('.select2').select2('val', v);
-		// update sticky header cell
-		if ($shcell.length) {
-			$shcell.find('.select2').select2('val', v);
-		}
-	},
-
-	// get options from table cell content or filter_selectSource (v2.16)
-	updateOptions = function(){
-		data = [];
-		arry = ts.filter.getOptionSource(c.$table[0], indx, onlyAvail) || [];
-		// build select2 data option
-		$.each(arry, function(i,v){
-			data.push({id: v, text: v});
-		});
-		o.data = data;
-	};
+		}, select2Def ),
+		arry, data,
+		c = $cell.closest('table')[0].config,
+		wo = c.widgetOptions,
+		// Add a hidden input to hold the range values
+		$input = $('<input class="filter" type="hidden">')
+			.appendTo($cell)
+			// hidden filter update namespace trigger by filter widget
+			.bind('change' + c.namespace + 'filter', function(){
+				var val = this.value;
+				val = val.replace(/[/()$^]/g, '').split('|');
+				$cell.find('.select2').select2('val', val);
+				updateSelect2();
+			}),
+		$header = c.$headerIndexed[indx],
+		onlyAvail = $header.hasClass(wo.filter_onlyAvail),
+		$shcell = [],
+		matchPrefix = o.match ? '' : '^',
+		matchSuffix = o.match ? '' : '$',
 
-	// get filter-match class from option
-	$header.toggleClass('filter-match', o.match);
-	if (o.cellText) {
-		$cell.prepend('<label>' + o.cellText + '</label>');
-	}
+		// this function updates the hidden input and adds the current values to the header cell text
+		updateSelect2 = function() {
+			var arry = false,
+				v = $cell.find('.select2').select2('val') || o.value || '';
+			// convert array to string
+			if ($.isArray(v)) {
+				arry = true;
+				v = v.join('\u0000');
+			}
+			// escape special regex characters (http://stackoverflow.com/a/9310752/145346)
+			v = v.replace(/[-[\]{}()*+?.,/\\^$|#\s]/g, '\\$&');
+			// convert string back into an array
+			if (arry) {
+				v = v.split('\u0000');
+			}
+			$input
+				// add regex, so we filter exact numbers
+				.val( $.isArray(v) && v.length && v.join('') !== '' ? '/(' + matchPrefix + (v || []).join(matchSuffix + '|' + matchPrefix) + matchSuffix + ')/' : '' )
+				.trigger('search').end()
+				.find('.select2').select2('val', v);
+			// update sticky header cell
+			if ($shcell.length) {
+				$shcell.find('.select2').select2('val', v);
+			}
+		},
 
-	// don't add default in table options if either ajax or
-	// data options are already defined
-	if (!(o.ajax && !$.isEmptyObject(o.ajax)) && !o.data) {
-		updateOptions();
-		if (onlyAvail) {
-			c.$table.bind('filterEnd', function(){
-				updateOptions();
-				$cell.add($shcell).find('.select2').select2(o);
+		// get options from table cell content or filter_selectSource (v2.16)
+		updateOptions = function(){
+			data = [];
+			arry = ts.filter.getOptionSource(c.$table[0], indx, onlyAvail) || [];
+			// build select2 data option
+			$.each(arry, function(i, v){
+				data.push({id: v, text: v});
 			});
-		}
-	}
+			o.data = data;
+		};
 
-	// add a select2 hidden input!
-	$('<input class="select2 select2-' + indx + '" type="hidden" />')
-		.val(o.value)
-		.appendTo($cell)
-		.select2(o)
-		.bind('change', function(){
-			updateSelect2();
-		});
+		// get filter-match class from option
+		$header.toggleClass('filter-match', o.match);
+		if (o.cellText) {
+			$cell.prepend('<label>' + o.cellText + '</label>');
+		}
 
-	// update select2 from filter hidden input, in case of saved filters
-	c.$table.bind('filterFomatterUpdate', function(){
-		// value = '/(^x$|^y$)/' => 'x,y'
-		var val = c.$table.data('lastSearch')[indx] || '';
-		val = val.replace(/^\/\(\^?/,'').replace(/\$\|\^/g, '|').replace(/\$?\)\/$/g,'').split('|');
-		$cell.find('.select2').select2('val', val);
-		updateSelect2();
-		ts.filter.formatterUpdated($cell, indx);
-	});
+		// don't add default in table options if either ajax or
+		// data options are already defined
+		if (!(o.ajax && !$.isEmptyObject(o.ajax)) && !o.data) {
+			updateOptions();
+			if (onlyAvail) {
+				c.$table.bind('filterEnd', function(){
+					updateOptions();
+					$cell.add($shcell).find('.select2').select2(o);
+				});
+			}
+		}
 
-	// has sticky headers?
-	c.$table.bind('stickyHeadersInit', function(){
-		$shcell = c.widgetOptions.$sticky.find('.tablesorter-filter-row').children().eq(indx).empty();
-		// add a select2!
-		$('<input class="select2 select2-' + indx + '" type="hidden">')
+		// add a select2 hidden input!
+		$('<input class="select2 select2-' + indx + '" type="hidden" />')
 			.val(o.value)
-			.appendTo($shcell)
+			.appendTo($cell)
 			.select2(o)
 			.bind('change', function(){
-				$cell.find('.select2').select2('val', $shcell.find('.select2').select2('val') );
 				updateSelect2();
 			});
-		if (o.cellText) {
-			$shcell.prepend('<label>' + o.cellText + '</label>');
-		}
 
-	});
-
-	// on reset
-	c.$table.bind('filterReset', function(){
-		$cell.find('.select2').select2('val', o.value || '');
-		setTimeout(function(){
+		// update select2 from filter hidden input, in case of saved filters
+		c.$table.bind('filterFomatterUpdate', function(){
+			// value = '/(^x$|^y$)/' => 'x,y'
+			var val = c.$table.data('lastSearch')[indx] || '';
+			val = val.replace(/^\/\(\^?/, '').replace(/\$\|\^/g, '|').replace(/\$?\)\/$/g, '').split('|');
+			$cell.find('.select2').select2('val', val);
 			updateSelect2();
-		}, 0);
-	});
+			ts.filter.formatterUpdated($cell, indx);
+		});
+
+		// has sticky headers?
+		c.$table.bind('stickyHeadersInit', function(){
+			$shcell = c.widgetOptions.$sticky.find('.tablesorter-filter-row').children().eq(indx).empty();
+			// add a select2!
+			$('<input class="select2 select2-' + indx + '" type="hidden">')
+				.val(o.value)
+				.appendTo($shcell)
+				.select2(o)
+				.bind('change', function(){
+					$cell.find('.select2').select2('val', $shcell.find('.select2').select2('val') );
+					updateSelect2();
+				});
+			if (o.cellText) {
+				$shcell.prepend('<label>' + o.cellText + '</label>');
+			}
 
-	updateSelect2();
-	return $input;
-};
+		});
+
+		// on reset
+		c.$table.bind('filterReset', function(){
+			$cell.find('.select2').select2('val', o.value || '');
+			setTimeout(function(){
+				updateSelect2();
+			}, 0);
+		});
+
+		updateSelect2();
+		return $input;
+	};
 
 })(jQuery);

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

@@ -1,6 +1,6 @@
 /*! Widget: filter, insideRange filter type - updated 2/23/2015 (v2.21.0) */
 ;(function($){
-'use strict';
+	'use strict';
 
 	// Add insideRange filter type
 	// ============================

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

@@ -1,94 +1,94 @@
-/*! Widget: filter - updated 5/17/2015 (v2.22.1) *//*
+/*! Widget: filter - updated 7/28/2015 (v2.22.4) *//*
  * Requires tablesorter v2.8+ and jQuery 1.7+
  * by Rob Garrison
  */
 ;( function ( $ ) {
-'use strict';
-var ts = $.tablesorter || {},
+	'use strict';
+	var ts = $.tablesorter || {},
 	tscss = ts.css;
 
-$.extend( tscss, {
-	filterRow      : 'tablesorter-filter-row',
-	filter         : 'tablesorter-filter',
-	filterDisabled : 'disabled',
-	filterRowHide  : 'hideme'
-});
+	$.extend( tscss, {
+		filterRow      : 'tablesorter-filter-row',
+		filter         : 'tablesorter-filter',
+		filterDisabled : 'disabled',
+		filterRowHide  : 'hideme'
+	});
 
-ts.addWidget({
-	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_excludeFilter : {},    // filters to exclude, per column
-		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_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
-		filter_searchFiltered: true,  // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
-		filter_selectSource  : null,  // include a function to return an array of values to be added to the column filter select
-		filter_startsWith    : false, // if true, filter start from the beginning of the cell contents
-		filter_useParsedData : false, // filter all data using parsed content
-		filter_serversideFiltering : false, // if true, server-side filtering should be performed because client-side filtering will be disabled, but the ui and events will still be used.
-		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 );
-		}
-	},
-	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 ' );
-		$table
-			.removeClass( 'hasFilters' )
-			// add .tsfilter namespace to all BUT search
-			.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
-		}
-		if ( wo.filter_reset ) {
-			$( document ).undelegate( wo.filter_reset, 'click.tsfilter' );
+	ts.addWidget({
+		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_excludeFilter : {},    // filters to exclude, per column
+			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_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
+			filter_searchFiltered: true,  // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
+			filter_selectSource  : null,  // include a function to return an array of values to be added to the column filter select
+			filter_startsWith    : false, // if true, filter start from the beginning of the cell contents
+			filter_useParsedData : false, // filter all data using parsed content
+			filter_serversideFiltering : false, // if true, must perform server-side filtering b/c client-side filtering is disabled, but the ui and events will still be used.
+			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 );
+			}
+		},
+		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 ' );
+			$table
+				.removeClass( 'hasFilters' )
+				// add .tsfilter namespace to all BUT search
+				.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
+			}
+			if ( wo.filter_reset ) {
+				$( document ).undelegate( wo.filter_reset, 'click.tsfilter' );
+			}
 		}
-	}
-});
+	});
 
-ts.filter = {
+	ts.filter = {
 
-	// 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
-		filtered  : /filtered/, // filtered (hidden) row class name; updated in the script
-		type      : /undefined|number/, // check type
-		exact     : /(^[\"\'=]+)|([\"\'=]+$)/g, // exact match (allow '==')
-		nondigit  : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
-		operators : /[<>=]/g, // replace operators
-		query     : '(q|query)' // replace filter queries
-	},
+		// 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
+			filtered  : /filtered/, // filtered (hidden) row class name; updated in the script
+			type      : /undefined|number/, // check type
+			exact     : /(^[\"\'=]+)|([\"\'=]+$)/g, // exact match (allow '==')
+			nondigit  : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
+			operators : /[<>=]/g, // replace operators
+			query     : '(q|query)' // replace filter queries
+		},
 		// function( c, data ) { }
 		// c = table.config
 		// data.$row = jQuery object of the row currently being processed
@@ -102,1507 +102,1522 @@ ts.filter = {
 		// 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: {
-		or : function( c, data, vars ) {
-			if ( /\|/.test( data.iFilter ) || ts.filter.regex.orSplit.test( data.filter ) ) {
-				var indx, filterMatched, txt, query, regex,
-					// duplicate data but split filter
-					data2 = $.extend( {}, data ),
-					index = data.index,
-					parsed = data.parsed[ index ],
-					filter = data.filter.split( ts.filter.regex.orSplit ),
-					iFilter = data.iFilter.split( ts.filter.regex.orSplit ),
-					len = filter.length;
-				for ( indx = 0; indx < len; indx++ ) {
-					data2.nestedFilters = true;
-					data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
-					data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
-					query = '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')';
-					regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
-					// filterMatched = data2.filter === '' && indx > 0 ? true
-					// look for an exact match with the 'or' unless the 'filter-match' class is found
-					filterMatched = regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars );
-					if ( filterMatched ) {
-						return filterMatched;
+		types: {
+			or : function( c, data, vars ) {
+				if ( /\|/.test( data.iFilter ) || ts.filter.regex.orSplit.test( data.filter ) ) {
+					var indx, filterMatched, txt, query, regex,
+						// duplicate data but split filter
+						data2 = $.extend( {}, data ),
+						index = data.index,
+						parsed = data.parsed[ index ],
+						filter = data.filter.split( ts.filter.regex.orSplit ),
+						iFilter = data.iFilter.split( ts.filter.regex.orSplit ),
+						len = filter.length;
+					for ( indx = 0; indx < len; indx++ ) {
+						data2.nestedFilters = true;
+						data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
+						data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
+						query = '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')';
+						try {
+							// use try/catch, because query may not be a valid regex if "|" is contained within a partial regex search,
+							// e.g "/(Alex|Aar" -> Uncaught SyntaxError: Invalid regular expression: /(/(Alex)/: Unterminated group
+							regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
+							// filterMatched = data2.filter === '' && indx > 0 ? true
+							// look for an exact match with the 'or' unless the 'filter-match' class is found
+							filterMatched = regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars );
+							if ( filterMatched ) {
+								return filterMatched;
+							}
+						} catch ( error ) {
+							return null;
+						}
 					}
+					// may be null from processing types
+					return filterMatched || false;
 				}
-				// may be null from processing types
-				return filterMatched || false;
-			}
-			return null;
-		},
-		// Look for an AND or && operator ( logical and )
-		and : function( c, data, vars ) {
-			if ( ts.filter.regex.andTest.test( data.filter ) ) {
-				var indx, filterMatched, result, txt, query, regex,
-					// duplicate data but split filter
-					data2 = $.extend( {}, data ),
-					index = data.index,
-					parsed = data.parsed[ index ],
-					filter = data.filter.split( ts.filter.regex.andSplit ),
-					iFilter = data.iFilter.split( ts.filter.regex.andSplit ),
-					len = filter.length;
-				for ( indx = 0; indx < len; indx++ ) {
-					data2.nestedFilters = true;
-					data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
-					data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
-					query = ( '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')' )
-						// replace wild cards since /(a*)/i will match anything
-						.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' );
-					regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
-					// look for an exact match with the 'and' unless the 'filter-match' class is found
-					result = ( regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars ) );
-					if ( indx === 0 ) {
-						filterMatched = result;
-					} else {
-						filterMatched = filterMatched && result;
+				return null;
+			},
+			// Look for an AND or && operator ( logical and )
+			and : function( c, data, vars ) {
+				if ( ts.filter.regex.andTest.test( data.filter ) ) {
+					var indx, filterMatched, result, txt, query, regex,
+						// duplicate data but split filter
+						data2 = $.extend( {}, data ),
+						index = data.index,
+						parsed = data.parsed[ index ],
+						filter = data.filter.split( ts.filter.regex.andSplit ),
+						iFilter = data.iFilter.split( ts.filter.regex.andSplit ),
+						len = filter.length;
+					for ( indx = 0; indx < len; indx++ ) {
+						data2.nestedFilters = true;
+						data2.filter = '' + ( ts.filter.parseFilter( c, filter[ indx ], index, parsed ) || '' );
+						data2.iFilter = '' + ( ts.filter.parseFilter( c, iFilter[ indx ], index, parsed ) || '' );
+						query = ( '(' + ( ts.filter.parseFilter( c, data2.filter, index, parsed ) || '' ) + ')' )
+							// replace wild cards since /(a*)/i will match anything
+							.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' );
+						try {
+							// use try/catch just in case RegExp is invalid
+							regex = new RegExp( data.isMatch ? query : '^' + query + '$', c.widgetOptions.filter_ignoreCase ? 'i' : '' );
+							// look for an exact match with the 'and' unless the 'filter-match' class is found
+							result = ( regex.test( data2.exact ) || ts.filter.processTypes( c, data2, vars ) );
+							if ( indx === 0 ) {
+								filterMatched = result;
+							} else {
+								filterMatched = filterMatched && result;
+							}
+						} catch ( error ) {
+							return null;
+						}
 					}
+					// may be null from processing types
+					return filterMatched || false;
 				}
-				// may be null from processing types
-				return filterMatched || false;
-			}
-			return null;
-		},
-		// Look for regex
-		regex: function( c, data ) {
-			if ( ts.filter.regex.regex.test( data.filter ) ) {
-				var matches,
-					// cache regex per column for optimal speed
-					regex = data.filter_regexCache[ data.index ] || ts.filter.regex.regex.exec( data.filter ),
-					isRegex = regex instanceof RegExp;
-				try {
-					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] );
+				return null;
+			},
+			// Look for regex
+			regex: function( c, data ) {
+				if ( ts.filter.regex.regex.test( data.filter ) ) {
+					var matches,
+						// cache regex per column for optimal speed
+						regex = data.filter_regexCache[ data.index ] || ts.filter.regex.regex.exec( data.filter ),
+						isRegex = regex instanceof RegExp;
+					try {
+						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;
 					}
-					matches = regex.test( data.exact );
-				} catch ( error ) {
-					matches = false;
-				}
-				return matches;
-			}
-			return null;
-		},
-		// Look for operators >, >=, < or <=
-		operators: function( c, data ) {
-			// 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 ),
-					parser = c.parsers[index],
-					savedSearch = query;
-				// parse filter value in case we're comparing numbers ( dates )
-				if ( parsed || parser.type === 'numeric' ) {
-					txt = $.trim( '' + data.iFilter.replace( ts.filter.regex.operators, '' ) );
-					result = ts.filter.parseFilter( c, txt, index, true );
-					query = ( typeof result === 'number' && result !== '' && !isNaN( result ) ) ? result : query;
+					return matches;
 				}
-				// iExact may be numeric - see issue #149;
-				// 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;
+				return null;
+			},
+			// Look for operators >, >=, < or <=
+			operators: function( c, data ) {
+				// 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 ),
+						parser = c.parsers[index],
+						savedSearch = query;
+					// parse filter value in case we're comparing numbers ( dates )
+					if ( parsed || parser.type === 'numeric' ) {
+						txt = $.trim( '' + data.iFilter.replace( ts.filter.regex.operators, '' ) );
+						result = ts.filter.parseFilter( c, txt, index, true );
+						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 )
+					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;
+					}
+					return result;
 				}
-				// keep showing all rows if nothing follows the operator
-				if ( !result && savedSearch === '' ) {
-					result = true;
+				return null;
+			},
+			// Look for a not match
+			notMatch: function( c, data ) {
+				if ( /^\!/.test( data.iFilter ) ) {
+					var indx,
+						txt = data.iFilter.replace( '!', '' ),
+						filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+					if ( ts.filter.regex.exact.test( filter ) ) {
+						// look for exact not matches - see #628
+						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 );
+					}
 				}
-				return result;
-			}
-			return null;
-		},
-		// Look for a not match
-		notMatch: function( c, data ) {
-			if ( /^\!/.test( data.iFilter ) ) {
-				var indx,
-					txt = data.iFilter.replace( '!', '' ),
-					filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
-				if ( ts.filter.regex.exact.test( filter ) ) {
-					// look for exact not matches - see #628
-					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 );
+				return null;
+			},
+			// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
+			exact: function( c, data ) {
+				/*jshint eqeqeq:false */
+				if ( ts.filter.regex.exact.test( data.iFilter ) ) {
+					var txt = data.iFilter.replace( ts.filter.regex.exact, '' ),
+						filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+					return data.anyMatch ? $.inArray( filter, data.rowArray ) >= 0 : filter == data.iExact;
 				}
-			}
-			return null;
-		},
-		// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
-		exact: function( c, data ) {
-			/*jshint eqeqeq:false */
-			if ( ts.filter.regex.exact.test( data.iFilter ) ) {
-				var txt = data.iFilter.replace( ts.filter.regex.exact, '' ),
-					filter = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
-				return data.anyMatch ? $.inArray( filter, data.rowArray ) >= 0 : filter == data.iExact;
-			}
-			return null;
-		},
-		// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
-		range : function( c, data ) {
-			if ( ts.filter.regex.toTest.test( data.iFilter ) ) {
-				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 );
+				return null;
+			},
+			// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
+			range : function( c, data ) {
+				if ( ts.filter.regex.toTest.test( data.iFilter ) ) {
+					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 );
 
-				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
-				}
-				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 ) ) {
-				var index = data.index,
-					parsed = data.parsed[ index ],
-					query = '' + ( ts.filter.parseFilter( c, data.iFilter, index, parsed ) || '' );
-				// look for an exact match with the 'or' unless the 'filter-match' class is found
-				if ( !/\?\*/.test( query ) && data.nestedFilters ) {
-					query = data.isMatch ? query : '^(' + query + ')$';
+					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
+					}
+					return ( result >= range1 && result <= range2 ) || ( range1 === '' || range2 === '' );
 				}
-				// parsing the filter may not work properly when using wildcards =/
-				return new RegExp(
-					query.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' ),
-					c.widgetOptions.filter_ignoreCase ? 'i' : ''
-				)
-				.test( data.exact );
-			}
-			return null;
-		},
-		// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
-		fuzzy: function( c, data ) {
-			if ( /^~/.test( data.iFilter ) ) {
-				var indx,
-					patternIndx = 0,
-					len = data.iExact.length,
-					txt = data.iFilter.slice( 1 ),
-					pattern = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
-				for ( indx = 0; indx < len; indx++ ) {
-					if ( data.iExact[ indx ] === pattern[ patternIndx ] ) {
-						patternIndx += 1;
+				return null;
+			},
+			// Look for wild card: ? = single, * = multiple, or | = logical OR
+			wild : function( c, data ) {
+				if ( /[\?\*\|]/.test( data.iFilter ) ) {
+					var index = data.index,
+						parsed = data.parsed[ index ],
+						query = '' + ( ts.filter.parseFilter( c, data.iFilter, index, parsed ) || '' );
+					// look for an exact match with the 'or' unless the 'filter-match' class is found
+					if ( !/\?\*/.test( query ) && data.nestedFilters ) {
+						query = data.isMatch ? query : '^(' + query + ')$';
+					}
+					// parsing the filter may not work properly when using wildcards =/
+					try {
+						return new RegExp(
+							query.replace( /\?/g, '\\S{1}' ).replace( /\*/g, '\\S*' ),
+							c.widgetOptions.filter_ignoreCase ? 'i' : ''
+						)
+						.test( data.exact );
+					} catch ( error ) {
+						return null;
 					}
 				}
-				if ( patternIndx === pattern.length ) {
-					return true;
+				return null;
+			},
+			// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
+			fuzzy: function( c, data ) {
+				if ( /^~/.test( data.iFilter ) ) {
+					var indx,
+						patternIndx = 0,
+						len = data.iExact.length,
+						txt = data.iFilter.slice( 1 ),
+						pattern = ts.filter.parseFilter( c, txt, data.index, data.parsed[data.index] ) || '';
+					for ( indx = 0; indx < len; indx++ ) {
+						if ( data.iExact[ indx ] === pattern[ patternIndx ] ) {
+							patternIndx += 1;
+						}
+					}
+					if ( patternIndx === pattern.length ) {
+						return true;
+					}
+					return false;
 				}
-				return false;
+				return null;
 			}
-			return null;
-		}
-	},
-	init: function( table, c, wo ) {
-		// filter language options
-		ts.language = $.extend( true, {}, {
-			to  : 'to',
-			or  : 'or',
-			and : 'and'
-		}, ts.language );
-
-		var options, string, txt, $header, column, filters, val, fxn, noSelect,
-			regex = ts.filter.regex;
-		c.$table.addClass( 'hasFilters' );
+		},
+		init: function( table, c, wo ) {
+			// filter language options
+			ts.language = $.extend( true, {}, {
+				to  : 'to',
+				or  : 'or',
+				and : 'and'
+			}, ts.language );
 
-		// define timers so using clearTimeout won't cause an undefined error
-		wo.searchTimer = null;
-		wo.filter_initTimer = null;
-		wo.filter_formatterCount = 0;
-		wo.filter_formatterInit = [];
-		wo.filter_anyColumnSelector = '[data-column="all"],[data-column="any"]';
-		wo.filter_multipleColumnSelector = '[data-column*="-"],[data-column*=","]';
+			var options, string, txt, $header, column, filters, val, fxn, noSelect,
+				regex = ts.filter.regex;
+			c.$table.addClass( 'hasFilters' );
 
-		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' ),
-			orSplit : new RegExp( '(?:\\s+(?:' + ts.language.or + ')\\s+|\\|)', 'gi' ),
-			iQuery : new RegExp( val, 'i' ),
-			igQuery : new RegExp( val, 'ig' )
-		});
+			// define timers so using clearTimeout won't cause an undefined error
+			wo.searchTimer = null;
+			wo.filter_initTimer = null;
+			wo.filter_formatterCount = 0;
+			wo.filter_formatterInit = [];
+			wo.filter_anyColumnSelector = '[data-column="all"],[data-column="any"]';
+			wo.filter_multipleColumnSelector = '[data-column*="-"],[data-column*=","]';
 
-		// 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 );
-		}
+			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' ),
+				orSplit : new RegExp( '(?:\\s+(?:' + ts.language.or + ')\\s+|\\|)', 'gi' ),
+				iQuery : new RegExp( val, 'i' ),
+				igQuery : new RegExp( val, 'ig' )
+			});
 
-		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 );
+			// 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 );
 			}
-			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' ) {
-					// force a new search since content has changed
-					c.lastCombinedFilter = null;
-					c.lastSearch = [];
+
+			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 );
 				}
-				// 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;
-		});
+				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' ) {
+						// 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 );
+				}
+				return false;
+			});
 
-		// reset button/link
-		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' );
-				});
-			} 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
+			// reset button/link
+			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' );
 					});
+				} 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' );
+						});
+				}
 			}
-		}
-		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' ) );
-					options = '';
-					if ( fxn === true && noSelect ) {
-						ts.filter.buildSelect( table, column );
-					} else if ( typeof fxn === 'object' && noSelect ) {
-						// add custom drop down list
-						for ( string in fxn ) {
-							if ( typeof string === 'string' ) {
-								options += options === '' ?
-									'<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 );
-									txt = val[1];
-									val = val[0];
+			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' ) );
+						options = '';
+						if ( fxn === true && noSelect ) {
+							ts.filter.buildSelect( table, column );
+						} else if ( typeof fxn === 'object' && noSelect ) {
+							// add custom drop down list
+							for ( string in fxn ) {
+								if ( typeof string === 'string' ) {
+									options += options === '' ?
+										'<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 );
+										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 );
-						txt = wo.filter_selectSource;
-						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 ) );
+							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 ) {
+								// updating so the extra options are appended
+								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, 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 ) {
-			txt = 'filterStart filterEnd '.split( ' ' ).join( c.namespace + 'filter ' );
-			c.$table
-				.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 : '' );
-			});
-		}
+			// show processing icon
+			if ( c.showProcessing ) {
+				txt = 'filterStart filterEnd '.split( ' ' ).join( c.namespace + 'filter ' );
+				c.$table
+					.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 : '' );
+				});
+			}
 
-		// set filtered rows count ( intially unfiltered )
-		c.filteredRows = c.totalRows;
+			// 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( 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 ) {
-				// prevent delayInit from triggering a cache build if filters are empty
-				if ( !( c.delayInit && filters.join( '' ) === '' ) ) {
-					ts.setFilters( table, filters, true );
+			// add default values
+			txt = 'tablesorter-initialized pagerBeforeInitialized '.split( ' ' ).join( c.namespace + 'filter ' );
+			c.$table
+			.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 ) {
+					// prevent delayInit from triggering a cache build if filters are empty
+					if ( !( c.delayInit && filters.join( '' ) === '' ) ) {
+						ts.setFilters( table, filters, true );
+					}
 				}
-			}
-			c.$table.trigger( 'filterFomatterUpdate' );
-			// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
-			setTimeout( function() {
-				if ( !wo.filter_initialized ) {
+				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 );
+					}
+				}, 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 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 );
-		}
-	},
-	// $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;
-		}
-	},
-	filterInitComplete: function( c ) {
-		var indx, len,
-			wo = c.widgetOptions,
-			count = 0,
-			completed = function() {
-				wo.filter_initialized = true;
-				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 ) {
-					count++;
-				}
+				}, 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 ) {
+				// add updates by column since this function
+				// may be called numerous times before initialization
+				wo.filter_formatterInit[ column ] = 1;
 			}
-			clearTimeout( wo.filter_initTimer );
-			if ( !wo.filter_initialized && count === wo.filter_formatterCount ) {
-				// filter widget initialized
+		},
+		filterInitComplete: function( c ) {
+			var indx, len,
+				wo = c.widgetOptions,
+				count = 0,
+				completed = function() {
+					wo.filter_initialized = true;
+					c.$table.trigger( 'filterInit', c );
+					ts.filter.findRows( c.table, c.$table.data( 'lastSearch' ) || [] );
+				};
+			if ( $.isEmptyObject( wo.filter_formatter ) ) {
 				completed();
-			} 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() {
+			} else {
+				len = wo.filter_formatterInit.length;
+				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 ) {
+					// filter widget initialized
 					completed();
-				}, 500 );
+				} 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() {
+						completed();
+					}, 500 );
+				}
 			}
-		}
-	},
-	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 ) {
-			saved = ts.storage( table, 'tablesorter-filters' ) || [];
-			isArray = $.isArray( saved );
-			// make sure we're not just getting an empty array
-			if ( !( isArray && saved.join( '' ) === '' || !isArray ) ) {
-				filters = saved;
+		},
+		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 ) {
+				saved = ts.storage( table, 'tablesorter-filters' ) || [];
+				isArray = $.isArray( saved );
+				// make sure we're not just getting an empty array
+				if ( !( isArray && saved.join( '' ) === '' || !isArray ) ) {
+					filters = saved;
+				}
 			}
-		}
-		// if no filters saved, then check default settings
-		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
-				col = indx === c.columns ? 'all' : indx;
-				filters[indx] = $filters
-					.filter( '[data-column="' + col + '"]' )
-					.attr( wo.filter_defaultAttrib ) || filters[indx] || '';
+			// if no filters saved, then check default settings
+			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
+					col = indx === c.columns ? 'all' : indx;
+					filters[indx] = $filters
+						.filter( '[data-column="' + col + '"]' )
+						.attr( wo.filter_defaultAttrib ) || filters[indx] || '';
+				}
 			}
-		}
-		c.$table.data( 'lastSearch', filters );
-		return filters;
-	},
-	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, tmp,
-			// c.columns defined in computeThIndexes()
-			cellFilter = wo.filter_cellFilter,
-			columns = c.columns,
-			arry = $.isArray( cellFilter ),
-			buildFilter = '<tr role="row" class="' + tscss.filterRow + ' ' + c.cssIgnoreRow + '">';
-		for ( column = 0; column < columns; column++ ) {
-			buildFilter += '<td';
-			if ( arry ) {
-				buildFilter += ( cellFilter[ column ] ? ' class="' + cellFilter[ column ] + '"' : '' );
-			} else {
-				buildFilter += ( cellFilter !== '' ? ' class="' + cellFilter + '"' : '' );
+			c.$table.data( 'lastSearch', filters );
+			return filters;
+		},
+		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, tmp,
+				// c.columns defined in computeThIndexes()
+				cellFilter = wo.filter_cellFilter,
+				columns = c.columns,
+				arry = $.isArray( cellFilter ),
+				buildFilter = '<tr role="row" class="' + tscss.filterRow + ' ' + c.cssIgnoreRow + '">';
+			for ( column = 0; column < columns; column++ ) {
+				buildFilter += '<td';
+				if ( arry ) {
+					buildFilter += ( cellFilter[ column ] ? ' class="' + cellFilter[ column ] + '"' : '' );
+				} else {
+					buildFilter += ( cellFilter !== '' ? ' class="' + cellFilter + '"' : '' );
+				}
+				buildFilter += '></td>';
 			}
-			buildFilter += '></td>';
-		}
-		c.$filters = $( buildFilter += '</tr>' )
-			.appendTo( c.$table.children( 'thead' ).eq( 0 ) )
-			.find( 'td' );
-		// build each filter input
-		for ( column = 0; column < columns; column++ ) {
-			disabled = false;
-			// assuming last cell of a column is the main 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' );
-			// 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';
+			c.$filters = $( buildFilter += '</tr>' )
+				.appendTo( c.$table.children( 'thead' ).eq( 0 ) )
+				.find( 'td' );
+			// build each filter input
+			for ( column = 0; column < columns; column++ ) {
+				disabled = false;
+				// assuming last cell of a column is the main 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' );
+				// 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';
 
-			if ( buildSelect ) {
-				buildFilter = $( '<select>' ).appendTo( c.$filters.eq( column ) );
-			} else {
-				ffxn = ts.getColumnData( table, wo.filter_formatter, column );
-				if ( ffxn ) {
-					wo.filter_formatterCount++;
-					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 ( buildSelect ) {
+					buildFilter = $( '<select>' ).appendTo( c.$filters.eq( column ) );
+				} else {
+					ffxn = ts.getColumnData( table, wo.filter_formatter, column );
+					if ( ffxn ) {
+						wo.filter_formatterCount++;
+						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' );
+						}
+						// 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 );
+						}
+					} else {
+						buildFilter = $( '<input type="search">' ).appendTo( c.$filters.eq( column ) );
 					}
-					// 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 ) {
+						tmp = $header.data( 'placeholder' ) ||
+							$header.attr( 'data-placeholder' ) ||
+							wo.filter_placeholder.search || '';
+						buildFilter.attr( 'placeholder', tmp );
 					}
-				} else {
-					buildFilter = $( '<input type="search">' ).appendTo( c.$filters.eq( column ) );
 				}
 				if ( buildFilter ) {
-					tmp = $header.data( 'placeholder' ) ||
-						$header.attr( 'data-placeholder' ) ||
-						wo.filter_placeholder.search || '';
-					buildFilter.attr( 'placeholder', tmp );
+					// add filter class name
+					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;
+					}
 				}
 			}
-			if ( buildFilter ) {
-				// add filter class name
-				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;
+		},
+		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 ) {
+				// save anyMatch element
+				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 );
 			}
-		}
-	},
-	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 ) {
-			// save anyMatch element
-			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 );
+			// 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( tmp.replace( /\s+/g, ' ' ) )
+			// include change for select - fixes #473
+			.bind( 'keyup' + namespace, function( event ) {
+				$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
+				// emulate what webkit does.... escape clears the filter
+				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 )
+				} 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 ) ) ) ) ) {
+					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( 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() );
+					ts.filter.searching( table, false, true );
+				}
+			});
+		},
+		searching: function( table, filter, skipFirst ) {
+			var wo = table.config.widgetOptions;
+			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 );
 			} else {
-				wo.filter_$externalFilters = $el;
+				// skip delay
+				ts.filter.checkFilters( table, filter, skipFirst );
 			}
-			// 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( tmp.replace( /\s+/g, ' ' ) )
-		// include change for select - fixes #473
-		.bind( 'keyup' + namespace, function( event ) {
-			$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
-			// emulate what webkit does.... escape clears the filter
-			if ( event.which === 27 ) {
-				this.value = '';
-			// live search
-			} else if ( wo.filter_liveSearch === false ) {
+		},
+		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
+			// 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 );
+					} ] );
+				}
 				return;
-				// 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 ) ) ) ) ) {
+			}
+			// add filter array back into inputs
+			if ( filterArray ) {
+				ts.setFilters( table, filters, false, skipFirst !== true );
+				if ( !wo.filter_initialized ) { c.lastCombinedFilter = ''; }
+			}
+			if ( wo.filter_hideFilters ) {
+				// show/hide filter row as needed
+				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 ) {
 				return;
+			} else if ( filter === false ) {
+				// force filter refresh
+				c.lastCombinedFilter = null;
+				c.lastSearch = [];
 			}
-			// 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( 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() );
-				ts.filter.searching( table, false, true );
+			if ( wo.filter_initialized ) {
+				c.$table.trigger( 'filterStart', [ filters ] );
 			}
-		});
-	},
-	searching: function( table, filter, skipFirst ) {
-		var wo = table.config.widgetOptions;
-		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 );
-		} else {
-			// skip delay
-			ts.filter.checkFilters( 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
-		// 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 ( c.showProcessing ) {
+				// give it time for the processing icon to kick in
+				setTimeout( function() {
+					ts.filter.findRows( table, filters, combinedFilters );
+					return false;
+				}, 30 );
+			} else {
+				ts.filter.findRows( table, filters, combinedFilters );
+				return false;
 			}
-			return;
-		}
-		// add filter array back into inputs
-		if ( filterArray ) {
-			ts.setFilters( table, filters, false, skipFirst !== true );
-			if ( !wo.filter_initialized ) { c.lastCombinedFilter = ''; }
-		}
-		if ( wo.filter_hideFilters ) {
-			// show/hide filter row as needed
+		},
+		hideFilters: function( table, c ) {
+			var timer;
 			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 ) {
-			return;
-		} else if ( filter === false ) {
-			// force filter refresh
-			c.lastCombinedFilter = null;
-			c.lastSearch = [];
-		}
-		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 );
-				return false;
-			}, 30 );
-		} else {
-			ts.filter.findRows( table, filters, combinedFilters );
-			return false;
-		}
-	},
-	hideFilters: function( table, c ) {
-		var timer;
-		c.$table
-			.find( '.' + tscss.filterRow )
-			.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 );
-					} else {
-						// don't hide if input has focus
-						// $( ':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 );
+				.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 );
+						} else {
+							// don't hide if input has focus
+							// $( ':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 );
+								}
 							}
 						}
-					}
-				}, 200 );
-			})
-			.find( 'input, select' ).bind( 'focus blur', function( e ) {
-				var event = e,
-					$row = $( this ).closest( 'tr' );
-				clearTimeout( timer );
-				timer = setTimeout( function() {
+					}, 200 );
+				})
+				.find( 'input, select' ).bind( 'focus blur', function( e ) {
+					var event = e,
+						$row = $( this ).closest( 'tr' );
 					clearTimeout( timer );
-					// don't hide row if any filter has a value
-					if ( ts.getFilters( c.$table ).join( '' ) === '' ) {
-						$row.toggleClass( tscss.filterRowHide, event.type !== 'focus' );
-					}
-				}, 200 );
-			});
-	},
-	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 ) ],
-			len = query.length - 1,
-			indx = 0,
-			val = mask;
-		if ( len < 1 && maskLen > 1 ) {
-			// 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 );
+					timer = setTimeout( function() {
+						clearTimeout( timer );
+						// don't hide row if any filter has a value
+						if ( ts.getFilters( c.$table ).join( '' ) === '' ) {
+							$row.toggleClass( tscss.filterRowHide, event.type !== 'focus' );
+						}
+					}, 200 );
+				});
+		},
+		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 ) ],
+				len = query.length - 1,
+				indx = 0,
+				val = mask;
+			if ( len < 1 && maskLen > 1 ) {
+				// only one 'word' in query but mask has >1 slots
+				query[1] = query[0];
 			}
-		}
-		return val;
-	},
-	getLatestSearch: function( $input ) {
-		if ( $input ) {
-			return $input.sort( function( a, b ) {
-				return $( b ).attr( 'data-lastSearchTime' ) - $( a ).attr( 'data-lastSearchTime' );
-			});
-		}
-		return $input || $();
-	},
-	multipleColumns: function( c, $input ) {
-		// 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,
-			columns = [],
-			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++ ) {
-				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
+			// 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 ( end >= c.columns ) {
-					end = c.columns - 1;
-				}
-				for ( ; start <= end; start++ ) {
-					columns.push( start );
+			}
+			return val;
+		},
+		getLatestSearch: function( $input ) {
+			if ( $input ) {
+				return $input.sort( function( a, b ) {
+					return $( b ).attr( 'data-lastSearchTime' ) - $( a ).attr( 'data-lastSearchTime' );
+				});
+			}
+			return $input || $();
+		},
+		multipleColumns: function( c, $input ) {
+			// 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,
+				columns = [],
+				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++ ) {
+					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;
+					}
+					for ( ; start <= end; start++ ) {
+						columns.push( start );
+					}
+					// remove processed range from val
+					val = val.replace( ranges[ indx ], '' );
 				}
-				// remove processed range from val
-				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 );
-					if ( indx < c.columns ) {
-						columns.push( 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 );
+						if ( indx < c.columns ) {
+							columns.push( indx );
+						}
 					}
 				}
 			}
-		}
-		// return all columns
-		if ( !columns.length ) {
-			for ( indx = 0; indx < c.columns; indx++ ) {
-				columns.push( indx );
+			// return all columns
+			if ( !columns.length ) {
+				for ( indx = 0; indx < c.columns; indx++ ) {
+					columns.push( indx );
+				}
 			}
-		}
-		return columns;
-	},
-	processTypes: function( c, data, vars ) {
-		var ffxn,
-			filterMatched = null,
-			matches = null;
-		for ( ffxn in ts.filter.types ) {
-			if ( $.inArray( ffxn, vars.excludeMatch ) < 0 && matches === null ) {
-				matches = ts.filter.types[ffxn]( c, data, vars );
-				if ( matches !== null ) {
-					filterMatched = matches;
+			return columns;
+		},
+		processTypes: function( c, data, vars ) {
+			var ffxn,
+				filterMatched = null,
+				matches = null;
+			for ( ffxn in ts.filter.types ) {
+				if ( $.inArray( ffxn, vars.excludeMatch ) < 0 && matches === null ) {
+					matches = ts.filter.types[ffxn]( c, data, vars );
+					if ( matches !== null ) {
+						filterMatched = matches;
+					}
 				}
 			}
-		}
-		return filterMatched;
-	},
-	processRow: function( c, data, vars ) {
-		var columnIndex, hasSelect, result, val, filterMatched,
-			fxn, ffxn, txt,
-			regex = ts.filter.regex,
-			wo = c.widgetOptions,
-			showRow = true;
-		data.$cells = data.$row.children();
+			return filterMatched;
+		},
+		processRow: function( c, data, vars ) {
+			var columnIndex, hasSelect, result, val, filterMatched,
+				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.isMatch = 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 );
+			if ( data.anyMatchFlag ) {
+				// look for multiple columns '1-3,4-6,8'
+				columnIndex = ts.filter.multipleColumns( c, wo.filter_$anyMatch );
+				data.anyMatch = true;
+				data.isMatch = 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;
 					}
-					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( ' ' );
+				}).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( ' ' );
 
-			vars.excludeMatch = vars.noAnyMatch;
-			filterMatched = ts.filter.processTypes( c, data, vars );
+				vars.excludeMatch = vars.noAnyMatch;
+				filterMatched = ts.filter.processTypes( c, data, vars );
 
-			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;
-					}
+				if ( filterMatched !== null ) {
+					showRow = filterMatched;
 				} else {
-					showRow = ( data.iExact + data.childRowText ).indexOf( data.iFilter ) >= 0;
+					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;
 				}
 			}
-			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;
+			for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
+				data.filter = data.filters[ columnIndex ];
+				data.index = columnIndex;
 
-			// filter types to exclude, per column
-			vars.excludeMatch = vars.excludeFilter[ columnIndex ];
+				// filter types to exclude, per column
+				vars.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;
+				// 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;
 
-				data.isMatch = c.$headerIndexed[ data.index ].hasClass( 'filter-match' );
+					data.isMatch = c.$headerIndexed[ data.index ].hasClass( 'filter-match' );
 
-				result = showRow; // if showRow is true, show that row
+					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 );
-				}
+					// 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 ];
-				hasSelect = c.$headerIndexed[ columnIndex ].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 = data.isMatch ?
-							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 );
+					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;
 					}
-				}
-				if ( filterMatched === null ) {
-					// cycle through the different filters
-					// filters return a boolean or null if nothing matches
-					filterMatched = ts.filter.processTypes( c, data, vars );
-					if ( filterMatched !== null ) {
-						result = filterMatched;
-					// Look for match, and add child row data for matching
+					// 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 ];
+					hasSelect = c.$headerIndexed[ columnIndex ].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 = data.isMatch ?
+								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
+						filterMatched = ts.filter.processTypes( c, data, vars );
+						if ( filterMatched !== null ) {
+							result = filterMatched;
+						// Look for match, and add child row data for matching
+						} else {
+							txt = ( data.iExact + data.childRowText )
+								.indexOf( ts.filter.parseFilter( c, data.iFilter, columnIndex, data.parsed[ columnIndex ] ) );
+							result = ( ( !wo.filter_startsWith && txt >= 0 ) || ( wo.filter_startsWith && txt === 0 ) );
+						}
 					} 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 ) );
+						result = filterMatched;
 					}
-				} else {
-					result = filterMatched;
+					showRow = ( result ) ? showRow : false;
 				}
-				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,
-				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 ) || ''
-			};
+			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,
+					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 ] &&
-				// force parsing if parser type is numeric
-				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' );
-		}).get();
+			// 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 ] &&
+					// force parsing if parser type is numeric
+					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' );
+			}).get();
 
-		for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
-			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+/ );
-		}
+			for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
+				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 );
-			time = new Date();
-		}
-		// filtered rows count
-		c.filteredRows = 0;
-		c.totalRows = 0;
-		// combindedFilters are undefined on init
-		combinedFilters = ( storedFilters || [] ).join( '' );
+			if ( c.debug ) {
+				console.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 = ( 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 );
-			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();
-			}) );
+			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();
+				}) );
 
-			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 );
-				len = $rows.length;
+				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 );
+					len = $rows.length;
 
-				if ( ( wo.filter_$anyMatch && wo.filter_$anyMatch.length ) ||
-					typeof filters[c.columns] !== 'undefined' ) {
-					data.anyMatchFlag = true;
-					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( regex.andSplit );
-						injected = false;
-						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 );
-									indx--;
-									injected = true;
+					if ( ( wo.filter_$anyMatch && wo.filter_$anyMatch.length ) ||
+						typeof filters[c.columns] !== 'undefined' ) {
+						data.anyMatchFlag = true;
+						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( regex.andSplit );
+							injected = false;
+							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 );
+										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++ ) {
-						val = filters[indx] || '';
-						// break out of loop if we've already determined not to search filtered rows
-						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' ) );
+					// 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++ ) {
+							val = filters[indx] || '';
+							// break out of loop if we've already determined not to search filtered rows
+							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' ) );
+						}
 					}
-				}
-				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 ( data.anyMatchFlag ) {
-					if ( c.sortLocaleCompare ) {
-						// replace accents
-						data.anyMatchFilter = ts.replaceAccents( data.anyMatchFilter );
+					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 ) {
+						console.log( 'Filter: Searching through ' +
+							( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' );
 					}
-					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;
+					if ( data.anyMatchFlag ) {
+						if ( c.sortLocaleCompare ) {
+							// replace accents
+							data.anyMatchFilter = ts.replaceAccents( data.anyMatchFilter );
+						}
+						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.toLowerCase();
 					}
-					// 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.toLowerCase();
-				}
 
-				// loop through the rows
-				for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
+					// loop through the rows
+					for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
 
-					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 ( isChild || ( searchFiltered && regex.filtered.test( txt ) ) ) {
-						continue;
-					}
+						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 ( isChild || ( searchFiltered && regex.filtered.test( txt ) ) ) {
+							continue;
+						}
 
-					data.$row = $rows.eq( rowIndex );
-					data.cacheArray = norm_rows[ rowIndex ];
-					rowData = data.cacheArray[ c.columns ];
-					data.rawArray = rowData.raw;
-					data.childRowText = '';
+						data.$row = $rows.eq( rowIndex );
+						data.cacheArray = norm_rows[ rowIndex ];
+						rowData = data.cacheArray[ c.columns ];
+						data.rawArray = rowData.raw;
+						data.childRowText = '';
 
-					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( '' ) || '';
+						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 ) :
+								'';
 						}
-						data.childRowText = wo.filter_childRows ?
-							( wo.filter_ignoreCase ? txt.toLowerCase() : txt ) :
-							'';
-					}
 
-					showRow = ts.filter.processRow( c, data, vars );
-					childRow = rowData.$row.filter( ':gt( 0 )' );
+						showRow = ts.filter.processRow( c, data, vars );
+						childRow = rowData.$row.filter( ':gt( 0 )' );
 
-					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 ( 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 );
+								}
 							}
+							childRow.toggleClass( wo.filter_filteredRow, !showRow );
 						}
-						childRow.toggleClass( wo.filter_filteredRow, !showRow );
-					}
 
-					rowData.$row
-						.toggleClass( wo.filter_filteredRow, !showRow )[0]
-						.display = showRow ? '' : 'none';
+						rowData.$row
+							.toggleClass( wo.filter_filteredRow, !showRow )[0]
+							.display = showRow ? '' : 'none';
+					}
 				}
+				c.filteredRows += $rows.not( '.' + wo.filter_filteredRow ).length;
+				c.totalRows += $rows.length;
+				ts.processTbody( table, $tbody, false );
 			}
-			c.filteredRows += $rows.not( '.' + wo.filter_filteredRow ).length;
-			c.totalRows += $rows.length;
-			ts.processTbody( table, $tbody, false );
-		}
-		c.lastCombinedFilter = combinedFilters; // save last search
-		// 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 ( wo.filter_initialized ) {
-			c.$table.trigger( 'filterEnd', c );
-		}
-		setTimeout( function() {
-			c.$table.trigger( 'applyWidgets' ); // make sure zebra widget is applied
-		}, 0 );
-	},
-	getOptionSource: function( table, column, onlyAvail ) {
-		table = $( table )[0];
-		var cts, txt, 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 );
+			c.lastCombinedFilter = combinedFilters; // save last search
+			// 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 ) {
+				console.log( 'Completed filter widget search' + ts.benchmark(time) );
+			}
+			if ( wo.filter_initialized ) {
+				c.$table.trigger( 'filterEnd', c );
+			}
+			setTimeout( function() {
+				c.$table.trigger( 'applyWidgets' ); // make sure zebra widget is applied
+			}, 0 );
+		},
+		getOptionSource: function( table, column, onlyAvail ) {
+			table = $( table )[0];
+			var cts, txt, 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 );
 
-		if ( onlyAvail && last[column] !== '' ) {
-			onlyAvail = false;
-		}
+			if ( onlyAvail && last[column] !== '' ) {
+				onlyAvail = false;
+			}
 
-		// filter select source option
-		if ( fxn === true ) {
-			// OVERALL source
-			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 ) ) {
-			arry = fxn;
-		} else if ( $.type( source ) === 'object' && fxn ) {
-			// custom select source function for a SPECIFIC COLUMN
-			arry = fxn( table, column, onlyAvail );
-		}
-		if ( arry === false ) {
-			// fall back to original method
-			arry = ts.filter.getOptions( table, column, onlyAvail );
-		}
+			// filter select source option
+			if ( fxn === true ) {
+				// OVERALL source
+				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 ) ) {
+				arry = fxn;
+			} else if ( $.type( source ) === 'object' && fxn ) {
+				// custom select source function for a SPECIFIC COLUMN
+				arry = fxn( table, column, onlyAvail );
+			}
+			if ( arry === false ) {
+				// fall back to original method
+				arry = ts.filter.getOptions( table, column, onlyAvail );
+			}
 
-		// get unique elements and sort the list
-		// 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;
-		});
+			// get unique elements and sort the list
+			// 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;
+			});
 
-		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++ ) {
-				txt = arry[ indx ];
-				// parse array data using set column parser; this DOES NOT pass the original
-				// table cell to the parser format function
-				parsed.push({
-					t : txt,
-					// check parser length - fixes #934
-					p : c.parsers && c.parsers.length && c.parsers[ column ].format( txt, table, [], column ) || txt
+			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++ ) {
+					txt = arry[ indx ];
+					// parse array data using set column parser; this DOES NOT pass the original
+					// table cell to the parser format function
+					parsed.push({
+						t : txt,
+						// check parser length - fixes #934
+						p : c.parsers && c.parsers.length && c.parsers[ column ].format( txt, table, [], column ) || txt
+					});
+				}
+
+				// sort parsed select options
+				cts = c.textSorter || '';
+				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 ) ) {
+						// custom OVERALL text sorter
+						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 ) {
+						// fall back to natural sort
+						return ts.sortNatural( x, y );
+					}
+					// using an older version! do a basic sort
+					return true;
 				});
+				// rebuild arry from sorted parsed data
+				arry = [];
+				len = parsed.length;
+				for ( indx = 0; indx < len; indx++ ) {
+					arry.push( parsed[indx].t );
+				}
+				return arry;
 			}
-
-			// sort parsed select options
-			cts = c.textSorter || '';
-			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 ) ) {
-					// custom OVERALL text sorter
-					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 ) {
-					// fall back to natural sort
-					return ts.sortNatural( x, y );
+		},
+		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++ ) {
+				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];
+					// check if has class filtered
+					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 ] );
+					} else {
+						// get raw cached data instead of content directly from the cells
+						arry.push( cache.normalized[ rowIndex ][ c.columns ].raw[ column ] );
+					}
 				}
-				// using an older version! do a basic sort
-				return true;
-			});
-			// rebuild arry from sorted parsed data
-			arry = [];
-			len = parsed.length;
-			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,
-			c = table.config,
-			wo = c.widgetOptions,
-			arry = [];
-		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];
-				// check if has class filtered
-				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 ] );
-				} else {
-					// get raw cached data instead of content directly from the cells
-					arry.push( cache.normalized[ rowIndex ][ c.columns ].raw[ column ] );
-				}
+		},
+		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>',
+				// 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 );
 			}
-		}
-		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;
-		}
-		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>',
-			// 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 );
-		}
 
-		if ( $.isArray( arry ) ) {
-			// build option list
-			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 );
-					val = t[0];
-					txt = t[1];
+			if ( $.isArray( arry ) ) {
+				// build option list
+				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 );
+						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 = [];
 			}
-			// 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;
-		}
-		$filter = $filters.filter( 'select[data-column="' + column + '"]' );
+			// 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 + '"]' );
 
-		// make sure there is a select there!
-		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 );
+			// make sure there is a select there!
+			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 );
+				}
+				$filter.val( currentValue );
 			}
-			$filter.val( currentValue );
-		}
-	},
-	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++ ) {
-			$header = c.$headerIndexed[columnIndex];
-			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 ) );
+		},
+		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++ ) {
+				$header = c.$headerIndexed[columnIndex];
+				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 ) );
+				}
 			}
 		}
-	}
-};
+	};
 
-ts.getFilters = function( table, getRaw, setFilters, skipFirst ) {
-	var i, $filters, $column, cols,
-		filters = false,
-		c = table ? $( table )[0].config : '',
-		wo = c ? c.widgetOptions : '';
-	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 );
+	ts.getFilters = function( table, getRaw, setFilters, skipFirst ) {
+		var i, $filters, $column, cols,
+			filters = false,
+			c = table ? $( table )[0].config : '',
+			wo = c ? c.widgetOptions : '';
+		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 ( wo.filter_$externalFilters ) {
-			$filters = $filters && $filters.length ?
-				$filters.add( wo.filter_$externalFilters ) :
-				wo.filter_$externalFilters;
-		}
-		if ( $filters && $filters.length ) {
-			filters = setFilters || [];
-			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' )
-					wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector :
-					'[data-column="' + i + '"]' );
-				$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.length > 1 ) {
-							$column = $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' );
-					} 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
+		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 ( $filters && $filters.length ) {
+				filters = setFilters || [];
+				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' )
+						wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector :
+						'[data-column="' + i + '"]' );
+					$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.length > 1 ) {
+								$column = $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
-								.slice( 1 )
-								.filter( '[data-column*="' + $column.attr( 'data-column' ) + '"]' )
-								.val( filters[ i ] );
+								.val( setFilters[ i ] )
+								.trigger( 'change.tsfilter' );
 						} else {
-							$column
-								.slice( 1 )
-								.val( filters[ i ] );
+							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 ] );
+							} else {
+								$column
+									.slice( 1 )
+									.val( filters[ i ] );
+							}
+						}
+						// save any match input dynamically
+						if ( i === c.columns && $column.length ) {
+							wo.filter_$anyMatch = $column;
 						}
-					}
-					// save any match input dynamically
-					if ( i === c.columns && $column.length ) {
-						wo.filter_$anyMatch = $column;
 					}
 				}
 			}
 		}
-	}
-	if ( filters.length === 0 ) {
-		filters = false;
-	}
-	return filters;
-};
+		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 ) {
-		// 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' );
-	}
-	return !!valid;
-};
+	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' );
+		}
+		return !!valid;
+	};
 
 })( jQuery );