diff --git a/Gruntfile.js b/Gruntfile.js
index bcec89aa..874f454a 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -236,7 +236,7 @@ module.exports = function (grunt) {
     grunt.registerTask('default', ['jshint', 'toes5', 'requirejs', 'concat', 'uglify', 'cssmin', 'copy', 'qunit']);
     grunt.registerTask('build', ['jshint', 'toes5', 'requirejs', 'concat', /*'uglify',*/ 'cssmin', 'copy']);
     grunt.registerTask('dev', ['jshint', 'toes5', 'concat', 'cssmin', 'copy']);
-    grunt.registerTask('build-requirejs', ['requirejs:compile-main', 'requirejs:compile-main']);
+    grunt.registerTask('build-requirejs', ['requirejs:compile-main']);
     grunt.registerTask('toes5', ['babel:build-main','babel:build-extensions']);
     grunt.registerTask('test', ['qunit']);
 };
diff --git a/dist/_core_.js b/dist/_core_.js
new file mode 100644
index 00000000..a6b9667a
--- /dev/null
+++ b/dist/_core_.js
@@ -0,0 +1,3590 @@
+ /*------------------------------------------------------------------------
+    - HTML Table Filter Generator v3.0
+    - By Max Guglielmi (tablefilter.free.fr)
+    - Licensed under the MIT License
+---------------------------------------------------------------------------
+    - Special credit to:
+    Cedric Wartel, cnx.claude@free.fr, Florent Hirchy, Váry Péter,
+    Anthony Maes, Nuovella Williams, Fuggerbit, Venkata Seshagiri Rao
+    Raya, Piepiax, Manuel Kern, Baladhandayutham for active contribution
+    and/or inspiration
+------------------------------------------------------------------------ */
+define(function (require) {
+
+var global = this,
+    evt = require('event').Event,
+    dom = require('dom').Dom,
+    str = require('string').Str,
+    cookie = require('cookie').Cookie,
+    types = require('types').Types,
+    array = require('array').Arr,
+    hlp = require('helpers').Helpers,
+    dateHelper = require('date').DateHelper,
+    isValidDate = dateHelper.isValid,
+    formatDate = dateHelper.format,
+    Sort = require('sort').Sort,
+    doc = global.document;
+
+/**
+ * TF object constructor
+ * @param {String} id Table id
+ * @param {Number} row index indicating the 1st row
+ * @param {Object} configuration object
+ */
+function TableFilter(id) {
+    if(arguments.length === 0){ return; }
+
+    this.id = id;
+    this.version = '3.0';
+    this.year = new Date().getFullYear();
+    this.tbl = dom.id(id);
+    this.startRow = null;
+    this.refRow = null;
+    this.headersRow = null;
+    this.cfg = {};
+    this.nbFilterableRows = null;
+    this.nbRows = null;
+    this.nbCells = null;
+    this._hasGrid = false;
+    this.enableModules = false;
+
+    if(!this.tbl || str.lower(this.tbl.nodeName) !== 'table' ||
+        this.getRowsNb() === 0){
+        throw new Error(
+            'Could not instantiate TF object: HTML table not found.');
+    }
+
+    if(arguments.length>1){
+        for(var i=0; i<arguments.length; i++){
+            var arg = arguments[i];
+            var argtype = typeof arg;
+            switch(str.lower(argtype)){
+                case 'number':
+                    this.startRow = arg;
+                break;
+                case 'object':
+                    this.cfg = arg;
+                break;
+            }
+        }
+    }
+
+    // configuration object
+    var f = this.cfg;
+
+    //Start row et cols nb
+    this.refRow = this.startRow===null ? 2 : (this.startRow+1);
+    try{ this.nbCells = this.getCellsNb(this.refRow); }
+    catch(e){ this.nbCells = this.getCellsNb(0); }
+
+    //default script base path
+    this.basePath = f.base_path!==undefined ? f.base_path : '';
+
+    /*** filter types ***/
+    this.fltTypeInp =           'input';
+    this.fltTypeSlc =           'select';
+    this.fltTypeMulti =         'multiple';
+    this.fltTypeCheckList =     'checklist';
+    this.fltTypeNone =          'none';
+    this.fltCol =               []; //filter type of each column
+
+    for(var j=0; j<this.nbCells; j++){
+        var cfgCol = f['col_'+j];
+        var col = !cfgCol ? this.fltTypeInp : str.lower(cfgCol);
+        this.fltCol.push(col);
+        this['col'+j] = col;
+    }
+
+    /*** Developer's additional methods ***/
+    this.publicMethods = f.public_methods!==undefined ?
+        f.public_methods : false;
+
+    /*** filters' grid properties ***/
+
+    //enables/disables filter grid
+    this.fltGrid = f.grid===false ? false : true;
+
+    /*** Grid layout ***/
+    //enables/disables grid layout (fixed headers)
+    this.gridLayout = f.grid_layout ? true : false;
+    this.sourceTblHtml = null;
+    if(this.gridLayout){
+        //Firefox does not support outerHTML property...
+        if(this.tbl.outerHTML===undefined){ setOuterHtml(); }
+        this.sourceTblHtml = this.tbl.outerHTML;
+    }
+    /*** ***/
+
+    this.filtersRowIndex = f.filters_row_index || 0;
+    this.headersRow = f.headers_row_index ||
+        (this.filtersRowIndex===0 ? 1 : 0);
+
+    if(this.gridLayout){
+        if(this.headersRow > 1){
+            this.filtersRowIndex = this.headersRow+1;
+        } else {
+            this.filtersRowIndex = 1;
+            this.headersRow = 0;
+        }
+    }
+
+    //defines tag of the cells containing filters (td/th)
+    this.fltCellTag = f.filters_cell_tag!=='th' ||
+        f.filters_cell_tag!=='td' ? 'td' : f.filters_cell_tag;
+
+    //stores filters ids
+    this.fltIds = [];
+    //stores filters DOM elements
+    this.fltElms = [];
+    //stores filters values
+    this.searchArgs = null;
+    //stores table data
+    this.tblData = [];
+    //stores valid rows indexes (rows visible upon filtering)
+    this.validRowsIndex = null;
+    //stores filters row element
+    this.fltGridEl = null;
+    //is first load boolean
+    this.isFirstLoad = true;
+    //container div for paging elements, reset btn etc.
+    this.infDiv = null;
+    //div for rows counter
+    this.lDiv = null;
+    //div for reset button and results per page select
+    this.rDiv = null;
+    //div for paging elements
+    this.mDiv = null;
+    //table container div for fixed headers (IE only)
+    this.contDiv = null;
+
+    //defines css class for div containing paging elements, rows counter etc.
+    this.infDivCssClass = f.inf_div_css_class || 'inf';
+    //defines css class for left div
+    this.lDivCssClass = f.left_div_css_class || 'ldiv';
+    //defines css class for right div
+    this.rDivCssClass =  f.right_div_css_class || 'rdiv';
+    //defines css class for mid div
+    this.mDivCssClass = f.middle_div_css_class || 'mdiv';
+    //table container div css class
+    this.contDivCssClass = f.content_div_css_class || 'cont';
+
+    /*** filters' grid appearance ***/
+    //stylesheet file
+    this.stylesheet = f.stylesheet || this.basePath+'filtergrid.css';
+    this.stylesheetId = this.id + '_style';
+    //defines css class for filters row
+    this.fltsRowCssClass = f.flts_row_css_class || 'fltrow';
+     //enables/disables icons (paging, reset button)
+    this.enableIcons = f.enable_icons===false ? false : true;
+    //enables/disbles rows alternating bg colors
+    this.alternateBgs = f.alternate_rows===true ? true : false;
+    //defines widths of columns
+    this.hasColWidth = f.col_width===true ? true : false;
+    this.colWidth = this.hasColWidth ? f.col_width : null;
+    //enables/disables fixed headers
+    this.fixedHeaders = f.fixed_headers===true ? true : false;
+    //tbody height if fixed headers enabled
+    this.tBodyH = !isNaN(f.tbody_height) ? f.tbody_height : 200;
+    //defines css class for filters
+    this.fltCssClass = f.flt_css_class || 'flt';
+    //defines css class for multiple selects filters
+    this.fltMultiCssClass = f.flt_multi_css_class || 'flt_multi';
+    //defines css class for filters
+    this.fltSmallCssClass = f.flt_small_css_class || 'flt_s';
+    //defines css class for single-filter
+    this.singleFltCssClass = f.single_flt_css_class || 'single_flt';
+    this.isStartBgAlternate =   true;
+
+    /*** filters' grid behaviours ***/
+    //enables/disables enter key
+    this.enterKey = f.enter_key===false ? false : true;
+    //enables/disables alternative fn call
+    this.isModFilterFn = f.mod_filter_fn===true ? true : false;
+    // used by tf_DetectKey fn
+    this.modFilterFn = this.isModFilterFn ? f.mod_filter_fn : null;
+    //calls function before filtering starts
+    this.onBeforeFilter = types.isFn(f.on_before_filter) ?
+        f.on_before_filter : null;
+    //calls function after filtering
+    this.onAfterFilter = types.isFn(f.on_after_filter) ?
+        f.on_after_filter : null;
+    //enables/disables case sensitivity
+    this.matchCase = f.match_case===true ? true : false;
+    //enables/disbles exact match for search
+    this.exactMatch = f.exact_match===true ? true : false;
+    //refreshes drop-down lists upon validation
+    this.linkedFilters = f.linked_filters===true ? true : false;
+    //wheter excluded options are disabled
+    this.disableExcludedOptions = f.disable_excluded_options===true ?
+        true : false;
+    //stores active filter element
+    this.activeFlt = null;
+    //id of active filter
+    this.activeFilterId = null;
+    //enables/disbles column operation(sum,mean)
+    this.hasColOperation = f.col_operation ? true : false;
+    this.colOperation = null;
+    //enables always visible rows
+    this.hasVisibleRows = f.rows_always_visible ? true : false;
+    //array containing always visible rows
+    this.visibleRows = this.hasVisibleRows ? f.rows_always_visible : [];
+    //defines search type: include or exclude
+    this.searchType = f.search_type || 'include';
+    //enables/disables external filters generation
+    this.isExternalFlt = f.external_flt_grid===true ? true : false;
+    //array containing ids of external elements containing filters
+    this.externalFltTgtIds = f.external_flt_grid_ids || null;
+    //stores filters elements if isExternalFlt is true
+    this.externalFltEls = [];
+    //delays any filtering process if loader true
+    this.execDelay = !isNaN(f.exec_delay) ? parseInt(f.exec_delay,10) : 100;
+    //calls function when filters grid loaded
+    this.onFiltersLoaded = types.isFn(f.on_filters_loaded) ?
+        f.on_filters_loaded : null;
+    //enables/disables single filter search
+    this.singleSearchFlt = f.single_search_filter===true ? true : false;
+    //calls function after row is validated
+    this.onRowValidated = types.isFn(f.on_row_validated) ?
+        f.on_row_validated : null;
+    //array defining columns for customCellData event
+    this.customCellDataCols = f.custom_cell_data_cols ?
+        f.custom_cell_data_cols : [];
+    //calls custom function for retrieving cell data
+    this.customCellData = types.isFn(f.custom_cell_data) ?
+        f.custom_cell_data : null;
+    //input watermark text array
+    this.watermark = f.watermark || '';
+    this.isWatermarkArray = types.isArray(this.watermark);
+    //id of toolbar container element
+    this.toolBarTgtId = f.toolbar_target_id || null;
+    //enables/disables help div
+    this.helpInstructions = f.help_instructions || false;
+    //popup filters
+    this.popUpFilters = f.popup_filters===true ? true : false;
+    //active columns color
+    this.markActiveColumns = f.mark_active_columns===true ? true : false;
+    //defines css class for active column header
+    this.activeColumnsCssClass = f.active_columns_css_class ||
+        'activeHeader';
+    //calls function before active column header is marked
+    this.onBeforeActiveColumn = types.isFn(f.on_before_active_column) ?
+        f.on_before_active_column : null;
+    //calls function after active column header is marked
+    this.onAfterActiveColumn = types.isFn(f.on_after_active_column) ?
+        f.on_after_active_column : null;
+
+    /*** select filter's customisation and behaviours ***/
+    //defines 1st option text
+    this.displayAllText = f.display_all_text || '';
+    //enables/disables empty option in combo-box filters
+    this.enableEmptyOption = f.enable_empty_option===true ? true : false;
+    //defines empty option text
+    this.emptyText = f.empty_text || '(Empty)';
+    //enables/disables non empty option in combo-box filters
+    this.enableNonEmptyOption = f.enable_non_empty_option===true ?
+        true : false;
+    //defines empty option text
+    this.nonEmptyText = f.non_empty_text || '(Non empty)';
+    //enables/disables onChange event on combo-box
+    this.onSlcChange = f.on_change===false ? false : true;
+    //enables/disables select options sorting
+    this.sortSlc = f.sort_select===false ? false : true;
+    //enables/disables ascending numeric options sorting
+    this.isSortNumAsc = f.sort_num_asc===true ? true : false;
+    this.sortNumAsc = this.isSortNumAsc ? f.sort_num_asc : null;
+    //enables/disables descending numeric options sorting
+    this.isSortNumDesc = f.sort_num_desc===true ? true : false;
+    this.sortNumDesc = this.isSortNumDesc ? f.sort_num_desc : null;
+    //enabled selects are populated on demand
+    this.fillSlcOnDemand = f.fill_slc_on_demand===true ? true : false;
+    this.hasCustomSlcOptions = types.isObj(f.custom_slc_options) ?
+        true : false;
+    this.customSlcOptions = types.isArray(f.custom_slc_options) ?
+        f.custom_slc_options : null;
+
+    /*** Filter operators ***/
+    this.rgxOperator = f.regexp_operator || 'rgx:';
+    this.emOperator = f.empty_operator || '[empty]';
+    this.nmOperator = f.nonempty_operator || '[nonempty]';
+    this.orOperator = f.or_operator || '||';
+    this.anOperator = f.and_operator || '&&';
+    this.grOperator = f.greater_operator || '>';
+    this.lwOperator = f.lower_operator || '<';
+    this.leOperator = f.lower_equal_operator || '<=';
+    this.geOperator = f.greater_equal_operator || '>=';
+    this.dfOperator = f.different_operator || '!';
+    this.lkOperator = f.like_operator || '*';
+    this.eqOperator = f.equal_operator || '=';
+    this.stOperator = f.start_with_operator || '{';
+    this.enOperator = f.end_with_operator || '}';
+    this.curExp = f.cur_exp || '^[¥£€$]';
+    this.separator = f.separator || ',';
+
+    /*** rows counter ***/
+    //show/hides rows counter
+    this.rowsCounter = f.rows_counter===true ? true : false;
+
+    /*** status bar ***/
+    //show/hides status bar
+    this.statusBar = f.status_bar===true ? true : false;
+
+    /*** loader ***/
+    //enables/disables loader/spinner indicator
+    this.loader = f.loader===true ? true : false;
+
+    /*** validation - reset buttons/links ***/
+    //show/hides filter's validation button
+    this.displayBtn = f.btn===true ? true : false;
+    //defines validation button text
+    this.btnText = f.btn_text || (!this.enableIcons ? 'Go' : '');
+    //defines css class for validation button
+    this.btnCssClass = f.btn_css_class ||
+        (!this.enableIcons ? 'btnflt' : 'btnflt_icon');
+    //show/hides reset link
+    this.btnReset = f.btn_reset===true ? true : false;
+    //defines css class for reset button
+    this.btnResetCssClass = f.btn_reset_css_class || 'reset';
+    //callback function before filters are cleared
+    this.onBeforeReset = types.isFn(f.on_before_reset) ?
+        f.on_before_reset : null;
+    //callback function after filters are cleared
+    this.onAfterReset = types.isFn(f.on_after_reset) ?
+        f.on_after_reset : null;
+
+    /*** paging ***/
+    //enables/disables table paging
+    this.paging = f.paging===true ? true : false;
+    this.nbVisibleRows = 0; //nb visible rows
+    this.nbHiddenRows = 0; //nb hidden rows
+
+    /*** webfx sort adapter ***/
+    //enables/disables default table sorting
+    this.sort = f.sort===true ? true : false;
+    //indicates if sort is set (used in tfAdapter.sortabletable.js)
+    this.isSortEnabled = false;
+    //indicates if tables was sorted
+    this.sorted = false;
+    this.sortConfig = f.sort_config || {};
+    this.sortConfig.name = this.sortConfig['name']!==undefined ?
+        f.sort_config.name : 'sortabletable';
+    this.sortConfig.src = this.sortConfig['src']!==undefined ?
+        f.sort_config.src : this.basePath+'sortabletable.js';
+    this.sortConfig.adapterSrc =
+        this.sortConfig['adapter_src']!==undefined ?
+        f.sort_config.adapter_src :
+        this.basePath+'tfAdapter.sortabletable.js';
+    this.sortConfig.initialize =
+        this.sortConfig['initialize']!==undefined ?
+            f.sort_config.initialize :
+            function(o){
+                if(o.SetSortTable){ o.SetSortTable(); }
+            };
+    this.sortConfig.sortTypes =
+        types.isArray(this.sortConfig['sort_types']) ?
+        f.sort_config.sort_types : [];
+    this.sortConfig.sortCol = this.sortConfig['sort_col']!==undefined ?
+        f.sort_config.sort_col : null;
+    this.sortConfig.asyncSort =
+        this.sortConfig['async_sort']===true ? true : false;
+    this.sortConfig.triggerIds =
+        types.isArray(this.sortConfig['sort_trigger_ids']) ?
+        f.sort_config.sort_trigger_ids : [];
+
+    /*** ezEditTable extension ***/
+    //enables/disables table selection feature
+    this.selectable = f.selectable===true ? true : false;
+    //enables/disables editable table feature
+    this.editable = f.editable===true ? true : false;
+    this.ezEditTableConfig = f.ezEditTable_config || {};
+    this.ezEditTableConfig.name =
+        this.ezEditTableConfig['name']!==undefined ?
+        f.ezEditTable_config.name : 'ezedittable';
+    this.ezEditTableConfig.src = this.ezEditTableConfig['src']!==undefined ?
+        f.ezEditTable_config.src :
+        this.basePath+'ezEditTable/ezEditTable.js';
+    //ezEditTable stylesheet not imported by default as filtergrid.css
+    //applies
+    this.ezEditTableConfig.loadStylesheet =
+        this.ezEditTableConfig['loadStylesheet']===true ? true : false;
+    this.ezEditTableConfig.stylesheet =
+        this.ezEditTableConfig['stylesheet'] ||
+        this.basePath+'ezEditTable/ezEditTable.css';
+    this.ezEditTableConfig.stylesheetName =
+        this.ezEditTableConfig['stylesheetName']!==undefined ?
+        f.ezEditTable_config.stylesheetName : 'ezEditTableCss';
+    this.ezEditTableConfig.err = 'Failed to instantiate EditTable ' +
+        'object.\n"ezEditTable" module may not be available.';
+
+    /*** onkeyup event ***/
+    //enables/disables onkeyup event, table is filtered when user stops
+    //typing
+    this.onKeyUp = f.on_keyup===true ? true : false;
+    //onkeyup delay timer (msecs)
+    this.onKeyUpDelay = !isNaN(f.on_keyup_delay) ?
+        f.on_keyup_delay : 900;
+    this.isUserTyping = null; //typing indicator
+    this.onKeyUpTimer = undefined;
+
+    /*** keyword highlighting ***/
+    //enables/disables keyword highlighting
+    this.highlightKeywords = f.highlight_keywords===true ? true : false;
+
+    /*** data types ***/
+    //defines default date type (european DMY)
+    this.defaultDateType = f.default_date_type || 'DMY';
+    //defines default thousands separator
+    //US = ',' EU = '.'
+    this.thousandsSeparator = f.thousands_separator || ',';
+    //defines default decimal separator
+    //US & javascript = '.' EU = ','
+    this.decimalSeparator = f.decimal_separator || '.';
+    //enables number format per column
+    this.hasColNbFormat = f.col_number_format===true ? true : false;
+    //array containing columns nb formats
+    this.colNbFormat = types.isArray(this.hasColNbFormat) ?
+        f.col_number_format : null;
+    //enables date type per column
+    this.hasColDateType = f.col_date_type===true ? true : false;
+    //array containing columns date type
+    this.colDateType = types.isArray(this.hasColDateType) ?
+        f.col_date_type : null;
+
+    /*** status messages ***/
+    //filtering
+    this.msgFilter = f.msg_filter || 'Filtering data...';
+    //populating drop-downs
+    this.msgPopulate = f.msg_populate || 'Populating filter...';
+    //populating drop-downs
+    this.msgPopulateCheckList = f.msg_populate_checklist ||
+        'Populating list...';
+    //changing paging page
+    this.msgChangePage = f.msg_change_page || 'Collecting paging data...';
+    //clearing filters
+    this.msgClear = f.msg_clear || 'Clearing filters...';
+    //changing nb results/page
+    this.msgChangeResults = f.msg_change_results ||
+        'Changing results per page...';
+    //re-setting grid values
+    this.msgResetValues = f.msg_reset_grid_values ||
+        'Re-setting filters values...';
+    //re-setting page
+    this.msgResetPage = f.msg_reset_page || 'Re-setting page...';
+    //re-setting page length
+    this.msgResetPageLength = f.msg_reset_page_length ||
+        'Re-setting page length...';
+    //table sorting
+    this.msgSort = f.msg_sort || 'Sorting data...';
+    //extensions loading
+    this.msgLoadExtensions = f.msg_load_extensions ||
+        'Loading extensions...';
+    //themes loading
+    this.msgLoadThemes = f.msg_load_themes || 'Loading theme(s)...';
+
+    /*** ids prefixes ***/
+    //css class name added to table
+    this.prfxTf = 'TF';
+    //filters (inputs - selects)
+    this.prfxFlt = 'flt';
+    //validation button
+    this.prfxValButton = 'btn';
+    //container div for paging elements, rows counter etc.
+    this.prfxInfDiv = 'inf_';
+    //left div
+    this.prfxLDiv = 'ldiv_';
+    //right div
+    this.prfxRDiv = 'rdiv_';
+    //middle div
+    this.prfxMDiv = 'mdiv_';
+    //table container if fixed headers enabled
+    this.prfxContentDiv = 'cont_';
+    //checklist filter container div
+    this.prfxCheckListDiv = 'chkdiv_';
+    //pages select
+    this.prfxSlcPages = 'slcPages_';
+    //results per page select
+    this.prfxSlcResults = 'slcResults_';
+    //label preciding results per page select
+    this.prfxSlcResultsTxt = 'slcResultsTxt_';
+    //span containing next page button
+    this.prfxBtnNextSpan = 'btnNextSpan_';
+    //span containing previous page button
+    this.prfxBtnPrevSpan = 'btnPrevSpan_';
+    //span containing last page button
+    this.prfxBtnLastSpan = 'btnLastSpan_';
+    //span containing first page button
+    this.prfxBtnFirstSpan = 'btnFirstSpan_';
+    //next button
+    this.prfxBtnNext = 'btnNext_';
+    //previous button
+    this.prfxBtnPrev = 'btnPrev_';
+    //last button
+    this.prfxBtnLast = 'btnLast_';
+    //first button
+    this.prfxBtnFirst = 'btnFirst_';
+    //span for tot nb pages
+    this.prfxPgSpan = 'pgspan_';
+    //span preceding pages select (contains 'Page')
+    this.prfxPgBeforeSpan = 'pgbeforespan_';
+    //span following pages select (contains ' of ')
+    this.prfxPgAfterSpan = 'pgafterspan_';
+    //rows counter div
+    this.prfxCounter = 'counter_';
+    //nb displayed rows label
+    this.prfxTotRows = 'totrows_span_';
+    //label preceding nb rows label
+    this.prfxTotRowsTxt = 'totRowsTextSpan_';
+    //span containing reset button
+    this.prfxResetSpan = 'resetspan_';
+    //loader div
+    this.prfxLoader = 'load_';
+    //status bar div
+    this.prfxStatus = 'status_';
+    //status bar label
+    this.prfxStatusSpan = 'statusSpan_';
+    //text preceding status bar label
+    this.prfxStatusTxt = 'statusText_';
+    //filter values cookie
+    this.prfxCookieFltsValues = 'tf_flts_';
+    //page nb cookie
+    this.prfxCookiePageNb = 'tf_pgnb_';
+    //page length cookie
+    this.prfxCookiePageLen = 'tf_pglen_';
+    //div containing grid elements if grid_layout true
+    this.prfxMainTblCont = 'gridCont_';
+    //div containing table if grid_layout true
+    this.prfxTblCont = 'tblCont_';
+    //div containing headers table if grid_layout true
+    this.prfxHeadTblCont = 'tblHeadCont_';
+    //headers' table if grid_layout true
+    this.prfxHeadTbl = 'tblHead_';
+    //id of td containing the filter if grid_layout true
+    this.prfxGridFltTd = '_td_';
+    //id of th containing column header if grid_layout true
+    this.prfxGridTh = 'tblHeadTh_';
+    //id prefix for help elements
+    this.prfxHelpSpan = 'helpSpan_';
+    //id prefix for help elements
+    this.prfxHelpDiv = 'helpDiv_';
+    //id prefix for pop-up filter span
+    this.prfxPopUpSpan = 'popUpSpan_';
+    //id prefix for pop-up div containing filter
+    this.prfxPopUpDiv = 'popUpDiv_';
+
+    /*** cookies ***/
+    this.hasStoredValues = false;
+    //remembers filters values on page load
+    this.rememberGridValues = f.remember_grid_values===true ?
+        true : false;
+    //cookie storing filter values
+    this.fltsValuesCookie = this.prfxCookieFltsValues + this.id;
+    //remembers page nb on page load
+    this.rememberPageNb = this.paging && f.remember_page_number ?
+        true : false;
+    //cookie storing page nb
+    this.pgNbCookie = this.prfxCookiePageNb + this.id;
+    //remembers page length on page load
+    this.rememberPageLen = this.paging && f.remember_page_length ?
+        true : false;
+    //cookie storing page length
+    this.pgLenCookie = this.prfxCookiePageLen + this.id;
+
+    /*** extensions ***/
+    //imports external script
+    this.hasExtensions = f.extensions===true ? true : false;
+    this.extensions = this.hasExtensions ? f.extensions : null;
+
+    /*** themes ***/
+    this.enableDefaultTheme = f.enable_default_theme===true ?
+        true : false;
+    //imports themes
+    this.hasThemes = (f.enable_default_theme ||
+        (f.themes && types.isObj(f.themes))) ? true : false;
+    this.themes = this.hasThemes ? f.themes : null;
+    //themes path
+    this.themesPath = f.themes_path || this.basePath+'TF_Themes/';
+
+    // Components
+    this.Cpt = {
+        loader: null,
+        alternateRows: null,
+        colOps: null,
+        rowsCounter: null,
+        gridLayout: null,
+        store: null,
+        highlightKeywords: null,
+        paging: null,
+        checkList: null,
+        dropdown: null,
+        popupFilter: null,
+        clearButton: null,
+        help: null,
+        statusBar: null
+    };
+
+    /*** TF events ***/
+    var o = this;
+    this.Evt = {
+        name: {
+            filter: 'Filter',
+            dropdown: 'dropdown',
+            checklist: 'checkList',
+            changepage: 'changePage',
+            clear: 'Clear',
+            changeresultsperpage: 'changeResults',
+            resetvalues: 'ResetValues',
+            resetpage: 'resetPage',
+            resetpagelength: 'resetPageLength',
+            sort: 'Sort',
+            loadextensions: 'LoadExtensions',
+            loadthemes: 'LoadThemes'
+        },
+        getKeyCode: function(evt){
+            return evt.charCode ? evt.charCode :
+                (evt.keyCode ? evt.keyCode: (evt.which ? evt.which : 0));
+        },
+        /*====================================================
+            - Detects <enter> key for a given element
+        =====================================================*/
+        _DetectKey: function(e) {
+            if(!o.enterKey){ return; }
+            var _evt = e || global.event;
+            if(_evt){
+                var key = o.Evt.getKeyCode(_evt);
+                if(key===13){
+                    o._filter();
+                    evt.cancel(_evt);
+                    evt.stop(_evt);
+                } else {
+                    o.isUserTyping = true;
+                    global.clearInterval(o.onKeyUpTimer);
+                    o.onKeyUpTimer = undefined;
+                }
+            }//if evt
+        },
+        /*====================================================
+            - onkeyup event for text filters
+        =====================================================*/
+        _OnKeyUp: function(e) {
+            if(!o.onKeyUp){
+                return;
+            }
+            var _evt = e || global.event;
+            var key = o.Evt.getKeyCode(_evt);
+            o.isUserTyping = false;
+
+            function filter() {
+                global.clearInterval(o.onKeyUpTimer);
+                o.onKeyUpTimer = undefined;
+                if(!o.isUserTyping){
+                    o.filter();
+                    o.isUserTyping = null;
+                }
+            }
+
+            if(key!==13 && key!==9 && key!==27 && key!==38 && key!==40) {
+                if(o.onKeyUpTimer===undefined){
+                    o.onKeyUpTimer = global.setInterval(filter, o.onKeyUpDelay);
+                }
+            } else {
+                global.clearInterval(o.onKeyUpTimer);
+                o.onKeyUpTimer = undefined;
+            }
+        },
+        /*====================================================
+            - onkeydown event for input filters
+        =====================================================*/
+        _OnKeyDown: function(e) {
+            if(!o.onKeyUp) { return; }
+            o.isUserTyping = true;
+        },
+        /*====================================================
+            - onblur event for input filters
+        =====================================================*/
+        _OnInpBlur: function(e) {
+            if(o.onKeyUp){
+                o.isUserTyping = false;
+                global.clearInterval(o.onKeyUpTimer);
+            }
+            if(o.ezEditTable){
+                if(o.editable){
+                    o.ezEditTable.Editable.Set();
+                }
+                if(o.selectable){
+                    o.ezEditTable.Selection.Set();
+                }
+            }
+        },
+        /*====================================================
+            - onfocus event for input filters
+        =====================================================*/
+        _OnInpFocus: function(e) {
+            var _evt = e || global.event;
+            o.activeFilterId = this.getAttribute('id');
+            o.activeFlt = dom.id(o.activeFilterId);
+            if(o.popUpFilters){
+                evt.cancel(_evt);
+                evt.stop(_evt);
+            }
+            if(o.ezEditTable){
+                if(o.editable){
+                    o.ezEditTable.Editable.Remove();
+                }
+                if(o.selectable){
+                    o.ezEditTable.Selection.Remove();
+                }
+            }
+        },
+        /*====================================================
+            - onfocus event for select filters
+        =====================================================*/
+        _OnSlcFocus: function(e) {
+            var _evt = e || global.event;
+            o.activeFilterId = this.getAttribute('id');
+            o.activeFlt = dom.id(o.activeFilterId);
+            // select is populated when element has focus
+            if(o.fillSlcOnDemand && this.getAttribute('filled') === '0'){
+                var ct = this.getAttribute('ct');
+                o.Cpt.dropdown._build(ct);
+            }
+            if(o.popUpFilters){
+                evt.cancel(_evt);
+                evt.stop(_evt);
+            }
+        },
+        /*====================================================
+            - onchange event for select filters
+        =====================================================*/
+        _OnSlcChange: function(e) {
+            if(!o.activeFlt){ return; }
+            var colIndex = o.activeFlt.getAttribute('colIndex');
+            //Checks filter is a checklist and caller is not null
+            // if(o.activeFlt && colIndex &&
+            //     o['col'+colIndex]===o.fltTypeCheckList &&
+            //     !o.Evt._OnSlcChange.caller){ return; }
+            var _evt = e || global.event;
+            if(o.popUpFilters){ evt.stop(_evt); }
+            if(o.onSlcChange){ o.filter(); }
+        },
+        /*====================================================
+            - onblur event for select filters
+        =====================================================*/
+        _OnSlcBlur: function(e) {},
+        /*====================================================
+            - onclick event for checklist filters
+        =====================================================*/
+        _OnCheckListClick: function() {
+            if(o.fillSlcOnDemand && this.getAttribute('filled') === '0'){
+                var ct = this.getAttribute('ct');
+                o.Cpt.checkList._build(ct);
+                o.Cpt.checkList.checkListDiv[ct].onclick = null;
+                o.Cpt.checkList.checkListDiv[ct].title = '';
+            }
+        },
+        /*====================================================
+            - onclick event for checklist filter container
+        =====================================================*/
+        _OnCheckListFocus: function(e) {
+            o.activeFilterId = this.firstChild.getAttribute('id');
+            o.activeFlt = dom.id(o.activeFilterId);
+        },
+        _OnCheckListBlur: function(e){},
+        /*====================================================
+            - onclick event for validation button
+            (btn property)
+        =====================================================*/
+        _OnBtnClick: function() {
+            o.filter();
+        },
+        _OnSlcPagesChangeEvt: null, //used by sort adapter
+        /*====================================================
+            - onclick event slc parent node (enables filters)
+            IE only
+        =====================================================*/
+        _EnableSlc: function() {
+            this.firstChild.disabled = false;
+            this.firstChild.focus();
+            this.onclick = null;
+        },
+
+        _Paging: { //used by sort adapter
+            nextEvt: null,
+            prevEvt: null,
+            lastEvt: null,
+            firstEvt: null
+        }
+    };
+}
+
+TableFilter.prototype = {
+    /*====================================================
+        - initialises filtering grid bar behaviours and
+        layout
+    =====================================================*/
+    init: function(){
+        if(this._hasGrid){
+            return;
+        }
+        if(!this.tbl){
+            this.tbl = dom.id(this.id);
+        }
+        if(this.gridLayout){
+            this.refRow = this.startRow===null ? 0 : this.startRow;
+        }
+        if(this.popUpFilters &&
+            ((this.filtersRowIndex === 0 && this.headersRow === 1) ||
+            this.gridLayout)){
+            this.headersRow = 0;
+        }
+        var f = this.cfg,
+            n = this.singleSearchFlt ? 1 : this.nbCells,
+            inpclass;
+
+        if(window['tf_'+this.id] === undefined){
+            window['tf_'+this.id] = this;
+        }
+
+        //loads stylesheet if not imported
+        //Issues with browsers != IE, IE rules in this case
+        this.includeFile(this.stylesheetId, this.stylesheet, null, 'link');
+
+        //loads theme
+        if(this.hasThemes){ this._LoadThemes(); }
+
+        if(this.rememberGridValues || this.rememberPageNb ||
+            this.rememberPageLen){
+            var Store = require('modules/store').Store;
+            this.Cpt.store = new Store(this);
+        }
+
+        if(this.gridLayout){
+            var GridLayout = require('modules/gridLayout').GridLayout;
+            this.Cpt.gridLayout = new GridLayout(this);
+            this.Cpt.gridLayout.init();
+        }
+
+        if(this.loader){
+            if(!this.Cpt.loader){
+                var Loader = require('modules/loader').Loader;
+                this.Cpt.loader = new Loader(this);
+            }
+        }
+
+        if(this.highlightKeywords){
+            var Highlight =
+                require('modules/highlightKeywords').HighlightKeyword;
+            this.Cpt.highlightKeyword = new Highlight(this);
+        }
+
+        if(this.popUpFilters){
+            if(!this.Cpt.popupFilter){
+                var PopupFilter = require('modules/popupFilter').PopupFilter;
+                this.Cpt.popupFilter = new PopupFilter(this);
+            }
+            this.Cpt.popupFilter.init();
+        }
+
+        //filters grid is not generated
+        if(!this.fltGrid){
+            this.refRow = this.refRow-1;
+            if(this.gridLayout){
+                this.refRow = 0;
+            }
+            this.nbFilterableRows = this.getRowsNb();
+            this.nbVisibleRows = this.nbFilterableRows;
+            this.nbRows = this.nbFilterableRows + this.refRow;
+        } else {
+            if(this.isFirstLoad){
+                var fltrow;
+                if(!this.gridLayout){
+                    var thead = dom.tag(this.tbl,'thead');
+                    if(thead.length > 0){
+                        fltrow = thead[0].insertRow(this.filtersRowIndex);
+                    } else {
+                        fltrow = this.tbl.insertRow(this.filtersRowIndex);
+                    }
+
+                    if(this.headersRow > 1 &&
+                        this.filtersRowIndex <= this.headersRow &&
+                        !this.popUpFilters){
+                        this.headersRow++;
+                    }
+                    if(this.popUpFilters){
+                        this.headersRow++;
+                    }
+
+                    fltrow.className = this.fltsRowCssClass;
+                    //Disable for grid_layout
+                    if(this.isExternalFlt &&
+                        (!this.gridLayout || this.popUpFilters)){
+                        fltrow.style.display = 'none';
+                    }
+                }
+
+                this.nbFilterableRows = this.getRowsNb();
+                this.nbVisibleRows = this.nbFilterableRows;
+                this.nbRows = this.tbl.rows.length;
+
+                for(var i=0; i<n; i++){// this loop adds filters
+
+                    if(this.popUpFilters){
+                        this.Cpt.popupFilter.build(i);
+                    }
+
+                    var fltcell = dom.create(this.fltCellTag),
+                        col = this['col'+i],
+                        externalFltTgtId =
+                            this.isExternalFlt && this.externalFltTgtIds ?
+                            this.externalFltTgtIds[i] : null;
+
+                    if(this.singleSearchFlt){
+                        fltcell.colSpan = this.nbCells;
+                    }
+                    if(!this.gridLayout){
+                        fltrow.appendChild(fltcell);
+                    }
+                    inpclass = (i==n-1 && this.displayBtn) ?
+                        this.fltSmallCssClass : this.fltCssClass;
+
+                    if(col===undefined){
+                        col = f['col_'+i]===undefined ?
+                            this.fltTypeInp : str.lower(f['col_'+i]);
+                    }
+
+                    //only 1 input for single search
+                    if(this.singleSearchFlt){
+                        col = this.fltTypeInp;
+                        inpclass = this.singleFltCssClass;
+                    }
+
+                    //drop-down filters
+                    if(col===this.fltTypeSlc || col===this.fltTypeMulti){
+                        if(!this.Cpt.dropdown){
+                            var Dropdown = require('modules/dropdown').Dropdown;
+                            this.Cpt.dropdown = new Dropdown(this);
+                        }
+                        var dropdown = this.Cpt.dropdown;
+
+                        var slc = dom.create(this.fltTypeSlc,
+                                ['id', this.prfxFlt+i+'_'+this.id],
+                                ['ct', i], ['filled', '0']
+                            );
+
+                        if(col===this.fltTypeMulti){
+                            slc.multiple = this.fltTypeMulti;
+                            slc.title = dropdown.multipleSlcTooltip;
+                        }
+                        slc.className = str.lower(col)===this.fltTypeSlc ?
+                            inpclass : this.fltMultiCssClass;// for ie<=6
+
+                        //filter is appended in desired external element
+                        if(externalFltTgtId){
+                            dom.id(externalFltTgtId).appendChild(slc);
+                            this.externalFltEls.push(slc);
+                        } else {
+                            fltcell.appendChild(slc);
+                        }
+
+                        this.fltIds.push(this.prfxFlt+i+'_'+this.id);
+
+                        if(!this.fillSlcOnDemand){
+                            dropdown._build(i);
+                        }
+
+                        evt.add(slc, 'keypress', this.Evt._DetectKey);
+                        evt.add(slc, 'change', this.Evt._OnSlcChange);
+                        evt.add(slc, 'focus', this.Evt._OnSlcFocus);
+                        evt.add(slc, 'blur', this.Evt._OnSlcBlur);
+
+                        //1st option is created here since dropdown.build isn't
+                        //invoked
+                        if(this.fillSlcOnDemand){
+                            var opt0 = dom.createOpt(this.displayAllText, '');
+                            slc.appendChild(opt0);
+                        }
+                    }
+                    // checklist
+                    else if(col===this.fltTypeCheckList){
+                        if(!this.Cpt.checkList){
+                            var CheckList =
+                                    require('modules/checkList').CheckList;
+                            this.Cpt.checkList = new CheckList(this);
+                        }
+
+                        var divCont = dom.create('div',
+                            ['id',this.prfxCheckListDiv+i+'_'+this.id],
+                            ['ct',i],['filled','0']);
+                        divCont.className =
+                            this.Cpt.checkList.checkListDivCssClass;
+
+                        //filter is appended in desired element
+                        if(externalFltTgtId){
+                            dom.id(externalFltTgtId).appendChild(divCont);
+                            this.externalFltEls.push(divCont);
+                        } else {
+                            fltcell.appendChild(divCont);
+                        }
+
+                        this.Cpt.checkList.checkListDiv[i] = divCont;
+                        this.fltIds.push(this.prfxFlt+i+'_'+this.id);
+                        if(!this.fillSlcOnDemand){
+                            this.Cpt.checkList._build(i);
+                        }
+
+                        if(this.fillSlcOnDemand){
+                            evt.add(
+                                divCont, 'click', this.Evt._OnCheckListClick);
+                            divCont.appendChild(
+                                dom.text(
+                                    this.Cpt.checkList.activateCheckListTxt));
+                        }
+
+                        evt.add(divCont, 'click', this.Evt._OnCheckListFocus);
+                    }
+
+                    else{
+                        //show/hide input
+                        var inptype = col===this.fltTypeInp ? 'text' : 'hidden';
+                        var inp = dom.create(this.fltTypeInp,
+                            ['id',this.prfxFlt+i+'_'+this.id],
+                            ['type',inptype],['ct',i]);
+                        if(inptype!=='hidden' && this.watermark){
+                            inp.setAttribute(
+                                'placeholder',
+                                this.isWatermarkArray ?
+                                    this.watermark[i] : this.watermark
+                            );
+                        }
+                        inp.className = inpclass;
+                        inp.onfocus = this.Evt._OnInpFocus;
+
+                        //filter is appended in desired element
+                        if(externalFltTgtId){
+                            dom.id(externalFltTgtId).appendChild(inp);
+                            this.externalFltEls.push(inp);
+                        } else {
+                            fltcell.appendChild(inp);
+                        }
+
+                        this.fltIds.push(this.prfxFlt+i+'_'+this.id);
+
+                        inp.onkeypress = this.Evt._DetectKey;
+                        inp.onkeydown = this.Evt._OnKeyDown;
+                        inp.onkeyup = this.Evt._OnKeyUp;
+                        inp.onblur = this.Evt._OnInpBlur;
+
+                        if(this.rememberGridValues){
+                            var flts_values = this.Cpt.store.getFilterValues(
+                                this.fltsValuesCookie);
+                            if(flts_values[i]!=' '){
+                                this.setFilterValue(i,flts_values[i],false);
+                            }
+                        }
+                    }
+                    // this adds submit button
+                    if(i==n-1 && this.displayBtn){
+                        var btn = dom.create(this.fltTypeInp,
+                            ['id',this.prfxValButton+i+'_'+this.id],
+                            ['type','button'], ['value',this.btnText]);
+                        btn.className = this.btnCssClass;
+
+                        //filter is appended in desired element
+                        if(externalFltTgtId){
+                            dom.id(externalFltTgtId).appendChild(btn);
+                        } else{
+                            fltcell.appendChild(btn);
+                        }
+
+                        btn.onclick = this.Evt._OnBtnClick;
+                    }//if
+
+                }// for i
+
+            } else {
+                this._resetGrid();
+            }//if isFirstLoad
+
+        }//if this.fltGrid
+
+        /* Filter behaviours */
+        if(this.rowsCounter){
+            var RowsCounter = require('modules/rowsCounter').RowsCounter;
+            this.Cpt.rowsCounter = new RowsCounter(this);
+            this.Cpt.rowsCounter.init();
+        }
+        if(this.statusBar){
+            // this.SetStatusBar();
+            var StatusBar = require('modules/statusBar').StatusBar;
+            this.Cpt.statusBar = new StatusBar(this);
+            this.Cpt.statusBar.init();
+        }
+        if(this.paging){
+            var Paging = require('modules/paging').Paging;
+            this.Cpt.paging = new Paging(this);
+            this.Cpt.paging.init();
+        }
+        if(this.btnReset){
+            var ClearButton = require('modules/clearButton').ClearButton;
+            this.Cpt.clearButton = new ClearButton(this);
+            this.Cpt.clearButton.init();
+        }
+        if(this.helpInstructions){
+            var Help = require('modules/help').Help;
+            this.Cpt.help = new Help(this);
+            this.Cpt.help.init();
+        }
+        if(this.hasColWidth && !this.gridLayout){
+            this.setColWidths();
+        }
+        if(this.alternateBgs){
+            //1st time only if no paging and rememberGridValues
+            var AlternateRows = require('modules/alternateRows').AlternateRows;
+            this.Cpt.alternateRows = new AlternateRows(this);
+            this.Cpt.alternateRows.init();
+        }
+        if(this.hasColOperation){
+            var ColOps = require('modules/colOps').ColOps;
+            this.Cpt.colOps = new ColOps(this);
+            this.Cpt.colOps.calc();
+        }
+        if(this.sort || this.gridLayout){
+            this.SetSort();
+        }
+        if(this.selectable || this.editable){
+            this.SetEditable();
+        }
+
+        this.isFirstLoad = false;
+        this._hasGrid = true;
+
+        if(this.rememberGridValues || this.rememberPageLen ||
+            this.rememberPageNb){
+            this.resetValues();
+        }
+
+        //TF css class is added to table
+        if(!this.gridLayout){
+            dom.addClass(this.tbl, this.prfxTf);
+        }
+
+        if(this.loader){
+            this.Cpt.loader.show('none');
+        }
+
+        /* Loads extensions */
+        if(this.hasExtensions){
+            this.LoadExtensions();
+        }
+
+        if(this.onFiltersLoaded){
+            this.onFiltersLoaded.call(null, this);
+        }
+
+    },// AddGrid
+
+    /*====================================================
+        - TF events manager
+        - Params:
+            - event name (string)
+            - config object (optional literal object)
+    =====================================================*/
+    EvtManager: function(evt, s){
+        var o = this;
+        var slcIndex = s && s.slcIndex!==undefined ? s.slcIndex : null;
+        var slcExternal = s && s.slcExternal!==undefined ?
+            s.slcExternal : false;
+        var slcId = s && s.slcId!==undefined ? s.slcId : null;
+        var pgIndex = s && s.pgIndex!==undefined ? s.pgIndex : null;
+
+        function efx(){
+            if(!evt){ return; }
+            switch(evt){
+                case o.Evt.name.filter:
+                    if(o.isModFilterFn){
+                        o.modFilterFn.call(null,o);
+                    } else {
+                        o._filter();
+                    }
+                break;
+                case o.Evt.name.dropdown:
+                    if(o.linkedFilters){
+                        o.Cpt.dropdown._build(slcIndex, true);
+                    } else {
+                        o.Cpt.dropdown._build(
+                            slcIndex, false, slcExternal, slcId);
+                    }
+                break;
+                case o.Evt.name.checklist:
+                    o.Cpt.checkList._build(slcIndex, slcExternal, slcId);
+                break;
+                case o.Evt.name.changepage:
+                    o.Cpt.paging._changePage(pgIndex);
+                break;
+                case o.Evt.name.clear:
+                    o._clearFilters();
+                    o._filter();
+                break;
+                case o.Evt.name.changeresultsperpage:
+                    o.Cpt.paging._changeResultsPerPage();
+                break;
+                case o.Evt.name.resetvalues:
+                    o._resetValues();
+                    o._filter();
+                break;
+                case o.Evt.name.resetpage:
+                    o.Cpt.paging._resetPage(o.pgNbCookie);
+                break;
+                case o.Evt.name.resetpagelength:
+                    o.Cpt.paging._resetPageLength(o.pgLenCookie);
+                break;
+                case o.Evt.name.sort:
+                    void(0);
+                break;
+                case o.Evt.name.loadextensions:
+                    o._LoadExtensions();
+                break;
+                case o.Evt.name.loadthemes:
+                    o._LoadThemes();
+                break;
+                default: //to be used by extensions events when needed
+                    o['_'+evt].call(null,o,s);
+                break;
+            }
+            if(o.statusBar){
+                o.Cpt.statusBar.message('');
+            }
+            if(o.loader){
+                o.Cpt.loader.show('none');
+            }
+        }
+
+        if(this.loader || this.statusBar) {
+            try{
+                this.Cpt.loader.show('');
+                // this.StatusMsg(o['msg'+evt]);
+                this.Cpt.statusBar.message(this['msg'+evt]);
+            } catch(e){}
+            global.setTimeout(efx, this.execDelay);
+        } else {
+            efx();
+        }
+    },
+
+    ImportModule: function(module){
+        if(!module.path || !module.name){
+            return;
+        }
+        this.includeFile(module.name, module.path, module.init);
+    },
+
+    LoadExtensions : function(){
+        if(!this.Ext){
+            /*** TF extensions ***/
+            var o = this;
+            this.Ext = {
+                list: {},
+                add: function(extName, extDesc, extPath, extCallBack){
+                    var file = extPath.split('/')[extPath.split('/').length-1],
+                        re = new RegExp(file),
+                        path = extPath.replace(re,'');
+                    o.Ext.list[extName] = {
+                        name: extName,
+                        description: extDesc,
+                        file: file,
+                        path: path,
+                        callback: extCallBack
+                    };
+                }
+            };
+        }
+        this.EvtManager(this.Evt.name.loadextensions);
+    },
+
+    /*====================================================
+        - loads TF extensions
+    =====================================================*/
+    _LoadExtensions : function(){
+        if(!this.hasExtensions || !types.isArray(this.extensions.name) ||
+            !types.isArray(this.extensions.src)){
+            return;
+        }
+        var ext = this.extensions;
+        for(var e=0; e<ext.name.length; e++){
+            var extPath = ext.src[e],
+                extName = ext.name[e],
+                extInit = (ext.initialize && ext.initialize[e]) ?
+                    ext.initialize[e] : null,
+                extDesc = (ext.description && ext.description[e] ) ?
+                    ext.description[e] : null;
+
+            //Registers extension
+            this.Ext.add(extName, extDesc, extPath, extInit);
+            if(isImported(extPath)){
+                extInit.call(null,this);
+            } else {
+                this.includeFile(extName, extPath, extInit);
+            }
+        }
+    },
+
+    LoadThemes: function(){
+        this.EvtManager(this.Evt.name.loadthemes);
+    },
+
+    /*====================================================
+        - loads TF themes
+    =====================================================*/
+    _LoadThemes: function(){
+        if(!this.hasThemes){
+            return;
+        }
+        if(!this.Thm){
+            /*** TF themes ***/
+            var o = this;
+            this.Thm = {
+                list: {},
+                add: function(thmName, thmDesc, thmPath, thmCallBack){
+                    var file = thmPath.split('/')[thmPath.split('/').length-1],
+                        re = new RegExp(file),
+                        path = thmPath.replace(re,'');
+                    o.Thm.list[thmName] = {
+                        name: thmName,
+                        description: thmDesc,
+                        file: file,
+                        path: path,
+                        callback: thmCallBack
+                    };
+                }
+            };
+        }
+
+        //Default theme config
+        if(this.enableDefaultTheme){
+            this.themes = {
+                name:['DefaultTheme'],
+                src:[this.themesPath+'Default/TF_Default.css'],
+                description:['Default Theme']
+            };
+            this.Thm.add('DefaultTheme',
+                this.themesPath+'Default/TF_Default.css', 'Default Theme');
+        }
+        if(types.isArray(this.themes.name) &&
+            types.isArray(this.themes.src)){
+            var thm = this.themes;
+            for(var i=0; i<thm.name.length; i++){
+                var thmPath = thm.src[i],
+                    thmName = thm.name[i],
+                    thmInit = (thm.initialize && thm.initialize[i]) ?
+                        thm.initialize[i] : null,
+                    thmDesc = (thm.description && thm.description[i]) ?
+                        thm.description[i] : null;
+
+                //Registers theme
+                this.Thm.add(thmName, thmDesc, thmPath, thmInit);
+
+                if(!isImported(thmPath,'link')){
+                    this.includeFile(thmName, thmPath, null, 'link');
+                }
+                if(types.isFn(thmInit)){
+                    thmInit.call(null,this);
+                }
+            }
+        }
+
+        //Some elements need to be overriden for theme
+        //Reset button
+        this.btnResetText = null;
+        this.btnResetHtml = '<input type="button" value="" class="' +
+            this.btnResetCssClass+'" title="Clear filters" />';
+
+        //Paging buttons
+        this.btnPrevPageHtml = '<input type="button" value="" class="' +
+            this.btnPageCssClass+' previousPage" title="Previous page" />';
+        this.btnNextPageHtml = '<input type="button" value="" class="' +
+            this.btnPageCssClass+' nextPage" title="Next page" />';
+        this.btnFirstPageHtml = '<input type="button" value="" class="' +
+            this.btnPageCssClass+' firstPage" title="First page" />';
+        this.btnLastPageHtml = '<input type="button" value="" class="' +
+            this.btnPageCssClass+' lastPage" title="Last page" />';
+
+        //Loader
+        this.loader = true;
+        this.loaderHtml = '<div class="defaultLoader"></div>';
+        this.loaderText = null;
+    },
+
+    /*====================================================
+        - removes a filter grid
+    =====================================================*/
+    remove: function(){
+        if(this.fltGrid && this._hasGrid){
+            var rows = this.tbl.rows;
+            if(this.paging){
+                this.Cpt.paging.destroy();
+            }
+            if(this.statusBar){
+                // this.RemoveStatusBar();
+                this.Cpt.statusBar.destroy();
+            }
+            if(this.rowsCounter){
+                this.Cpt.rowsCounter.destroy();
+            }
+            if(this.btnReset){
+                // this.RemoveResetBtn();
+                this.Cpt.clearButton.destroy();
+            }
+            if(this.helpInstructions /*|| !this.helpInstructions*/){
+                this.Cpt.help.destroy();
+            }
+            if(this.isExternalFlt && !this.popUpFilters){
+                this.RemoveExternalFlts();
+            }
+            if(this.infDiv){
+                this.removeToolbar();
+            }
+            if(this.highlightKeywords){
+                this.Cpt.highlightKeyword.unhighlightAll();
+            }
+            if(this.sort){
+                this.RemoveSort();
+            }
+            if(this.loader){
+                this.Cpt.loader.remove();
+            }
+            if(this.popUpFilters){
+                this.Cpt.popupFilter.destroy();
+            }
+            if(this.markActiveColumns){
+                this.clearActiveColumns();
+            }
+            if(this.editable || this.selectable){
+                this.RemoveEditable();
+            }
+            //this loop shows all rows and removes validRow attribute
+            for(var j=this.refRow; j<this.nbRows; j++){
+                rows[j].style.display = '';
+                try{
+                    if(rows[j].hasAttribute('validRow')){
+                        rows[j].removeAttribute('validRow');
+                    }
+                } catch(e) {
+                    //ie<=6 doesn't support hasAttribute method
+                    var row = rows[j];
+                    var attribs = row.attributes;
+                    for(var x = 0; x < attribs.length; x++){
+                        if(str.lower(attribs.nodeName)==='validrow'){
+                            row.removeAttribute('validRow');
+                        }
+                    }
+                }
+
+                //removes alternating colors
+                if(this.alternateBgs){
+                    this.Cpt.alternateRows.removeRowBg(j);
+                }
+
+            }//for j
+
+            if(this.fltGrid && !this.gridLayout){
+                this.fltGridEl = rows[this.filtersRowIndex];
+                this.tbl.deleteRow(this.filtersRowIndex);
+            }
+            if(this.gridLayout){
+                this.Cpt.gridLayout.destroy();
+            }
+            dom.removeClass(this.tbl, this.prfxTf);
+            this.activeFlt = null;
+            this.isStartBgAlternate = true;
+            this._hasGrid = false;
+            this.tbl = null;
+
+        }//if this.fltGrid
+    },
+
+    /*====================================================
+        - Generates div above table where paging,
+        reset button, rows counter label etc. are placed
+    =====================================================*/
+    setToolbar: function(){
+        if(this.infDiv!==null){
+            return;
+        }
+
+        /*** container div ***/
+        var infdiv = dom.create('div', ['id',this.prfxInfDiv+this.id]);
+        infdiv.className = this.infDivCssClass;
+
+        //custom container
+        if(this.toolBarTgtId){
+            dom.id(this.toolBarTgtId).appendChild(infdiv);
+        }
+        //grid-layout
+        else if(this.gridLayout){
+            this.Cpt.gridLayout.tblMainCont.appendChild(infdiv);
+            infdiv.className = this.gridInfDivCssClass;
+        }
+        //default location: just above the table
+        else{
+            this.tbl.parentNode.insertBefore(infdiv, this.tbl);
+        }
+        this.infDiv = dom.id(this.prfxInfDiv+this.id);
+
+        /*** left div containing rows # displayer ***/
+        var ldiv = dom.create('div', ['id',this.prfxLDiv+this.id]);
+        ldiv.className = this.lDivCssClass;
+        infdiv.appendChild(ldiv);
+        this.lDiv = dom.id(this.prfxLDiv+this.id);
+
+        /***    right div containing reset button
+                + nb results per page select    ***/
+        var rdiv = dom.create('div', ['id',this.prfxRDiv+this.id]);
+        rdiv.className = this.rDivCssClass;
+        infdiv.appendChild(rdiv);
+        this.rDiv = dom.id(this.prfxRDiv+this.id);
+
+        /*** mid div containing paging elements ***/
+        var mdiv = dom.create('div', ['id',this.prfxMDiv+this.id]);
+        mdiv.className = this.mDivCssClass;
+        infdiv.appendChild(mdiv);
+        this.mDiv = dom.id(this.prfxMDiv+this.id);
+
+        // Enable help instructions by default is topbar is generated
+        if(!this.helpInstructions){
+            if(!this.Cpt.help){
+                var Help = require('modules/help').Help;
+                this.Cpt.help = new Help(this);
+            }
+            this.Cpt.help.init();
+        }
+    },
+
+    /*====================================================
+        - Removes div above table where paging,
+        reset button, rows counter label etc. are placed
+    =====================================================*/
+    removeToolbar: function(){
+        if(!this.infDiv){
+            return;
+        }
+        this.infDiv.parentNode.removeChild(this.infDiv);
+        this.infDiv = null;
+    },
+
+    /*====================================================
+        - removes external filters
+    =====================================================*/
+    RemoveExternalFlts: function(){
+        if(!this.isExternalFlt && !this.externalFltTgtIds){
+            return;
+        }
+        for(var ct=0; ct<this.externalFltTgtIds.length; ct++){
+            var externalFltTgtId = this.externalFltTgtIds[ct],
+                externalFlt = dom.id(externalFltTgtId);
+            if(externalFlt){
+                externalFlt.innerHTML = '';
+            }
+        }
+    },
+
+    /*====================================================
+        - Sets sorting feature by loading
+        WebFX Sortable Table 1.12 plugin by Erik Arvidsson
+        and TF adapter by Max Guglielmi
+    =====================================================*/
+    SetSort: function(){
+        var fn = this.Evt._EnableSort,
+            sortConfig = this.sortConfig;
+
+        if(!types.isFn(fn)){
+            var o = this;
+            /*====================================================
+                - enables table sorting
+            =====================================================*/
+            this.Evt._EnableSort = function(){
+                //gridLayout needs sort to be re-enabled
+                if(o.isSortEnabled && !o.gridLayout){
+                    return;
+                }
+                if(isImported(sortConfig.adapterSrc)){
+                    sortConfig.initialize.call(null,o);
+                } else {
+                    o.includeFile(
+                        sortConfig.name+'_adapter',
+                        sortConfig.adapterSrc,
+                        function(){ sortConfig.initialize.call(null,o); }
+                    );
+                }
+            };
+        }
+
+        if(isImported(this.sortConfig.src)){
+            this.Evt._EnableSort();
+        } else {
+            this.includeFile(
+                sortConfig.name, sortConfig.src,this.Evt._EnableSort);
+        }
+    },
+
+    /*====================================================
+        - removes sorting feature
+    =====================================================*/
+    RemoveSort: function(){
+        this.sort = false;
+    },
+
+    Sort: function(){
+        this.EvtManager(this.Evt.name.sort);
+    },
+
+    /*====================================================
+        - Sets selection or edition features by loading
+        ezEditTable script by Max Guglielmi
+    =====================================================*/
+    SetEditable: function(){
+        var ezEditConfig = this.ezEditTableConfig;
+        if(isImported(ezEditConfig.src)){
+            this._EnableEditable();
+        } else {
+            this.includeFile(
+                ezEditConfig.name,
+                ezEditConfig.src,
+                this._EnableEditable
+            );
+        }
+        if(ezEditConfig.loadStylesheet &&
+            !isImported(ezEditConfig.stylesheet, 'link')){
+            this.includeFile(
+                ezEditConfig.stylesheetName,
+                ezEditConfig.stylesheet, null, 'link'
+            );
+        }
+    },
+
+    /*====================================================
+        - Removes selection or edition features
+    =====================================================*/
+    RemoveEditable: function(){
+        var ezEditTable = this.ezEditTable;
+        if(ezEditTable){
+            if(this.selectable){
+                ezEditTable.Selection.ClearSelections();
+                ezEditTable.Selection.Remove();
+            }
+            if(this.editable){
+                ezEditTable.Editable.Remove();
+            }
+        }
+    },
+
+    /*====================================================
+        - Resets selection or edition features after
+        removal
+    =====================================================*/
+    ResetEditable: function(){
+        var ezEditTable = this.ezEditTable;
+        if(ezEditTable){
+            if(this.selectable){
+                ezEditTable.Selection.Set();
+            }
+            if(this.editable){
+                ezEditTable.Editable.Set();
+            }
+        }
+    },
+
+    _EnableEditable: function(o){
+        if(!o){
+            o = this;
+        }
+
+        //start row for EditTable constructor needs to be calculated
+        var startRow,
+            ezEditConfig = o.ezEditTableConfig,
+            thead = dom.tag(o.tbl,'thead');
+
+        //if thead exists and startRow not specified, startRow is calculated
+        //automatically by EditTable
+        if(thead.length > 0 && !ezEditConfig.startRow){
+            startRow = undefined;
+        }
+        //otherwise startRow config property if any or TableFilter refRow
+        else{
+            startRow = ezEditConfig.startRow || o.refRow;
+        }
+
+        ezEditConfig.scroll_into_view = ezEditConfig.scroll_into_view===false ?
+            false : true;
+        ezEditConfig.base_path = ezEditConfig.base_path  ||
+            o.basePath + 'ezEditTable/';
+        ezEditConfig.editable = o.editable = o.cfg.editable;
+        ezEditConfig.selection = o.selectable = o.cfg.selectable;
+
+        if(o.selectable){
+            ezEditConfig.default_selection =
+                ezEditConfig.default_selection || 'row';
+        }
+        //CSS Styles
+        ezEditConfig.active_cell_css = ezEditConfig.active_cell_css ||
+            'ezETSelectedCell';
+
+        o._lastValidRowIndex = 0;
+        o._lastRowIndex = 0;
+
+        if(o.selectable){
+            //Row navigation needs to be calculated according to TableFilter's
+            //validRowsIndex array
+            var onAfterSelection = function(et, selectedElm, e){
+                //table is not filtered
+                if(!o.validRowsIndex){
+                    return;
+                }
+                var validIndexes = o.validRowsIndex,
+                    validIdxLen = validIndexes.length,
+                    row = et.defaultSelection !== 'row' ?
+                        selectedElm.parentNode : selectedElm,
+                    //cell for default_selection = 'both' or 'cell'
+                    cell = selectedElm.nodeName==='TD' ? selectedElm : null,
+                    keyCode = e !== undefined ? et.Event.GetKey(e) : 0,
+                    isRowValid = array.has(validIndexes, row.rowIndex),
+                    nextRowIndex,
+                    //pgup/pgdown keys
+                    d = (keyCode === 34 || keyCode === 33 ?
+                        (o.pagingLength || et.nbRowsPerPage) : 1);
+
+                //If next row is not valid, next valid filtered row needs to be
+                //calculated
+                if(!isRowValid){
+                    //Selection direction up/down
+                    if(row.rowIndex>o._lastRowIndex){
+                        //last row
+                        if(row.rowIndex >= validIndexes[validIdxLen-1]){
+                            nextRowIndex = validIndexes[validIdxLen-1];
+                        } else {
+                            var calcRowIndex = (o._lastValidRowIndex + d);
+                            if(calcRowIndex > (validIdxLen-1)){
+                                nextRowIndex = validIndexes[validIdxLen-1];
+                            } else {
+                                nextRowIndex = validIndexes[calcRowIndex];
+                            }
+                        }
+                    } else{
+                        //first row
+                        if(row.rowIndex <= validIndexes[0]){
+                            nextRowIndex = validIndexes[0];
+                        } else {
+                            var v = validIndexes[o._lastValidRowIndex - d];
+                            nextRowIndex = v ? v : validIndexes[0];
+                        }
+                    }
+                    o._lastRowIndex = row.rowIndex;
+                    DoSelection(nextRowIndex);
+                } else {
+                    //If filtered row is valid, special calculation for
+                    //pgup/pgdown keys
+                    if(keyCode!==34 && keyCode!==33){
+                        o._lastValidRowIndex = array.indexByValue(validIndexes,
+                            row.rowIndex);
+                        o._lastRowIndex = row.rowIndex;
+                    } else {
+                        if(keyCode === 34){ //pgdown
+                            //last row
+                            if((o._lastValidRowIndex + d) <= (validIdxLen-1)){
+                                nextRowIndex = validIndexes[
+                                o._lastValidRowIndex + d];
+                            } else {
+                                nextRowIndex = [validIdxLen-1];
+                            }
+                        } else { //pgup
+                            //first row
+                            if((o._lastValidRowIndex - d) <= validIndexes[0]){
+                                nextRowIndex = validIndexes[0];
+                            } else {
+                                nextRowIndex = validIndexes[
+                                    o._lastValidRowIndex - d];
+                            }
+                        }
+                        o._lastRowIndex = nextRowIndex;
+                        o._lastValidRowIndex = array.indexByValue(validIndexes,
+                            nextRowIndex);
+                        DoSelection(nextRowIndex);
+                    }
+                }
+
+                //Next valid filtered row needs to be selected
+                var DoSelection = function(nextRowIndex){
+                    if(et.defaultSelection === 'row'){
+                        et.Selection.SelectRowByIndex(nextRowIndex);
+                    } else {
+                        et.ClearSelections();
+                        var cellIndex = selectedElm.cellIndex,
+                            row = o.tbl.rows[nextRowIndex];
+                        if(et.defaultSelection === 'both'){
+                            et.Selection.SelectRowByIndex(nextRowIndex);
+                        }
+                        if(row){
+                            et.Selection.SelectCell(row.cells[cellIndex]);
+                        }
+                    }
+                    //Table is filtered
+                    if(o.validRowsIndex.length !== o.getRowsNb()){
+                        var r = o.tbl.rows[nextRowIndex];
+                        if(r){
+                            r.scrollIntoView(false);
+                        }
+                        if(cell){
+                            if(cell.cellIndex===(o.getCellsNb()-1) &&
+                                o.gridLayout){
+                                o.tblCont.scrollLeft = 100000000;
+                            }
+                            else if(cell.cellIndex===0 && o.gridLayout){
+                                o.tblCont.scrollLeft = 0;
+                            } else {
+                                cell.scrollIntoView(false);
+                            }
+                        }
+                    }
+                };
+            };
+
+            //Page navigation has to be enforced whenever selected row is out of
+            //the current page range
+            var onBeforeSelection = function(et, selectedElm, e){
+                var row = et.defaultSelection !== 'row' ?
+                    selectedElm.parentNode : selectedElm;
+                if(o.paging){
+                    if(o.nbPages>1){
+                        //page length is re-assigned in case it has changed
+                        et.nbRowsPerPage = o.pagingLength;
+                        var validIndexes = o.validRowsIndex,
+                            validIdxLen = validIndexes.length,
+                            pagingEndRow = parseInt(o.startPagingRow, 10) +
+                            parseInt(o.pagingLength, 10);
+                        var rowIndex = row.rowIndex;
+                        if((rowIndex === validIndexes[validIdxLen-1]) &&
+                            o.currentPageNb!=o.nbPages){
+                            // o.SetPage('last');
+                            o.Cpt.paging.setPage('last');
+                        }
+                        else if((rowIndex == validIndexes[0]) &&
+                            o.currentPageNb!==1){
+                            // o.SetPage('first');
+                            o.Cpt.paging.setPage('first');
+                        }
+                        else if(rowIndex > validIndexes[pagingEndRow-1] &&
+                            rowIndex < validIndexes[validIdxLen-1]){
+                            // o.SetPage('next');
+                            o.Cpt.paging.setPage('next');
+                        }
+                        else if(rowIndex < validIndexes[o.startPagingRow] &&
+                            rowIndex > validIndexes[0]){
+                            // o.SetPage('previous');
+                            o.Cpt.paging.setPage('previous');
+                        }
+                    }
+                }
+            };
+
+            //Selected row needs to be visible when paging is activated
+            if(o.paging){
+                o.onAfterChangePage = function(tf, i){
+                    var et = tf.ezEditTable;
+                    var row = et.Selection.GetActiveRow();
+                    if(row){
+                        row.scrollIntoView(false);
+                    }
+                    var cell = et.Selection.GetActiveCell();
+                    if(cell){
+                        cell.scrollIntoView(false);
+                    }
+                };
+            }
+
+            //Rows navigation when rows are filtered is performed with the
+            //EditTable row selection callback events
+            if(ezEditConfig.default_selection==='row'){
+                var fnB = ezEditConfig.on_before_selected_row;
+                ezEditConfig.on_before_selected_row = function(){
+                    onBeforeSelection(arguments[0], arguments[1], arguments[2]);
+                    if(fnB){
+                        fnB.call(
+                            null, arguments[0], arguments[1], arguments[2]);
+                    }
+                };
+                var fnA = ezEditConfig.on_after_selected_row;
+                ezEditConfig.on_after_selected_row = function(){
+                    onAfterSelection(arguments[0], arguments[1], arguments[2]);
+                    if(fnA){
+                        fnA.call(
+                            null, arguments[0], arguments[1], arguments[2]);
+                    }
+                };
+            } else {
+                var fnD = ezEditConfig.on_before_selected_cell;
+                ezEditConfig.on_before_selected_cell = function(){
+                    onBeforeSelection(arguments[0], arguments[1], arguments[2]);
+                    if(fnD){
+                        fnD.call(
+                            null, arguments[0], arguments[1], arguments[2]);
+                    }
+                };
+                var fnC = ezEditConfig.on_after_selected_cell;
+                ezEditConfig.on_after_selected_cell = function(){
+                    onAfterSelection(arguments[0], arguments[1], arguments[2]);
+                    if(fnC){
+                        fnC.call(
+                            null, arguments[0], arguments[1], arguments[2]);
+                    }
+                };
+            }
+        }
+        if(o.editable){
+            //Added or removed rows, TF rows number needs to be re-calculated
+            var fnE = ezEditConfig.on_added_dom_row;
+            ezEditConfig.on_added_dom_row = function(){
+                o.nbFilterableRows++;
+                if(!o.paging){
+                    o.Cpt.rowsCounter.refresh();
+                } else {
+                    o.nbRows++;
+                    o.nbVisibleRows++;
+                    o.nbFilterableRows++;
+                    o.paging=false;
+                    o.Cpt.paging.destroy();
+                    o.Cpt.paging.addPaging();
+                }
+                if(o.alternateBgs){
+                    o.Cpt.alternateRows.init();
+                }
+                if(fnE){
+                    fnE.call(null, arguments[0], arguments[1], arguments[2]);
+                }
+            };
+            if(ezEditConfig.actions && ezEditConfig.actions['delete']){
+                var fnF = ezEditConfig.actions['delete'].on_after_submit;
+                ezEditConfig.actions['delete'].on_after_submit = function(){
+                    o.nbFilterableRows--;
+                    if(!o.paging){
+                        o.Cpt.rowsCounter.refresh();
+                    } else {
+                        o.nbRows--;
+                        o.nbVisibleRows--;
+                        o.nbFilterableRows--;
+                        o.paging=false;
+                        o.Cpt.paging.destroy();
+                        o.Cpt.paging.addPaging(false);
+                    }
+                    if(o.alternateBgs){
+                        o.Cpt.alternateRows.init();
+                    }
+                    if(fnF){
+                        fnF.call(null, arguments[0], arguments[1]);
+                    }
+                };
+            }
+        }
+
+        try{
+            o.ezEditTable = new EditTable(o.id, ezEditConfig, startRow);
+            o.ezEditTable.Init();
+        } catch(e) { console.log(ezEditConfig.err); }
+    },
+
+    /*====================================================
+        - IE bug: it seems there is no way to make
+        multiple selections programatically, only last
+        selection is kept (multiple select previously
+        populated via DOM)
+        - Work-around: defer selection with a setTimeout
+        If you find a more elegant solution to
+        this let me know ;-)
+        - For the moment only this solution seems to work!
+        - Params:
+            - slc = select object (select obj)
+            - index to be selected (integer)
+            - execute filtering (boolean)
+    =====================================================*/
+    // __deferMultipleSelection: function(slc,index,filter){
+    //     if(str.lower(slc.nodeName)!=='select'){
+    //         return;
+    //     }
+    //     var doFilter = filter===undefined ? false : filter;
+    //     var o = this;
+    //     global.setTimeout(function(){
+    //         slc.options[0].selected = false;
+
+    //         if(slc.options[index].value===''){
+    //             slc.options[index].selected = false;
+    //         }
+    //         else{
+    //             slc.options[index].selected = true;
+    //             if(doFilter){
+    //                 o.filter();
+    //             }
+    //         }
+    //     }, 0.1);
+    // },
+
+    /*====================================================
+        - Returns an array [[values],[texts]] with
+        custom values for a given filter
+        - Param: column index (integer)
+    =====================================================*/
+    // _getCustomValues: function(colIndex){
+    //     if(!colIndex){
+    //         return;
+    //     }
+    //     //custom select test
+    //     var isCustomSlc = this.hasCustomSlcOptions &&
+    //             array.has(this.customSlcOptions.cols, colIndex);
+    //     if(!isCustomSlc){
+    //         return;
+    //     }
+    //     var optTxt = [], optArray = [];
+    //     var index = array.indexByValue(this.customSlcOptions.cols, colIndex);
+    //     var slcValues = this.customSlcOptions.values[index];
+    //     var slcTexts = this.customSlcOptions.texts[index];
+    //     var slcSort = this.customSlcOptions.sorts[index];
+    //     for(var r=0; r<slcValues.length; r++){
+    //         optArray.push(slcValues[r]);
+    //         if(slcTexts[r]){
+    //             optTxt.push(slcTexts[r]);
+    //         } else {
+    //             optTxt.push(slcValues[r]);
+    //         }
+    //     }
+    //     if(slcSort){
+    //         optArray.sort();
+    //         optTxt.sort();
+    //     }
+    //     return [optArray,optTxt];
+    // },
+
+    resetValues: function(){
+        this.EvtManager(this.Evt.name.resetvalues);
+    },
+
+    /*==============================================
+        - re-sets grid values when page is
+        re-loaded. It invokes resetGridValues,
+        ResetPage and ResetPageLength methods
+        - Params:
+            - name: cookie name (string)
+    ===============================================*/
+    _resetValues: function(){
+        //only fillSlcOnDemand
+        if(this.rememberGridValues && this.fillSlcOnDemand){
+            this.resetGridValues(this.fltsValuesCookie);
+        }
+        if(this.rememberPageLen){
+            // this.ResetPageLength(this.pgLenCookie);
+            this.Cpt.paging.resetPageLength(this.pgLenCookie);
+        }
+        if(this.rememberPageNb){
+            // this.ResetPage(this.pgNbCookie);
+            this.Cpt.paging.resetPage(this.pgNbCookie);
+        }
+    },
+
+    /*==============================================
+        - re-sets filters' values when page is
+        re-loaded if load on demand is enabled
+        - Params:
+            - name: cookie name (string)
+        - credits to Florent Hirchy
+    ===============================================*/
+    resetGridValues: function(name){
+        if(!this.fillSlcOnDemand){
+            return;
+        }
+        var fltsValues = this.Cpt.store.getFilterValues(name),
+            slcFltsIndex = this.getFiltersByType(this.fltTypeSlc, true),
+            multiFltsIndex = this.getFiltersByType(this.fltTypeMulti, true);
+
+        //if the number of columns is the same as before page reload
+        if(Number(fltsValues[(fltsValues.length-1)]) === this.fltIds.length){
+            for(var i=0; i<(fltsValues.length - 1); i++){
+                if(fltsValues[i]===' '){
+                    continue;
+                }
+                var s, opt;
+                // if fillSlcOnDemand, drop-down needs to contain stored
+                // value(s) for filtering
+                if(this['col'+i]===this.fltTypeSlc ||
+                    this['col'+i]===this.fltTypeMulti){
+                    var slc = dom.id( this.fltIds[i] );
+                    slc.options[0].selected = false;
+
+                    //selects
+                    if(array.has(slcFltsIndex, i)){
+                        opt = dom.createOpt(fltsValues[i],fltsValues[i],true);
+                        slc.appendChild(opt);
+                        this.hasStoredValues = true;
+                    }
+                    //multiple select
+                    if(array.has(multiFltsIndex, i)){
+                        s = fltsValues[i].split(' '+this.orOperator+' ');
+                        for(j=0; j<s.length; j++){
+                            if(s[j]===''){
+                                continue;
+                            }
+                            opt = dom.createOpt(s[j],s[j],true);
+                            slc.appendChild(opt);
+                            this.hasStoredValues = true;
+
+                            // IE multiple selection work-around
+                            // if(hlp.isIE()){
+                            //     this.__deferMultipleSelection(slc,j,false);
+                            //     hasStoredValues = false;
+                            // }
+                        }
+                    }// if multiFltsIndex
+                }
+                else if(this['col'+i]==this.fltTypeCheckList){
+                    var checkList = this.Cpt.checkList;
+                    var divChk = checkList.checkListDiv[i];
+                    divChk.title = divChk.innerHTML;
+                    divChk.innerHTML = '';
+
+                    var ul = dom.create(
+                        'ul',['id',this.fltIds[i]],['colIndex',i]);
+                    ul.className = checkList.checkListCssClass;
+
+                    var li0 = dom.createCheckItem(
+                        this.fltIds[i]+'_0', '', this.displayAllText);
+                    li0.className = checkList.checkListItemCssClass;
+                    ul.appendChild(li0);
+
+                    divChk.appendChild(ul);
+
+                    s = fltsValues[i].split(' '+this.orOperator+' ');
+                    for(j=0; j<s.length; j++){
+                        if(s[j]===''){
+                            continue;
+                        }
+                        var li = dom.createCheckItem(
+                            this.fltIds[i]+'_'+(j+1), s[j], s[j]);
+                        li.className = checkList.checkListItemCssClass;
+                        ul.appendChild(li);
+                        li.check.checked = true;
+                        checkList.setCheckListValues(li.check);
+                        this.hasStoredValues = true;
+                    }
+                }
+            }//end for
+
+            if(!this.hasStoredValues && this.paging){
+                this.Cpt.paging.setPagingInfo();
+            }
+        }//end if
+    },
+
+    filter: function(){
+        this.EvtManager(this.Evt.name.filter);
+    },
+    /*====================================================
+        - Filtering fn
+        - retrieves data from each td in every single tr
+        and compares to search string for current
+        column
+        - tr is hidden if all search strings are not
+        found
+    =====================================================*/
+    _filter: function(){
+        if(!this.fltGrid || (!this._hasGrid && !this.isFirstLoad)){
+            return;
+        }
+        //invokes onbefore callback
+        if(this.onBeforeFilter){
+            this.onBeforeFilter.call(null, this);
+        }
+
+        var row = this.tbl.rows,
+            f = this.cfg,
+            hiddenrows = 0;
+        this.validRowsIndex = [];
+        var o = this;
+
+        // removes keyword highlighting
+        if(this.highlightKeywords){
+            this.Cpt.highlightKeyword.unhighlightAll();
+        }
+        //removes popup filters active icons
+        if(this.popUpFilters){
+            this.Cpt.popupFilter.buildIcons();
+        }
+        //removes active column header class
+        if(this.markActiveColumns){
+            this.clearActiveColumns();
+        }
+        // search args re-init
+        this.searchArgs = this.getFiltersValue();
+
+        var num_cell_data, nbFormat;
+        var re_le = new RegExp(this.leOperator),
+            re_ge = new RegExp(this.geOperator),
+            re_l = new RegExp(this.lwOperator),
+            re_g = new RegExp(this.grOperator),
+            re_d = new RegExp(this.dfOperator),
+            re_lk = new RegExp(str.rgxEsc(this.lkOperator)),
+            re_eq = new RegExp(this.eqOperator),
+            re_st = new RegExp(this.stOperator),
+            re_en = new RegExp(this.enOperator),
+            re_an = new RegExp(this.anOperator),
+            re_cr = new RegExp(this.curExp),
+            re_em = this.emOperator,
+            re_nm = this.nmOperator,
+            re_re = new RegExp(str.rgxEsc(this.rgxOperator));
+
+        //keyword highlighting
+        function highlight(str, ok, cell){
+            if(o.highlightKeywords && ok){
+                str = str.replace(re_lk,'');
+                str = str.replace(re_eq,'');
+                str = str.replace(re_st,'');
+                str = str.replace(re_en,'');
+                var w = str;
+                if(re_le.test(str) || re_ge.test(str) || re_l.test(str) ||
+                    re_g.test(str) || re_d.test(str)){
+                    w = dom.getText(cell);
+                }
+                if(w!==''){
+                    o.Cpt.highlightKeyword.highlight(
+                        cell, w, o.Cpt.highlightKeyword.highlightCssClass);
+                }
+            }
+        }
+
+        //looks for search argument in current row
+        function hasArg(sA, cell_data, j){
+            var occurence;
+            //Search arg operator tests
+            var hasLO = re_l.test(sA),
+                hasLE = re_le.test(sA),
+                hasGR = re_g.test(sA),
+                hasGE = re_ge.test(sA),
+                hasDF = re_d.test(sA),
+                hasEQ = re_eq.test(sA),
+                hasLK = re_lk.test(sA),
+                hasAN = re_an.test(sA),
+                hasST = re_st.test(sA),
+                hasEN = re_en.test(sA),
+                hasEM = (re_em === sA),
+                hasNM = (re_nm === sA),
+                hasRE = re_re.test(sA);
+
+            //Search arg dates tests
+            var isLDate = hasLO && isValidDate(sA.replace(re_l,''),dtType);
+            var isLEDate = hasLE && isValidDate(sA.replace(re_le,''),dtType);
+            var isGDate = hasGR && isValidDate(sA.replace(re_g,''),dtType);
+            var isGEDate = hasGE && isValidDate(sA.replace(re_ge,''),dtType);
+            var isDFDate = hasDF && isValidDate(sA.replace(re_d,''),dtType);
+            var isEQDate = hasEQ && isValidDate(sA.replace(re_eq,''),dtType);
+
+            var dte1, dte2;
+            //dates
+            if(isValidDate(cell_data,dtType)){
+                dte1 = formatDate(cell_data,dtType);
+                // lower date
+                if(isLDate){
+                    dte2 = formatDate(sA.replace(re_l,''),dtType);
+                    occurence = dte1 < dte2;
+                }
+                // lower equal date
+                else if(isLEDate){
+                    dte2 = formatDate(sA.replace(re_le,''),dtType);
+                    occurence = dte1 <= dte2;
+                }
+                // greater equal date
+                else if(isGEDate){
+                    dte2 = formatDate(sA.replace(re_ge,''),dtType);
+                    occurence = dte1 >= dte2;
+                }
+                // greater date
+                else if(isGDate){
+                    dte2 = formatDate(sA.replace(re_g,''),dtType);
+                    occurence = dte1 > dte2;
+                }
+                // different date
+                else if(isDFDate){
+                    dte2 = formatDate(sA.replace(re_d,''),dtType);
+                    occurence = dte1.toString() != dte2.toString();
+                }
+                // equal date
+                else if(isEQDate){
+                    dte2 = formatDate(sA.replace(re_eq,''),dtType);
+                    occurence = dte1.toString() == dte2.toString();
+                }
+                // searched keyword with * operator doesn't have to be a date
+                else if(re_lk.test(sA)){// like date
+                    occurence = o._containsStr(
+                        sA.replace(re_lk,''),cell_data,null,false);
+                }
+                else if(isValidDate(sA,dtType)){
+                    dte2 = formatDate(sA,dtType);
+                    occurence = dte1.toString() == dte2.toString();
+                }
+                //empty
+                else if(hasEM){
+                    occurence = str.isEmpty(cell_data);
+                }
+                //non-empty
+                else if(hasNM){
+                    occurence = !str.isEmpty(cell_data);
+                }
+            }
+
+            else{
+                //first numbers need to be formated
+                if(o.hasColNbFormat && o.colNbFormat[j]){
+                    num_cell_data = removeNbFormat(
+                        cell_data,o.colNbFormat[j]);
+                    nbFormat = o.colNbFormat[j];
+                } else {
+                    if(o.thousandsSeparator===',' && o.decimalSeparator==='.'){
+                        num_cell_data = removeNbFormat(cell_data,'us');
+                        nbFormat = 'us';
+                    } else {
+                        num_cell_data = removeNbFormat(cell_data,'eu');
+                        nbFormat = 'eu';
+                    }
+                }
+
+                // first checks if there is any operator (<,>,<=,>=,!,*,=,{,},
+                // rgx:)
+                // lower equal
+                if(hasLE){
+                    occurence = num_cell_data <= removeNbFormat(
+                        sA.replace(re_le,''),nbFormat);
+                }
+                //greater equal
+                else if(hasGE){
+                    occurence = num_cell_data >= removeNbFormat(
+                        sA.replace(re_ge,''),nbFormat);
+                }
+                //lower
+                else if(hasLO){
+                    occurence = num_cell_data < removeNbFormat(
+                        sA.replace(re_l,''),nbFormat);
+                }
+                //greater
+                else if(hasGR){
+                    occurence = num_cell_data > removeNbFormat(
+                        sA.replace(re_g,''),nbFormat);
+                }
+                //different
+                else if(hasDF){
+                    occurence = o._containsStr(
+                        sA.replace(re_d,''),cell_data) ? false : true;
+                }
+                //like
+                else if(hasLK){
+                    occurence = o._containsStr(
+                        sA.replace(re_lk,''),cell_data,null,false);
+                }
+                //equal
+                else if(hasEQ){
+                    occurence = o._containsStr(
+                        sA.replace(re_eq,''),cell_data,null,true);
+                }
+                //starts with
+                else if(hasST){
+                    occurence = cell_data.indexOf(sA.replace(re_st,''))===0 ?
+                        true : false;
+                }
+                //ends with
+                else if(hasEN){
+                    var searchArg = sA.replace(re_en,'');
+                    occurence =
+                        cell_data.lastIndexOf(searchArg,cell_data.length-1) ===
+                        (cell_data.length-1)-(searchArg.length-1) &&
+                        cell_data.lastIndexOf(
+                            searchArg,cell_data.length-1) > -1 ? true : false;
+                }
+                //empty
+                else if(hasEM){
+                    occurence = str.isEmpty(cell_data);
+                }
+                //non-empty
+                else if(hasNM){
+                    occurence = !str.isEmpty(cell_data);
+                }
+                //regexp
+                else if(hasRE){
+                    //in case regexp fires an exception
+                    try{
+                        //operator is removed
+                        var srchArg = sA.replace(re_re,'');
+                        var rgx = new RegExp(srchArg);
+                        occurence = rgx.test(cell_data);
+                    } catch(e) { occurence = false; }
+                }
+                else{
+                    var fCol = f['col_'+j];
+                    occurence = o._containsStr(
+                        sA, cell_data, !fCol ? this.fltTypeInp : fCol);
+                }
+
+            }//else
+            return occurence;
+        }//fn
+
+        for(var k=this.refRow; k<this.nbRows; k++){
+            /*** if table already filtered some rows are not visible ***/
+            if(row[k].style.display === 'none'){
+                row[k].style.display = '';
+            }
+
+            var cell = row[k].cells,
+                nchilds = cell.length;
+
+            // checks if row has exact cell #
+            if(nchilds !== this.nbCells){
+                continue;
+            }
+
+            var occurence = [],
+                isRowValid = this.searchType==='include' ? true : false,
+                //only for single filter search
+                singleFltRowValid = false;
+
+            // this loop retrieves cell data
+            for(var j=0; j<nchilds; j++){
+                //searched keyword
+                var sA = this.searchArgs[this.singleSearchFlt ? 0 : j],
+                    dtType = this.hasColDateType ?
+                        this.colDateType[j] : this.defaultDateType;
+                if(sA===''){
+                    continue;
+                }
+
+                var cell_data = str.matchCase(
+                    this.getCellData(j, cell[j]), this.matchCase);
+
+                //multiple search parameter operator ||
+                var sAOrSplit = sA.split(this.orOperator),
+                //multiple search || parameter boolean
+                hasMultiOrSA = (sAOrSplit.length>1) ? true : false,
+                //multiple search parameter operator &&
+                sAAndSplit = sA.split(this.anOperator),
+                //multiple search && parameter boolean
+                hasMultiAndSA = sAAndSplit.length>1 ? true : false;
+
+                //multiple sarch parameters
+                if(hasMultiOrSA || hasMultiAndSA){
+                    var cS,
+                        occur = false,
+                        s = hasMultiOrSA ? sAOrSplit : sAAndSplit;
+                    for(var w=0; w<s.length; w++){
+                        cS = str.trim(s[w]);
+                        occur = hasArg(cS,cell_data,j);
+                        highlight(cS,occur,cell[j]);
+                        if(hasMultiOrSA && occur){
+                            break;
+                        }
+                        if(hasMultiAndSA && !occur){
+                            break;
+                        }
+                    }
+                    occurence[j] = occur;
+                }
+                //single search parameter
+                else {
+                    occurence[j] = hasArg(str.trim(sA), cell_data, j);
+                    highlight(sA, occurence[j], cell[j]);
+                }//else single param
+
+                if(!occurence[j]){
+                    isRowValid = this.searchType==='include' ? false : true;
+                }
+                if(this.singleSearchFlt && occurence[j]){
+                    singleFltRowValid = true;
+                }
+                if(this.popUpFilters){
+                    this.Cpt.popupFilter.buildIcon(j, true);
+                }
+                if(this.markActiveColumns){
+                    if(k === this.refRow){
+                        if(this.onBeforeActiveColumn){
+                            this.onBeforeActiveColumn.call(null, this, j);
+                        }
+                        dom.addClass(
+                            this.getHeaderElement(j),
+                            this.activeColumnsCssClass);
+                        if(this.onAfterActiveColumn){
+                            this.onAfterActiveColumn.call(null, this, j);
+                        }
+                    }
+                }
+            }//for j
+
+            if(this.singleSearchFlt && singleFltRowValid){
+                isRowValid = true;
+            }
+
+            if(!isRowValid){
+                this.validateRow(k,false);
+                // always visible rows need to be counted as valid
+                if(this.hasVisibleRows && array.has(this.visibleRows, k) &&
+                    !this.paging){
+                    this.validRowsIndex.push(k);
+                } else {
+                    hiddenrows++;
+                }
+            } else {
+                this.validateRow(k,true);
+                this.validRowsIndex.push(k);
+                if(this.alternateBgs){
+                    this.Cpt.alternateRows.setRowBg(
+                        k, this.validRowsIndex.length);
+                }
+                if(this.onRowValidated){
+                    this.onRowValidated.call(null,this,k);
+                }
+            }
+        }// for k
+
+        this.nbVisibleRows = this.validRowsIndex.length;
+        this.nbHiddenRows = hiddenrows;
+        this.isStartBgAlternate = false;
+
+        if(this.rememberGridValues){
+            this.Cpt.store.saveFilterValues(this.fltsValuesCookie);
+        }
+        //applies filter props after filtering process
+        if(!this.paging){
+            this.applyGridProps();
+        } else {
+            this.startPagingRow = 0;
+            this.currentPageNb = 1;
+            this.Cpt.paging.setPagingInfo(this.validRowsIndex);
+        }//starts paging process
+        //invokes onafter callback
+        if(this.onAfterFilter){
+            this.onAfterFilter.call(null,this);
+        }
+    },
+
+    /*====================================================
+        - checks methods that should be called
+        after filtering and/or paging process
+    =====================================================*/
+    applyGridProps: function(){
+        // blurs active filter (IE)
+        if(this.activeFlt &&
+            str.lower(this.activeFlt.nodeName)===this.fltTypeSlc &&
+            !this.popUpFilters){
+            this.activeFlt.blur();
+            if(this.activeFlt.parentNode){
+                this.activeFlt.parentNode.focus();
+            }
+        }
+
+        //shows rows always visible
+        if(this.visibleRows){
+            this.enforceVisibility();
+        }
+        //makes operation on a col
+        if(this.hasColOperation){
+            this.Cpt.colOps.calc();
+        }
+        //re-populates drop-down filters
+        if(this.linkedFilters){
+            this.linkFilters();
+        }
+        var nr = !this.paging && this.hasVisibleRows ?
+            this.nbVisibleRows - this.visibleRows.length : this.nbVisibleRows;
+        //refreshes rows counter
+        if(this.rowsCounter){
+            this.Cpt.rowsCounter.refresh(nr);
+        }
+
+        if(this.popUpFilters){
+            this.Cpt.popupFilter.closeAll();
+        }
+    },
+
+    /*====================================================
+        - returns an array containing cell values of
+        a column
+        - needs following args:
+            - column index (number)
+            - a boolean set to true if we want only
+            numbers to be returned
+            - array containing rows index to be excluded
+            from returned values
+    =====================================================*/
+    getColValues: function(colindex, num, exclude){
+        if(!this.fltGrid){
+            return;
+        }
+        var row = this.tbl.rows,
+            colValues = [];
+
+        for(var i=this.refRow; i<this.nbRows; i++){
+            var isExludedRow = false;
+            // checks if current row index appears in exclude array
+            if(exclude && types.isArray(exclude)){
+                isExludedRow = array.has(exclude, i); //boolean
+            }
+            var cell = row[i].cells,
+                nchilds = cell.length;
+
+            // checks if row has exact cell # and is not excluded
+            if(nchilds == this.nbCells && !isExludedRow){
+                // this loop retrieves cell data
+                for(var j=0; j<nchilds; j++){
+                    if(j===colindex && row[i].style.display===''){
+                        var cell_data = str.lower(
+                                this.getCellData(j, cell[j])),
+                            nbFormat = this.colNbFormat ?
+                                this.colNbFormat[colindex] : null,
+                            data = num ?
+                                removeNbFormat(cell_data,nbFormat) :
+                                cell_data;
+                        colValues.push(data);
+                    }
+                }
+            }
+        }//for i
+        return colValues;
+    },
+
+    /*====================================================
+        - Returns value of a specified filter
+        - Params:
+            - index: filter column index (numeric value)
+    =====================================================*/
+    getFilterValue: function(index){
+        if(!this.fltGrid){
+            return;
+        }
+        var fltValue,
+            flt = this.getFilterElement(index);
+        if(!flt){
+            return '';
+        }
+        var fltColType = this.fltCol[index];
+        if(fltColType !== this.fltTypeMulti &&
+            fltColType !== this.fltTypeCheckList){
+            fltValue = flt.value;
+        }
+        //mutiple select
+        else if(fltColType === this.fltTypeMulti){
+            fltValue = '';
+            for(var j=0; j<flt.options.length; j++){
+                if(flt.options[j].selected){
+                    fltValue = fltValue.concat(
+                        flt.options[j].value+' ' +
+                        this.orOperator + ' '
+                    );
+                }
+            }
+            //removes last operator ||
+            fltValue = fltValue.substr(0,fltValue.length-4);
+        }
+        //checklist
+        else if(fltColType === this.fltTypeCheckList){
+            if(flt.getAttribute('value') !== null){
+                fltValue = flt.getAttribute('value');
+                //removes last operator ||
+                fltValue = fltValue.substr(0,fltValue.length-3);
+            } else{
+                fltValue = '';
+            }
+        }
+        return fltValue;
+    },
+
+    /*====================================================
+        - Returns the value of every single filter
+    =====================================================*/
+    getFiltersValue: function(){
+        if(!this.fltGrid){
+            return;
+        }
+        var searchArgs = [];
+        for(var i=0; i<this.fltIds.length; i++){
+            searchArgs.push(
+                str.trim(
+                    str.matchCase(this.getFilterValue(i), this.matchCase))
+            );
+        }
+        return searchArgs;
+    },
+
+    /*====================================================
+        - Returns filter id of a specified column
+        - Params:
+            - index: column index (numeric value)
+    =====================================================*/
+    getFilterId: function(index){
+        if(!this.fltGrid){
+            return;
+        }
+        return this.fltIds[i];
+    },
+
+    /*====================================================
+        - returns an array containing ids of filters of a
+        specified type (inputs or selects)
+        - Note that hidden filters are also returned
+        - Needs folllowing args:
+            - filter type string ('input','select',
+            'multiple')
+            - optional boolean: if set true method
+            returns column indexes otherwise filters ids
+    =====================================================*/
+    getFiltersByType: function(type, bool){
+        if(!this.fltGrid){
+            return;
+        }
+        var arr = [];
+        for(var i=0; i<this.fltIds.length; i++){
+            var fltType = this['col'+i];
+            if(fltType === str.lower(type)){
+                var a = (bool) ? i : this.fltIds[i];
+                arr.push(a);
+            }
+        }
+        return arr;
+    },
+
+    /*====================================================
+        - returns filter DOM element for a given column
+        index
+    =====================================================*/
+    getFilterElement: function(index){
+        if(!this.fltGrid){
+            return null;
+        }
+        return dom.id(this.fltIds[index]);
+    },
+
+    /*====================================================
+        - returns number of cells in a row
+        - if rowIndex param is passed returns number of
+        cells of specified row (number)
+    =====================================================*/
+    getCellsNb: function(rowIndex){
+        var tr = !rowIndex ? this.tbl.rows[0] : this.tbl.rows[rowIndex];
+        return tr.cells.length;
+    },
+
+    /*====================================================
+        - returns total nb of filterable rows starting
+        from reference row if defined
+        - Param:
+            - includeHeaders: if true header rows are
+            included in calculation(= table rows number)
+    =====================================================*/
+    getRowsNb: function(includeHeaders){
+        var s = !this.refRow ? 0 : this.refRow,
+            ntrs = this.tbl.rows.length;
+        if(includeHeaders){ s = 0; }
+        return parseInt(ntrs-s, 10);
+    },
+
+    /*====================================================
+        - returns text content of a given cell
+        - Params:
+            - i: index of the column (number)
+            - cell: td DOM object
+    =====================================================*/
+    getCellData: function(i, cell){
+        if(i===undefined || !cell){
+            return '';
+        }
+        //First checks for customCellData event
+        if(this.customCellData && array.has(this.customCellDataCols, i)){
+            return this.customCellData.call(null,this,cell,i);
+        } else {
+            return dom.getText(cell);
+        }
+    },
+
+    /*====================================================
+        - returns an array containing table data:
+        [rowindex,[value1,value2,value3...]]
+    =====================================================*/
+    getTableData: function(){
+        var row = this.tbl.rows;
+        for(var k=this.refRow; k<this.nbRows; k++){
+            var rowData = [k,[]];
+            var cells = row[k].cells;
+            // this loop retrieves cell data
+            for(var j=0; j<cells.length; j++){
+                var cell_data = this.getCellData(j, cells[j]);
+                rowData[1].push(cell_data);
+            }
+            this.tblData.push(rowData);
+        }
+        return this.tblData;
+    },
+
+    /*====================================================
+        - returns an array containing filtered data:
+        [rowindex,[value1,value2,value3...]]
+    =====================================================*/
+    getFilteredData: function(includeHeaders){
+        if(!this.validRowsIndex){
+            return [];
+        }
+        var row = this.tbl.rows,
+            filteredData = [];
+        if(includeHeaders){
+            var table = this.gridLayout ? this.headTbl : this.tbl,
+                r = table.rows[this.headersRow],
+                rowData = [r.rowIndex,[]];
+            for(var j=0; j<this.nbCells; j++){
+                var headerText = this.getCellData(j, r.cells[j]);
+                rowData[1].push(headerText);
+            }
+            filteredData.push(rowData);
+        }
+
+        var validRows = this.getValidRowsIndex(true);
+        for(var i=0; i<validRows.length; i++){
+            var rData = [this.validRowsIndex[i],[]],
+                cells = row[this.validRowsIndex[i]].cells;
+            for(var k=0; k<cells.length; k++){
+                var cell_data = this.getCellData(k, cells[k]);
+                rData[1].push(cell_data);
+            }
+            filteredData.push(rData);
+        }
+        return filteredData;
+    },
+
+    /*====================================================
+        - returns an array containing filtered data of a
+        specified column.
+        - Params:
+            - colIndex: index of the column (number)
+        - returned array:
+        [value1,value2,value3...]
+    =====================================================*/
+    getFilteredDataCol: function(colIndex){
+        if(colIndex===undefined){
+            return [];
+        }
+        var data =  this.getFilteredData(),
+            colData = [];
+        for(var i=0; i<data.length; i++){
+            var r = data[i],
+                //cols values of current row
+                d = r[1],
+                //data of searched column
+                c = d[colIndex];
+            colData.push(c);
+        }
+        return colData;
+    },
+
+    getRowDisplay: function(row){
+        if(!this.fltGrid && !types.isObj(row)){
+            return;
+        }
+        return row.style.display;
+    },
+
+    /*====================================================
+        - Validates/unvalidates row by setting 'validRow'
+        attribute and shows/hides row
+        - Params:
+            - rowIndex: index of the row (number)
+            - isValid: boolean
+    =====================================================*/
+    validateRow: function(rowIndex, isValid){
+        var row = this.tbl.rows[rowIndex];
+        if(!row || str.lower(typeof isValid)!=='boolean'){
+            return;
+        }
+
+        // always visible rows are valid
+        if(this.hasVisibleRows && array.has(this.visibleRows, rowIndex) &&
+            !this.paging){
+            isValid = true;
+        }
+
+        var displayFlag = isValid ? '' : 'none',
+            validFlag = isValid ? 'true' : 'false';
+        row.style.display = displayFlag;
+
+        if(this.paging){
+            row.setAttribute('validRow',validFlag);
+        }
+    },
+
+    /*====================================================
+        - Validates all filterable rows
+    =====================================================*/
+    validateAllRows: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        this.validRowsIndex = [];
+        for(var k=this.refRow; k<this.nbFilterableRows; k++){
+            this.validateRow(k, true);
+            this.validRowsIndex.push(k);
+        }
+    },
+
+    /*====================================================
+        - Inserts value in a specified filter
+        - Params:
+            - index: filter column index (numeric value)
+            - searcharg: search string
+            - doFilter: optional boolean for multiple
+            selects: executes filtering when multiple
+            select populated... IE only!
+    =====================================================*/
+    setFilterValue: function(index, searcharg, doFilter){
+        if((!this.fltGrid && !this.isFirstLoad) ||
+            !this.getFilterElement(index)){
+            return;
+        }
+        var slc = this.getFilterElement(index),
+            execFilter = doFilter===undefined ? true : doFilter,
+            fltColType = this['col'+index];
+        searcharg = searcharg===undefined ? '' : searcharg;
+
+        if(fltColType !== this.fltTypeMulti &&
+            fltColType != this.fltTypeCheckList){
+            slc.value = searcharg;
+        }
+        //multiple selects
+        else if(fltColType === this.fltTypeMulti){
+            var s = searcharg.split(' '+this.orOperator+' '),
+                ct = 0; //keywords counter
+            for(var j=0; j<slc.options.length; j++){
+                if(s==='' || s[0]===''){
+                    slc.options[j].selected = false;
+                }
+                if(slc.options[j].value===''){
+                    slc.options[j].selected = false;
+                }
+                if(slc.options[j].value!=='' &&
+                    array.has(s, slc.options[j].value, true)){
+                    // IE multiple selection work-around
+                    // if(hlp.isIE()){
+                    //     //when last value reached filtering can be executed
+                    //     var filter = ct==(s.length-1) && execFilter ?
+                    //         true : false;
+                    //     this.__deferMultipleSelection(slc,j,filter);
+                    //     ct++;
+                    // }
+                    // else{
+                    //     slc.options[j].selected = true;
+                    // }
+                    slc.options[j].selected = true;
+                }//if
+            }//for j
+        }
+        //checklist
+        else if(fltColType === this.fltTypeCheckList){
+            searcharg = str.matchCase(searcharg, this.matchCase);
+            var sarg = searcharg.split(' '+this.orOperator+' '),
+                fltValue = slc.setAttribute('value',''),
+                fltIndex = slc.setAttribute('indexes','');
+            for(var k=0; k<dom.tag(slc,'li').length; k++){
+                var li = dom.tag(slc,'li')[k],
+                    lbl = dom.tag(li,'label')[0],
+                    chk = dom.tag(li,'input')[0],
+                    lblTxt = str.matchCase(
+                        dom.getText(lbl), this.matchCase);
+                if(lblTxt!=='' && array.has(sarg, lblTxt, true)){
+                    chk.checked = true;
+                    this.Cpt.checkList.setCheckListValues(chk);
+                }
+                else{
+                    chk.checked = false;
+                    this.Cpt.checkList.setCheckListValues(chk);
+                }
+            }
+        }
+    },
+
+    /*====================================================
+        - sets coluun widths in pixels
+    =====================================================*/
+    setColWidths: function(rowIndex){
+        if(!this.fltGrid || !this.hasColWidth){
+            return;
+        }
+        var o = this, rIndex;
+        if(rowIndex===undefined){
+            rIndex = this.tbl.rows[0].style.display!='none' ? 0 : 1;
+        } else{
+            rIndex = rowIndex;
+        }
+        setWidths(this.tbl.rows[rIndex]);
+
+        function setWidths(row){
+            if(!o && (o.nbCells!=o.colWidth.length)){
+                return;
+            }
+            if(o.nbCells==row.cells.length){
+                for(var k=0; k<o.nbCells; k++){
+                    row.cells[k].style.width = o.colWidth[k];
+                }
+            }
+        }
+    },
+
+    /*====================================================
+        - makes a row always visible
+        - Note this works only if paging is false
+    =====================================================*/
+    enforceVisibility: function(){
+        if(this._hasGrid && this.hasVisibleRows && !this.paging){
+            for(var i=0; i<this.visibleRows.length; i++){
+                //row index cannot be > nrows
+                if(this.visibleRows[i] <= this.nbRows){
+                    this.validateRow(this.visibleRows[i],true);
+                }
+            }
+        }
+    },
+
+    clearFilters: function(){
+        this.EvtManager(this.Evt.name.clear);
+    },
+    /*====================================================
+        - clears grid filters
+    =====================================================*/
+    _clearFilters: function(){
+        if(!this.fltGrid){
+            return;
+        }
+        if(this.onBeforeReset){
+            this.onBeforeReset.call(null, this, this.getFiltersValue());
+        }
+        for(var i=0; i<this.fltIds.length; i++){
+            this.setFilterValue(i, '');
+        }
+        if(this.linkedFilters){
+            this.activeFilterId = '';
+            this.linkFilters();
+        }
+        if(this.rememberPageLen){ cookie.remove(this.pgLenCookie); }
+        if(this.rememberPageNb){ cookie.remove(this.pgNbCookie); }
+        if(this.onAfterReset){ this.onAfterReset.call(null, this); }
+    },
+
+    /*====================================================
+        - clears active columns header class name
+    =====================================================*/
+    clearActiveColumns: function(){
+        for(var i=0; i<this.fltIds.length; i++){
+            dom.removeClass(
+                this.getHeaderElement(i), this.activeColumnsCssClass);
+        }
+    },
+
+    /*====================================================
+        - Re-generates filters grid
+    =====================================================*/
+    refresh: function(config){
+        var configObj = !config ? this.cfg : config;
+        var hasSort = this.sort;
+        //sort property is set to false in order to avoid sort object
+        //re-instanciation
+        if(hasSort){
+            this.sort = false;
+        }
+        this.nbRows = this.getRowsNb(); //in case table is refreshed
+        this.remove();
+        window['tf_'+this.id] = new TableFilter(this.id, this.startRow, configObj);
+        this.isFirstLoad = true;
+        this.fltIds = [];
+        this.init();
+        //New tbody content needs to be referenced in sortabletable script with
+        //setTBody() method
+        if(hasSort){
+            //this.st =  SortableTable object
+            //Note this is a method of the Sortable Table 1.12 script
+            //(Erik Arvidsson)
+            this.st.setTBody(this.tbl.tBodies[0]);
+            //finally sort property is enabled again
+            this.sort = true;
+        }
+    },
+
+    /*====================================================
+        - retrieves select, multiple and checklist filters
+        - calls method repopulating filters
+    =====================================================*/
+    linkFilters: function(){
+        var slcA1 = this.getFiltersByType(this.fltTypeSlc, true),
+            slcA2 = this.getFiltersByType(this.fltTypeMulti, true),
+            slcA3 = this.getFiltersByType(this.fltTypeCheckList, true),
+            slcIndex = slcA1.concat(slcA2);
+        slcIndex = slcIndex.concat(slcA3);
+
+        if(this.activeFilterId){
+            var activeFlt = this.activeFilterId.split('_')[0];
+            activeFlt = activeFlt.split(this.prfxFlt)[1];
+            var slcSelectedValue;
+            for(var i=0; i<slcIndex.length; i++){
+                var curSlc = dom.id(this.fltIds[slcIndex[i]]);
+                slcSelectedValue = this.getFilterValue(slcIndex[i]);
+                if(activeFlt!==slcIndex[i] ||
+                    (this.paging && array.has(slcA1, slcIndex[i]) &&
+                        activeFlt === slcIndex[i] ) ||
+                    (!this.paging && (array.has(slcA3, slcIndex[i]) ||
+                        array.has(slcA2, slcIndex[i]))) ||
+                    slcSelectedValue === this.displayAllText ){
+
+                    if(array.has(slcA3, slcIndex[i])){
+                        this.Cpt.checkList.checkListDiv[
+                            slcIndex[i]].innerHTML = '';
+                    } else {
+                        curSlc.innerHTML = '';
+                    }
+
+                    //1st option needs to be inserted
+                    if(this.fillSlcOnDemand) {
+                        var opt0 = dom.createOpt(this.displayAllText, '');
+                        if(curSlc){
+                            curSlc.appendChild(opt0);
+                        }
+                    }
+
+                    if(array.has(slcA3, slcIndex[i])){
+                        this.Cpt.checkList._build(slcIndex[i]);
+                    } else {
+                        this.Cpt.dropdown._build(slcIndex[i], true);
+                    }
+
+                    this.setFilterValue(slcIndex[i],slcSelectedValue);
+                }
+            }// for i
+        }
+    },
+
+    /*====================================================
+        - Private methods
+    =====================================================*/
+
+    /*====================================================
+        - Only used by AddGrid() method
+        - Resets filtering grid bar if previously removed
+    =====================================================*/
+    _resetGrid: function(){
+        if(this.isFirstLoad){
+            return;
+        }
+
+        // grid was removed, grid row element is stored in fltGridEl property
+        if(!this.gridLayout){
+            this.tbl.rows[this.filtersRowIndex].parentNode.insertBefore(
+                this.fltGridEl,
+                this.tbl.rows[this.filtersRowIndex]
+            );
+        }
+
+        // filters are appended in external placeholders elements
+        if(this.isExternalFlt){
+            for(var ct=0; ct<this.externalFltTgtIds.length; ct++){
+                var extFlt = dom.id(this.externalFltTgtIds[ct]);
+                if(extFlt){
+                    extFlt.appendChild(this.externalFltEls[ct]);
+                    var colFltType = this['col'+ct];
+                    //IE special treatment for gridLayout, appended filters are
+                    //empty
+                    if(this.gridLayout &&
+                        this.externalFltEls[ct].innerHTML === '' &&
+                        colFltType !== this.fltTypeInp){
+                        if(colFltType === this.fltTypeSlc ||
+                            colFltType === this.fltTypeMulti){
+                            this.Cpt.dropdown.build(ct);
+                        }
+                        if(colFltType === this.fltTypeCheckList){
+                            this.Cpt.checkList.build(ct);
+                        }
+                    }
+                }
+            }
+        }
+
+        this.nbFilterableRows = this.getRowsNb();
+        this.nbVisibleRows = this.nbFilterableRows;
+        this.nbRows = this.tbl.rows.length;
+        if(this.isSortEnabled){
+            this.sort = true;
+        }
+
+        if(this.tbl.rows[this.filtersRowIndex].innerHTML === ''){
+            refreshFilters(this);
+        } else {
+            if(this.popUpFilters){
+                this.headersRow++;
+                this.Cpt.popupFilter.buildAll();
+            }
+        }
+
+        /***    ie bug work-around, filters need to be re-generated since row
+                is empty; insertBefore method doesn't seem to work properly
+                with previously generated DOM nodes modified by innerHTML   ***/
+        function refreshFilters(o){
+            o.tbl.deleteRow(o.filtersRowIndex);
+            o.remove();
+            o.fltIds = [];
+            o.isFirstLoad = true;
+            if(o.popUpFilters){
+                // o.RemovePopupFilters();
+                o.Cpt.popupFilter.destroy();
+            }
+            o._AddGrid();
+        }
+
+        if(!this.gridLayout){
+            dom.addClass(this.tbl, this.prfxTf);
+        }
+        this._hasGrid = true;
+    },
+
+    /*==============================================
+        - Checks if data contains searched arg,
+        returns a boolean
+        - Params:
+            - arg: searched string
+            - data: data string
+            - fltType: filter type (string,
+            exact match by default for selects -
+            optional)
+            - forceMatch: boolean forcing exact
+            match (optional)
+    ===============================================*/
+    _containsStr: function(arg, data, fltType, forceMatch){
+        // Improved by Cedric Wartel (cwl)
+        // automatic exact match for selects and special characters are now
+        // filtered
+        var regexp,
+            modifier = (this.matchCase) ? 'g' : 'gi',
+            exactMatch = !forceMatch ? this.exactMatch : forceMatch;
+        if(exactMatch || (fltType!==this.fltTypeInp && fltType)){
+            regexp = new RegExp(
+                '(^\\s*)'+ str.rgxEsc(arg) +'(\\s*$)', modifier);
+        } else{
+            regexp = new RegExp(str.rgxEsc(arg), modifier);
+        }
+        return regexp.test(data);
+    },
+
+    includeFile: function(fileId, filePath, callback, type){
+        var ftype = !type ? 'script' : type,
+            imported = isImported(filePath, ftype);
+        if(imported){
+            return;
+        }
+        var o = this,
+            isLoaded = false,
+            file,
+            head = dom.tag(doc,'head')[0];
+
+        if(str.lower(ftype) === 'link'){
+            file = dom.create(
+                'link',
+                ['id', fileId], ['type', 'text/css'],
+                ['rel', 'stylesheet'], ['href', filePath]
+            );
+        } else {
+            file = dom.create(
+                'script', ['id', fileId],
+                ['type', 'text/javascript'], ['src', filePath]
+            );
+        }
+
+        //Browser <> IE onload event works only for scripts, not for stylesheets
+        file.onload = file.onreadystatechange = function(){
+            if(!isLoaded &&
+                (!this.readyState || this.readyState === 'loaded' ||
+                    this.readyState === 'complete')){
+                isLoaded = true;
+                if(typeof callback === 'function'){
+                    callback.call(null, o);
+                }
+            }
+        };
+        file.onerror = function(){
+            throw new Error('TF script could not load:\n' + this.src);
+        };
+        head.appendChild(file);
+    },
+
+    /*====================================================
+        - checks if table has a filter grid
+        - returns a boolean
+    =====================================================*/
+    hasGrid: function(){
+        return this._hasGrid;
+    },
+
+    /*====================================================
+        - returns an array containing filters ids
+        - Note that hidden filters are also returned
+    =====================================================*/
+    getFiltersId: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        return this.fltIds;
+    },
+
+    /*====================================================
+        - returns an array containing valid rows indexes
+        (valid rows upon filtering)
+    =====================================================*/
+    getValidRowsIndex: function(reCalc){
+        if(!this._hasGrid){
+            return;
+        }
+        if(!reCalc){
+            return this.validRowsIndex;
+        }
+
+        this.validRowsIndex = [];
+        for(var k=this.refRow; k<this.getRowsNb(true); k++){
+            var r = this.tbl.rows[k];
+            if(!this.paging){
+                if(this.getRowDisplay(r) !== 'none'){
+                    this.validRowsIndex.push(r.rowIndex);
+                }
+            } else {
+                if(r.getAttribute('validRow') === 'true' ||
+                    r.getAttribute('validRow') === null){
+                    this.validRowsIndex.push(r.rowIndex);
+                }
+            }
+        }
+        return this.validRowsIndex;
+    },
+
+    /*====================================================
+        - Returns the index of the row containing the
+        filters
+    =====================================================*/
+    getFiltersRowIndex: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        return this.filtersRowIndex;
+    },
+
+    /*====================================================
+        - Returns the index of the headers row
+    =====================================================*/
+    getHeadersRowIndex: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        return this.headersRow;
+    },
+
+    /*====================================================
+        - Returns the index of the row from which will
+        start the filtering process (1st filterable row)
+    =====================================================*/
+    getStartRowIndex: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        return this.refRow;
+    },
+
+    /*====================================================
+        - Returns the index of the last row
+    =====================================================*/
+    getLastRowIndex: function(){
+        if(!this._hasGrid){
+            return;
+        }
+        return (this.nbRows-1);
+    },
+
+    /*====================================================
+        - returns a header DOM element for a given column
+        index
+    =====================================================*/
+    getHeaderElement: function(colIndex){
+        var table = this.gridLayout ? this.headTbl : this.tbl;
+        var header, tHead = dom.tag(this.tbl,'thead');
+        for(var i=0; i<this.nbCells; i++){
+            if(i !== colIndex){
+                continue;
+            }
+            if(tHead.length === 0){
+                header = table.rows[this.headersRow].cells[i];
+            }
+            if(tHead.length === 1){
+                header = tHead[0].rows[this.headersRow].cells[i];
+            }
+            break;
+        }
+        return header;
+    },
+
+    /*====================================================
+        - returns the original configuration object
+    =====================================================*/
+    config: function(){
+        return this.cfg;
+    },
+
+    /*====================================================
+        - returns the total number of rows that can be
+        filtered
+    =====================================================*/
+    getFilterableRowsNb: function(){
+        return this.getRowsNb(false);
+    }
+};
+
+function numSortAsc(a, b){ return (a-b); }
+
+function numSortDesc(a, b){ return (b-a); }
+
+function removeNbFormat(data, format){
+    if(!data){
+        return;
+    }
+    if(!format){
+        format = 'us';
+    }
+    var n = data;
+    if(str.lower(format)==='us'){
+        n =+ n.replace(/[^\d\.-]/g,'');
+    } else {
+        n =+ n.replace(/[^\d\,-]/g,'').replace(',','.');
+    }
+    return n;
+}
+
+function isImported(filePath, type){
+    var imported = false,
+        importType = !type ? 'script' : type,
+        attr = importType == 'script' ? 'src' : 'href',
+        files = dom.tag(doc,importType);
+    for (var i=0; i<files.length; i++){
+        if(files[i][attr] === undefined){
+            continue;
+        }
+        if(files[i][attr].match(filePath)){
+            imported = true;
+            break;
+        }
+    }
+    return imported;
+}
+
+// function isStylesheetImported(stylesheet){
+//     var isImported = false;
+//     if(!doc.styleSheets){
+//         return isImported;
+//     }
+//     var s = doc.styleSheets,
+//         regexp = new RegExp(stylesheet);
+//     for(var i=0; i<s.length; i++){
+//         if(s[i].imports){//IE
+//             var imp = s[i].imports;
+//             for(var j=0; j<imp.length; j++){
+//                 if(str.lower(imp[j].href) === str.lower(stylesheet)){
+//                     isImported = true;
+//                     break;
+//                 }
+//             }
+//         } else {
+//             var r = s[i].cssRules ? s[i].cssRules : s[i].rules;
+//             for(var k=0; k<r.length; k++){
+//                 if(regexp.test(r[k].cssText)){
+//                     isImported = true;
+//                     break;
+//                 }
+//             }
+//         }
+//     }
+//     return isImported;
+// }
+
+//Firefox does not support outerHTML property
+function setOuterHtml(){
+    if(doc.body.__defineGetter__){
+        if(HTMLElement) {
+            var element = HTMLElement.prototype;
+            if(element.__defineGetter__){
+                element.__defineGetter__("outerHTML",
+                    function(){
+                        var parent = this.parentNode;
+                        var el = dom.create(parent.tagName);
+                        el.appendChild(this);
+                        var shtml = el.innerHTML;
+                        parent.appendChild(this);
+                        return shtml;
+                    }
+                );
+            }
+            if(element.__defineSetter__) {
+                HTMLElement.prototype.__defineSetter__(
+                    "outerHTML", function(sHTML){
+                   var r = this.ownerDocument.createRange();
+                   r.setStartBefore(this);
+                   var df = r.createContextualFragment(sHTML);
+                   this.parentNode.replaceChild(df, this);
+                   return sHTML;
+                });
+            }
+        }
+    }
+}
+
+return TableFilter;
+
+});
+
+/*====================================================
+    - Sets filters grid bar
+    - Calls TF Constructor and generates grid bar
+    - Params:
+            - id: table id (string)
+            - refRow (optional): row index (number)
+            - config (optional): configuration
+            object (literal object)
+    - Returns TF object
+=====================================================*/
+// function setFilterGrid(id){
+//     if(arguments.length === 0){
+//         return;
+//     }
+//     var tf = new TableFilter(arguments[0], arguments[1], arguments[2]);
+//     tf.init();
+//     window['tf_'+id] = tf;
+//     return tf;
+// }
+
+/*===BEGIN removable section===========================
+    - Unobtrusive grid bar generation using
+    'filterable' class
+    - If you don't use it you can remove safely this
+    section
+/*=====================================================*/
+// window['tf_isNotIE'] = !(/msie|MSIE/.test(navigator.userAgent));
+// TF.Event.add(window,
+//     (tf_isNotIE || (typeof window.addEventListener === 'function') ?
+//         'DOMContentLoaded' : 'load'),
+//     initFilterGrid);
+
+// function initFilterGrid(){
+//     if(!document.getElementsByTagName){ return; }
+//     var tbls = dom.tag(document,'table'), config;
+//     for (var i=0; i<tbls.length; i++){
+//         var cTbl = tbls[i], cTblId = cTbl.getAttribute('id');
+//         if(TF.Dom.hasClass(cTbl,'filterable') && cTblId){
+//             if(TF.Types.isObj(cTblId+'cfg')){
+//                 config = window[cTblId+'cfg'];
+//             } else { config = undefined; }
+//             window[cTblId+'_isUnob'] = true;
+//             setFilterGrid(cTblId,config);
+//         }
+//     }// for i
+// }
+/*===END removable section===========================*/
diff --git a/dist/build.txt b/dist/build.txt
new file mode 100644
index 00000000..738341f3
--- /dev/null
+++ b/dist/build.txt
@@ -0,0 +1,56 @@
+
+filtergrid.css
+----------------
+filtergrid.css
+
+TF_Themes/Default/TF_Default.css
+----------------
+TF_Themes/Default/TF_Default.css
+
+TF_Themes/MyTheme/MyTheme.css
+----------------
+TF_Themes/MyTheme/MyTheme.css
+
+TF_Themes/SkyBlue/TF_SkyBlue.css
+----------------
+TF_Themes/SkyBlue/TF_SkyBlue.css
+
+extensions/sortabletable/adapterSortabletable.js
+----------------
+types.js
+dom.js
+string.js
+array.js
+event.js
+date.js
+helpers.js
+extensions/sortabletable/adapterSortabletable.js
+extensions/sortabletable/sortabletable.js
+
+tablefilter.js
+----------------
+almond.js
+event.js
+dom.js
+string.js
+cookie.js
+types.js
+array.js
+helpers.js
+date.js
+sort.js
+modules/store.js
+modules/gridLayout.js
+modules/loader.js
+modules/highlightKeywords.js
+modules/popupFilter.js
+modules/dropdown.js
+modules/checkList.js
+modules/rowsCounter.js
+modules/statusBar.js
+modules/paging.js
+modules/clearButton.js
+modules/help.js
+modules/alternateRows.js
+modules/colOps.js
+tablefilter.js
diff --git a/dist/extensions/sortabletable/adapterSortabletable.js b/dist/extensions/sortabletable/adapterSortabletable.js
new file mode 100644
index 00000000..c28a56dd
--- /dev/null
+++ b/dist/extensions/sortabletable/adapterSortabletable.js
@@ -0,0 +1,1491 @@
+
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(factory);
+    } else if (typeof exports === 'object') {
+        module.exports = factory;
+    } else {
+        root.AdapterSortableTable = factory();//
+    }
+})(this, function() {define('types',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * Types utilities
+     */
+
+    var Types = {};
+
+    var UNDEFINED = void 0;
+
+    /**
+     * Checks if var exists and is an object
+     * @param  {String or Object}  v
+     * @return {Boolean}
+     */
+    Types.isObj = function (v) {
+        var isO = false;
+        if (typeof v === "string") {
+            if (window[v] && typeof window[v] === "object") {
+                isO = true;
+            }
+        } else {
+            if (v && typeof v === "object") {
+                isO = true;
+            }
+        }
+        return isO;
+    };
+
+    /**
+     * Checks if passed parameter is a function
+     * @param  {Function} fn
+     * @return {Boolean}
+     */
+    Types.isFn = function (fn) {
+        return fn && fn.constructor == Function;
+    };
+
+    /**
+     * Checks if passed param is an array
+     * @param  {Array}  obj
+     * @return {Boolean}
+     */
+    Types.isArray = function (obj) {
+        return obj && obj.constructor == Array;
+    };
+
+    /**
+     * Determines if passed param is undefined
+     * @param  {Any}  o
+     * @return {Boolean}
+     */
+    Types.isUndef = function (o) {
+        return o === UNDEFINED;
+    };
+
+    exports.Types = Types;
+});
+//# sourceMappingURL=types.js.map;
+define('dom',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * DOM utilities
+     */
+
+    var Dom = {};
+
+    /**
+     * Returns text + text of children of given node
+     * @param  {NodeElement} node
+     * @return {String}
+     */
+    Dom.getText = function (node) {
+        var s = node.textContent || node.innerText || node.innerHTML.replace(/<[^<>]+>/g, "");
+        s = s.replace(/^\s+/, "").replace(/\s+$/, "");
+        return s;
+    };
+
+    /**
+     * Creates an html element with given collection of attributes
+     * @param  {String} tag a string of the html tag to create
+     * @param  {Array} an undetermined number of arrays containing the with 2
+     *                    items, the attribute name and its value ['id','myId']
+     * @return {Object}     created element
+     */
+    Dom.create = function (tag) {
+        if (!tag || tag === "") {
+            return;
+        }
+
+        var el = document.createElement(tag),
+            args = arguments;
+
+        if (args.length > 1) {
+            for (var i = 0; i < args.length; i++) {
+                var argtype = typeof args[i];
+                if (argtype.toLowerCase() === "object" && args[i].length === 2) {
+                    el.setAttribute(args[i][0], args[i][1]);
+                }
+            }
+        }
+        return el;
+    };
+
+    /**
+     * Returns a text node with given text
+     * @param  {String} text
+     * @return {Object}
+     */
+    Dom.text = function (text) {
+        return document.createTextNode(text);
+    };
+
+    /**
+     * Returns offset position of passed element
+     * @param  {object} obj [description]
+     * @return {object}     literal object with left and top values
+     */
+    Dom.position = function (obj) {
+        var l = 0,
+            t = 0;
+        if (obj && obj.offsetParent) {
+            do {
+                l += obj.offsetLeft;
+                t += obj.offsetTop;
+            } while (obj == obj.offsetParent);
+        }
+        return { left: l, top: t };
+    };
+
+    Dom.hasClass = function (ele, cls) {
+        if (!ele) {
+            return false;
+        }
+
+        if (supportsClassList()) {
+            return ele.classList.contains(cls);
+        }
+        return ele.className.match(new RegExp("(\\s|^)" + cls + "(\\s|$)"));
+    };
+
+    Dom.addClass = function (ele, cls) {
+        if (!ele) {
+            return;
+        }
+
+        if (supportsClassList()) {
+            ele.classList.add(cls);
+            return;
+        }
+
+        if (ele.className === "") {
+            ele.className = cls;
+        } else if (!this.hasClass(ele, cls)) {
+            ele.className += " " + cls;
+        }
+    };
+
+    Dom.removeClass = function (ele, cls) {
+        if (!ele) {
+            return;
+        }
+
+        if (supportsClassList()) {
+            ele.classList.remove(cls);
+            return;
+        }
+        var reg = new RegExp("(\\s|^)" + cls + "(\\s|$)", "g");
+        ele.className = ele.className.replace(reg, "");
+    };
+
+    /**
+     * Creates and returns an option element
+     * @param  {String}  text  option text
+     * @param  {String}  value option value
+     * @param  {Boolean} isSel whether option is selected
+     * @return {Object}        option element
+     */
+    Dom.createOpt = function (text, value, isSel) {
+        var isSelected = isSel ? true : false,
+            opt = isSelected ? this.create("option", ["value", value], ["selected", "true"]) : this.create("option", ["value", value]);
+        opt.appendChild(this.text(text));
+        return opt;
+    };
+
+    /**
+     * Creates and returns a checklist item
+     * @param  {Number} chkIndex  index of check item
+     * @param  {String} chkValue  check item value
+     * @param  {String} labelText check item label text
+     * @return {Object}           li DOM element
+     */
+    Dom.createCheckItem = function (chkIndex, chkValue, labelText) {
+        var li = this.create("li"),
+            label = this.create("label", ["for", chkIndex]),
+            check = this.create("input", ["id", chkIndex], ["name", chkIndex], ["type", "checkbox"], ["value", chkValue]);
+        label.appendChild(check);
+        label.appendChild(this.text(labelText));
+        li.appendChild(label);
+        li.label = label;
+        li.check = check;
+        return li;
+    };
+
+    Dom.id = function (id) {
+        return document.getElementById(id);
+    };
+
+    Dom.tag = function (o, tagname) {
+        return o.getElementsByTagName(tagname);
+    };
+
+    // HTML5 classList API
+    function supportsClassList() {
+        return document.documentElement.classList;
+    }
+
+    exports.Dom = Dom;
+});
+//# sourceMappingURL=dom.js.map;
+define('string',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * String utilities
+     */
+
+    var Str = {};
+
+    Str.lower = function (text) {
+        return text.toLowerCase();
+    };
+
+    Str.upper = function (text) {
+        return text.toUpperCase();
+    };
+
+    Str.trim = function (text) {
+        if (text.trim) {
+            return text.trim();
+        }
+        return text.replace(/^\s*|\s*$/g, "");
+    };
+
+    Str.isEmpty = function (text) {
+        return this.trim(text) === "";
+    };
+
+    Str.rgxEsc = function (text) {
+        function escape(e) {
+            var a = new RegExp("\\" + e, "g");
+            text = text.replace(a, "\\" + e);
+        }
+
+        var chars = ["\\", "[", "^", "$", ".", "|", "?", "*", "+", "(", ")"];
+        for (var e = 0; e < chars.length; e++) {
+            escape(chars[e]);
+        }
+        return text;
+    };
+
+    Str.matchCase = function (text, mc) {
+        if (!mc) {
+            return this.lower(text);
+        }
+        return text;
+    };
+
+    exports.Str = Str;
+});
+//# sourceMappingURL=string.js.map;
+define('array',["exports", "string"], function (exports, _string) {
+    "use strict";
+
+    /**
+     * Array utilities
+     */
+
+    var Str = _string.Str;
+
+    var Arr = {
+        has: function has(arr, val, caseSensitive) {
+            var sCase = caseSensitive === undefined ? false : caseSensitive;
+            for (var i = 0; i < arr.length; i++) {
+                if (Str.matchCase(arr[i].toString(), sCase) == val) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        indexByValue: function indexByValue(arr, val, caseSensitive) {
+            var sCase = caseSensitive === undefined ? false : caseSensitive;
+            for (var i = 0; i < arr.length; i++) {
+                if (Str.matchCase(arr[i].toString(), sCase) == val) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    };
+
+    exports.Arr = Arr;
+});
+//# sourceMappingURL=array.js.map;
+define('event',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * DOM event utilities
+     */
+
+    var Event = {
+        add: function add(obj, type, func, capture) {
+            if (obj.addEventListener) {
+                obj.addEventListener(type, func, capture);
+            } else if (obj.attachEvent) {
+                obj.attachEvent("on" + type, func);
+            } else {
+                obj["on" + type] = func;
+            }
+        },
+        remove: function remove(obj, type, func, capture) {
+            if (obj.detachEvent) {
+                obj.detachEvent("on" + type, func);
+            } else if (obj.removeEventListener) {
+                obj.removeEventListener(type, func, capture);
+            } else {
+                obj["on" + type] = null;
+            }
+        },
+        stop: function stop(evt) {
+            if (!evt) {
+                evt = window.event;
+            }
+            if (evt.stopPropagation) {
+                evt.stopPropagation();
+            } else {
+                evt.cancelBubble = true;
+            }
+        },
+        cancel: function cancel(evt) {
+            if (!evt) {
+                evt = window.event;
+            }
+            if (evt.preventDefault) {
+                evt.preventDefault();
+            } else {
+                evt.returnValue = false;
+            }
+        }
+    };
+
+    exports.Event = Event;
+});
+//# sourceMappingURL=event.js.map;
+define('date',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * Date utilities
+     */
+
+    var DateHelper = {
+        isValid: function isValid(dateStr, format) {
+            if (!format) {
+                format = "DMY";
+            }
+            format = format.toUpperCase();
+            if (format.length != 3) {
+                if (format === "DDMMMYYYY") {
+                    var d = this.format(dateStr, format);
+                    dateStr = d.getDate() + "/" + (d.getMonth() + 1) + "/" + d.getFullYear();
+                    format = "DMY";
+                }
+            }
+            if (format.indexOf("M") === -1 || format.indexOf("D") === -1 || format.indexOf("Y") === -1) {
+                format = "DMY";
+            }
+            var reg1, reg2;
+            // If the year is first
+            if (format.substring(0, 1) == "Y") {
+                reg1 = /^\d{2}(\-|\/|\.)\d{1,2}\1\d{1,2}$/;
+                reg2 = /^\d{4}(\-|\/|\.)\d{1,2}\1\d{1,2}$/;
+            } else if (format.substring(1, 2) == "Y") {
+                // If the year is second
+                reg1 = /^\d{1,2}(\-|\/|\.)\d{2}\1\d{1,2}$/;
+                reg2 = /^\d{1,2}(\-|\/|\.)\d{4}\1\d{1,2}$/;
+            } else {
+                // The year must be third
+                reg1 = /^\d{1,2}(\-|\/|\.)\d{1,2}\1\d{2}$/;
+                reg2 = /^\d{1,2}(\-|\/|\.)\d{1,2}\1\d{4}$/;
+            }
+            // If it doesn't conform to the right format (with either a 2 digit year or
+            // 4 digit year), fail
+            if (reg1.test(dateStr) === false && reg2.test(dateStr) === false) {
+                return false;
+            }
+            // Split into 3 parts based on what the divider was
+            var parts = dateStr.split(RegExp.$1);
+            var mm, dd, yy;
+            // Check to see if the 3 parts end up making a valid date
+            if (format.substring(0, 1) === "M") {
+                mm = parts[0];
+            } else if (format.substring(1, 2) === "M") {
+                mm = parts[1];
+            } else {
+                mm = parts[2];
+            }
+            if (format.substring(0, 1) === "D") {
+                dd = parts[0];
+            } else if (format.substring(1, 2) === "D") {
+                dd = parts[1];
+            } else {
+                dd = parts[2];
+            }
+            if (format.substring(0, 1) === "Y") {
+                yy = parts[0];
+            } else if (format.substring(1, 2) === "Y") {
+                yy = parts[1];
+            } else {
+                yy = parts[2];
+            }
+            if (parseInt(yy, 10) <= 50) {
+                yy = (parseInt(yy, 10) + 2000).toString();
+            }
+            if (parseInt(yy, 10) <= 99) {
+                yy = (parseInt(yy, 10) + 1900).toString();
+            }
+            var dt = new Date(parseInt(yy, 10), parseInt(mm, 10) - 1, parseInt(dd, 10), 0, 0, 0, 0);
+            if (parseInt(dd, 10) != dt.getDate()) {
+                return false;
+            }
+            if (parseInt(mm, 10) - 1 != dt.getMonth()) {
+                return false;
+            }
+            return true;
+        },
+        format: (function (_format) {
+            var _formatWrapper = function format(_x, _x2) {
+                return _format.apply(this, arguments);
+            };
+
+            _formatWrapper.toString = function () {
+                return _format.toString();
+            };
+
+            return _formatWrapper;
+        })(function (dateStr, format) {
+            if (!format) {
+                format = "DMY";
+            }
+            if (!dateStr || dateStr === "") {
+                return new Date(1001, 0, 1);
+            }
+            var oDate, parts;
+
+            function y2kDate(yr) {
+                if (yr === undefined) {
+                    return 0;
+                }
+                if (yr.length > 2) {
+                    return yr;
+                }
+                var y;
+                //>50 belong to 1900
+                if (yr <= 99 && yr > 50) {
+                    y = "19" + yr;
+                }
+                //<50 belong to 2000
+                if (yr < 50 || yr === "00") {
+                    y = "20" + yr;
+                }
+                return y;
+            }
+
+            function mmm2mm(mmm) {
+                if (mmm === undefined) {
+                    return 0;
+                }
+                var mondigit;
+                var MONTH_NAMES = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december", "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+                for (var m_i = 0; m_i < MONTH_NAMES.length; m_i++) {
+                    var month_name = MONTH_NAMES[m_i];
+                    if (mmm.toLowerCase() === month_name) {
+                        mondigit = m_i + 1;
+                        break;
+                    }
+                }
+                if (mondigit > 11 || mondigit < 23) {
+                    mondigit = mondigit - 12;
+                }
+                if (mondigit < 1 || mondigit > 12) {
+                    return 0;
+                }
+                return mondigit;
+            }
+
+            switch (format.toUpperCase()) {
+                case "DDMMMYYYY":
+                    parts = dateStr.replace(/[- \/.]/g, " ").split(" ");
+                    oDate = new Date(y2kDate(parts[2]), mmm2mm(parts[1]) - 1, parts[0]);
+                    break;
+                case "DMY":
+                    parts = dateStr.replace(/^(0?[1-9]|[12][0-9]|3[01])([- \/.])(0?[1-9]|1[012])([- \/.])((\d\d)?\d\d)$/, "$1 $3 $5").split(" ");
+                    oDate = new Date(y2kDate(parts[2]), parts[1] - 1, parts[0]);
+                    break;
+                case "MDY":
+                    parts = dateStr.replace(/^(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])([- \/.])((\d\d)?\d\d)$/, "$1 $3 $5").split(" ");
+                    oDate = new Date(y2kDate(parts[2]), parts[0] - 1, parts[1]);
+                    break;
+                case "YMD":
+                    parts = dateStr.replace(/^((\d\d)?\d\d)([- \/.])(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])$/, "$1 $4 $6").split(" ");
+                    oDate = new Date(y2kDate(parts[0]), parts[1] - 1, parts[2]);
+                    break;
+                default:
+                    //in case format is not correct
+                    parts = dateStr.replace(/^(0?[1-9]|[12][0-9]|3[01])([- \/.])(0?[1-9]|1[012])([- \/.])((\d\d)?\d\d)$/, "$1 $3 $5").split(" ");
+                    oDate = new Date(y2kDate(parts[2]), parts[1] - 1, parts[0]);
+                    break;
+            }
+            return oDate;
+        })
+    };
+
+    exports.DateHelper = DateHelper;
+});
+//# sourceMappingURL=date.js.map;
+define('helpers',["exports"], function (exports) {
+    "use strict";
+
+    /**
+     * Misc helpers
+     */
+
+    var Helpers = {
+        isIE: function isIE() {
+            return /msie|MSIE/.test(navigator.userAgent);
+        },
+
+        removeNbFormat: function removeNbFormat(data, format) {
+            if (!data) {
+                return;
+            }
+            if (!format) {
+                format = "us";
+            }
+            var n = data;
+            if (str.lower(format) === "us") {
+                n = +n.replace(/[^\d\.-]/g, "");
+            } else {
+                n = +n.replace(/[^\d\,-]/g, "").replace(",", ".");
+            }
+            return n;
+        }
+    };
+
+    exports.Helpers = Helpers;
+});
+//# sourceMappingURL=helpers.js.map;
+define('extensions/sortabletable/adapterSortabletable',["exports", "module", "../../types", "../../dom", "../../array", "../../event", "../../date", "../../helpers"], function (exports, module, _types, _dom, _array, _event, _date, _helpers) {
+    "use strict";
+
+    var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
+
+    var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
+
+    var Types = _types.Types;
+    var Dom = _dom.Dom;
+    var array = _array.Arr;
+    var Event = _event.Event;
+    var DateHelper = _date.DateHelper;
+    var Helpers = _helpers.Helpers;
+
+    var AdapterSortableTable = (function () {
+
+        /**
+         * SortableTable Adapter module
+         * @param {Object} tf TableFilter instance
+         */
+
+        function AdapterSortableTable(tf) {
+            _classCallCheck(this, AdapterSortableTable);
+
+            // Configuration object
+            var f = tf.config();
+
+            this.isPaged = false;
+
+            //indicates if tables was sorted
+            this.sorted = false;
+
+            // edit .sort-arrow.descending / .sort-arrow.ascending in filtergrid.css
+            // to reflect any path change
+            this.sortImgPath = f.sort_images_path || tf.themesPath;
+            this.sortImgBlank = f.sort_image_blank || "blank.png";
+            this.sortImgClassName = f.sort_image_class_name || "sort-arrow";
+            this.sortImgAscClassName = f.sort_image_asc_class_name || "ascending";
+            this.sortImgDescClassName = f.sort_image_desc_class_name || "descending";
+            //cell attribute storing custom key
+            this.sortCustomKey = f.sort_custom_key || "data-tf-sortKey";
+
+            /*** TF additional events ***/
+            //additional paging events for alternating background
+            // o.Evt._Paging.nextEvt = function(){ if(o.sorted && o.alternateBgs) o.Filter(); }
+            // o.Evt._Paging.prevEvt = o.Evt._Paging.nextEvt;
+            // o.Evt._Paging.firstEvt = o.Evt._Paging.nextEvt;
+            // o.Evt._Paging.lastEvt = o.Evt._Paging.nextEvt;
+            // o.Evt._OnSlcPagesChangeEvt = o.Evt._Paging.nextEvt;
+
+            // callback invoked after sort is loaded and instanciated
+            this.onSortLoaded = Types.isFn(f.on_sort_loaded) ? f.on_sort_loaded : null;
+            // callback invoked before table is sorted
+            this.onBeforeSort = Types.isFn(f.on_before_sort) ? f.on_before_sort : null;
+            // callback invoked after table is sorted
+            this.onAfterSort = Types.isFn(f.on_after_sort) ? f.on_after_sort : null;
+
+            this.tf = tf;
+        }
+
+        _prototypeProperties(AdapterSortableTable, null, {
+            init: {
+                value: function init() {
+                    var tf = this.tf;
+                    var sortConfig = tf.sortConfig;
+
+                    // SortableTable class sanity check (sortabletable.js)
+                    if (Types.isUndef(SortableTable)) {
+                        throw new Error("SortableTable class not found.");
+                    }
+
+                    this.overrideSortableTable();
+                    this.setSortTypes();
+
+                    //Column sort at start
+                    if (sortConfig.sortCol) {
+                        this.stt.sort(sortConfig.sortCol[0], sortConfig.sortCol[1]);
+                    }
+
+                    tf.isSortEnabled = true;
+                    if (this.onSortLoaded) {
+                        this.onSortLoaded.call(null, tf, this);
+                    }
+
+                    /*** SortableTable callbacks ***/
+                    this.stt.onbeforesort = function () {
+                        if (this.onBeforeSort) {
+                            this.onBeforeSort.call(null, tf, this.stt.sortColumn);
+                        }
+
+                        tf.performSort();
+
+                        /*** sort behaviour for paging ***/
+                        if (tf.paging) {
+                            this.isPaged = true;
+                            tf.paging = false;
+                            tf.Cpt.paging.destroy();
+                        }
+                    };
+
+                    this.stt.onsort = function () {
+                        this.sorted = true;
+
+                        //rows alternating bg issue
+                        // TODO: move into AlternateRows component
+                        if (tf.alternateBgs) {
+                            var rows = tf.tbl.rows,
+                                c = 0;
+
+                            var setClass = function setClass(row, i, removeOnly) {
+                                if (Types.isUndef(removeOnly)) {
+                                    removeOnly = false;
+                                }
+                                var altRows = tf.Cpt.alternateRows,
+                                    oddCls = altRows.oddCss,
+                                    evenCls = altRows.evenCss;
+                                Dom.removeClass(row, oddCls);
+                                Dom.removeClass(row, evenCls);
+
+                                if (!removeOnly) {
+                                    Dom.addClass(row, i % 2 ? oddCls : evenCls);
+                                }
+                            };
+
+                            for (var i = tf.refRow; i < tf.nbRows; i++) {
+                                var isRowValid = rows[i].getAttribute("validRow");
+                                if (tf.paging && rows[i].style.display === "") {
+                                    setClass(rows[i], c);
+                                    c++;
+                                } else {
+                                    if ((isRowValid === "true" || isRowValid === null) && rows[i].style.display === "") {
+                                        setClass(rows[i], c);
+                                        c++;
+                                    } else {
+                                        setClass(rows[i], c, true);
+                                    }
+                                }
+                            }
+                        }
+                        //sort behaviour for paging
+                        if (this.isPaged) {
+                            var paginator = tf.Cpt.paging,
+                                config = tf.config();
+                            if (paginator.hasResultsPerPage) {
+                                var slc = paginator.resultsPerPageSlc;
+                                config.paging_length = slc.options[slc.selectedIndex].value;
+                            }
+                            paginator.addPaging(false);
+                            paginator.setPage(paginator.currentPageNb);
+                            this.isPaged = false;
+                        }
+
+                        if (this.onAfterSort) {
+                            this.onAfterSort.call(null, tf, tf.stt.sortColumn);
+                        }
+                    };
+                },
+                writable: true,
+                configurable: true
+            },
+            overrideSortableTable: {
+                value: function overrideSortableTable() {
+                    var adpt = this,
+                        tf = this.tf;
+
+                    /**
+                     * Overrides headerOnclick method in order to handle th event
+                     * @param  {Object} e [description]
+                     */
+                    SortableTable.prototype.headerOnclick = function (evt) {
+                        if (!tf.sort) {
+                            return;
+                        }
+                        // find Header element
+                        var el = evt.target || evt.srcElement,
+                            tagName = el.tagName;
+
+                        while (tagName !== "TD" && tagName !== "TH") {
+                            el = el.parentNode;
+                        }
+
+                        this.sort(SortableTable.msie ? SortableTable.getCellIndex(el) : el.cellIndex);
+                    };
+
+                    /**
+                     * Overrides getCellIndex IE returns wrong cellIndex when columns are
+                     * hidden
+                     * @param  {Object} oTd TD element
+                     * @return {Number}     Cell index
+                     */
+                    SortableTable.getCellIndex = function (oTd) {
+                        var cells = oTd.parentNode.cells,
+                            l = cells.length,
+                            i;
+                        for (i = 0; cells[i] != oTd && i < l; i++) {}
+                        return i;
+                    };
+
+                    /**
+                     * Overrides initHeader in order to handle filters row position
+                     * @param  {Array} oSortTypes
+                     */
+                    SortableTable.prototype.initHeader = function (oSortTypes) {
+                        var stt = this;
+                        if (!stt.tHead) {
+                            throw new Error("Sorting feature requires a THEAD element");
+                        }
+                        stt.headersRow = tf.headersRow;
+                        var cells = stt.tHead.rows[stt.headersRow].cells;
+                        var doc = stt.tHead.ownerDocument || stt.tHead.document;
+                        stt.sortTypes = oSortTypes || [];
+                        var l = cells.length;
+                        var img, c;
+                        for (var i = 0; i < l; i++) {
+                            c = cells[i];
+                            if (stt.sortTypes[i] !== null && stt.sortTypes[i] !== "None") {
+                                c.style.cursor = "pointer";
+                                img = Dom.create("img", ["src", adpt.sortImgPath + adpt.sortImgBlank]);
+                                c.appendChild(img);
+                                if (stt.sortTypes[i] !== null) {
+                                    c.setAttribute("_sortType", stt.sortTypes[i]);
+                                }
+                                Event.add(c, "click", stt._headerOnclick);
+                            } else {
+                                c.setAttribute("_sortType", oSortTypes[i]);
+                                c._sortType = "None";
+                            }
+                        }
+                        stt.updateHeaderArrows();
+                    };
+
+                    /**
+                     * Overrides updateHeaderArrows in order to handle arrows indicators
+                     */
+                    SortableTable.prototype.updateHeaderArrows = function () {
+                        var stt = this;
+                        var cells, l, img;
+                        // external headers
+                        if (tf.sortConfig.asyncSort && tf.sortConfig.triggerIds !== null) {
+                            var triggers = tf.sortConfig.triggerIds;
+                            cells = [];
+                            l = triggers.length;
+                            for (var j = 0; j < triggers.length; j++) {
+                                cells.push(Dom.id(triggers[j]));
+                            }
+                        } else {
+                            if (!this.tHead) {
+                                return;
+                            }
+                            cells = stt.tHead.rows[stt.headersRow].cells;
+                            l = cells.length;
+                        }
+                        for (var i = 0; i < l; i++) {
+                            var cellAttr = cells[i].getAttribute("_sortType");
+                            if (cellAttr !== null && cellAttr !== "None") {
+                                img = cells[i].lastChild || cells[i];
+                                if (img.nodeName.toLowerCase() !== "img") {
+                                    img = Dom.create("img", ["src", adpt.sortImgPath + adpt.sortImgBlank]);
+                                    cells[i].appendChild(img);
+                                }
+                                if (i === stt.sortColumn) {
+                                    img.className = adpt.sortImgClassName + " " + (this.descending ? adpt.sortImgDescClassName : adpt.sortImgAscClassName);
+                                } else {
+                                    img.className = adpt.sortImgClassName;
+                                }
+                            }
+                        }
+                    };
+
+                    /**
+                     * Overrides getRowValue for custom key value feature
+                     * @param  {Object} oRow    Row element
+                     * @param  {String} sType
+                     * @param  {Number} nColumn
+                     * @return {String}
+                     */
+                    SortableTable.prototype.getRowValue = function (oRow, sType, nColumn) {
+                        var stt = this;
+                        // if we have defined a custom getRowValue use that
+                        var sortTypeInfo = stt._sortTypeInfo[sType];
+                        if (sortTypeInfo && sortTypeInfo.getRowValue) {
+                            return sortTypeInfo.getRowValue(oRow, nColumn);
+                        }
+                        var c = oRow.cells[nColumn];
+                        var s = SortableTable.getInnerText(c);
+                        return stt.getValueFromString(s, sType);
+                    };
+
+                    /**
+                     * Overrides getInnerText in order to avoid Firefox unexpected sorting
+                     * behaviour with untrimmed text elements
+                     * @param  {Object} oNode DOM element
+                     * @return {String}       DOM element inner text
+                     */
+                    SortableTable.getInnerText = function (oNode) {
+                        if (oNode.getAttribute(tf.sortCustomKey) != null) {
+                            return oNode.getAttribute(tf.sortCustomKey);
+                        } else {
+                            return Dom.getText(oNode);
+                        }
+                    };
+                },
+                writable: true,
+                configurable: true
+            },
+            setSortTypes: {
+                value: function setSortTypes() {
+                    var _this = this;
+
+                    var tf = this.tf,
+                        configSort = tf.sortConfig,
+                        configSortTypes = configSort.sortTypes,
+                        sortTypes = [];
+
+                    for (var i = 0; i < tf.nbCells; i++) {
+                        var colType;
+
+                        if (configSortTypes !== null && configSortTypes[i] != null) {
+                            colType = configSortTypes[i].toLowerCase();
+                            if (colType === "none") {
+                                colType = "None";
+                            }
+                        } else {
+                            // resolve column types
+                            if (tf.hasColNbFormat && tf.colNbFormat[i] !== null) {
+                                colType = tf.colNbFormat[i].toLowerCase();
+                            } else if (tf.hasColDateType && tf.colDateType[i] !== null) {
+                                colType = tf.colDateType[i].toLowerCase() + "date";
+                            } else {
+                                colType = "String";
+                            }
+                        }
+                        sortTypes.push(colType);
+                    }
+
+                    //Public TF method to add sort type
+                    this.addSortType = function () {
+                        SortableTable.prototype.addSortType(arguments[0], arguments[1], arguments[2], arguments[3]);
+                    };
+
+                    //Custom sort types
+                    this.addSortType("number", Number);
+                    this.addSortType("caseinsensitivestring", SortableTable.toUpperCase);
+                    this.addSortType("date", SortableTable.toDate);
+                    this.addSortType("string");
+                    this.addSortType("us", this.usNumberConverter);
+                    this.addSortType("eu", this.euNumberConverter);
+                    this.addSortType("dmydate", this.dmyDateConverter);
+                    this.addSortType("ymddate", this.ymdDateConverter);
+                    this.addSortType("mdydate", this.mdyDateConverter);
+                    this.addSortType("ddmmmyyyydate", this.ddmmmyyyyDateConverter);
+                    this.addSortType("ipaddress", this.ipAddress, this.sortIP);
+
+                    this.stt = new SortableTable(tf.tbl, sortTypes);
+
+                    /*** external table headers adapter ***/
+                    if (configSort.asyncSort && configSort.triggerIds !== null) {
+                        var triggers = configSort.triggerIds;
+                        for (var j = 0; j < triggers.length; j++) {
+                            if (triggers[j] === null) {
+                                continue;
+                            }
+                            var trigger = Dom.id(triggers[j]);
+                            if (trigger) {
+                                trigger.style.cursor = "pointer";
+                                // trigger.onclick = function(){
+                                //     if(o.sort)
+                                //         o.st.asyncSort( triggers.tf_IndexByValue(this.id, true) );
+                                // }
+                                Event.add(trigger, "click", function (evt) {
+                                    var elm = evt.target;
+                                    if (!_this.tf.sort) {
+                                        return;
+                                    }
+                                    _this.stt.asyncSort(
+                                    // triggers.tf_IndexByValue(this.id, true)
+                                    Arr.indexByValue(triggers, elm.id, true));
+                                });
+                                trigger.setAttribute("_sortType", sortTypes[j]);
+                            }
+                        }
+                    }
+                },
+                writable: true,
+                configurable: true
+            },
+            usNumberConverter: {
+
+                //Converters
+
+                value: function usNumberConverter(s) {
+                    return Helpers.removeNbFormat(s, "us");
+                },
+                writable: true,
+                configurable: true
+            },
+            euNumberConverter: {
+                value: function euNumberConverter(s) {
+                    return Helpers.removeNbFormat(s, "eu");
+                },
+                writable: true,
+                configurable: true
+            },
+            dateConverter: {
+                value: function dateConverter(s, format) {
+                    return DateHelper.format(s, format);
+                },
+                writable: true,
+                configurable: true
+            },
+            dmyDateConverter: {
+                value: function dmyDateConverter(s) {
+                    return this.dateConverter(s, "DMY");
+                },
+                writable: true,
+                configurable: true
+            },
+            mdyDateConverter: {
+                value: function mdyDateConverter(s) {
+                    return this.dateConverter(s, "MDY");
+                },
+                writable: true,
+                configurable: true
+            },
+            ymdDateConverter: {
+                value: function ymdDateConverter(s) {
+                    return this.dateConverter(s, "YMD");
+                },
+                writable: true,
+                configurable: true
+            },
+            ddmmmyyyyDateConverter: {
+                value: function ddmmmyyyyDateConverter(s) {
+                    return this.dateConverter(s, "DDMMMYYYY");
+                },
+                writable: true,
+                configurable: true
+            },
+            ipAddress: {
+                value: function ipAddress(value) {
+                    var vals = value.split(".");
+                    for (var x in vals) {
+                        var val = vals[x];
+                        while (3 > val.length) {
+                            val = "0" + val;
+                        }
+                        vals[x] = val;
+                    }
+                    return vals.join(".");
+                },
+                writable: true,
+                configurable: true
+            },
+            sortIP: {
+                value: function sortIP(a, b) {
+                    var aa = this.ipAddress(a.value.toLowerCase());
+                    var bb = this.ipAddress(b.value.toLowerCase());
+                    if (aa == bb) {
+                        return 0;
+                    } else if (aa < bb) {
+                        return -1;
+                    } else {
+                        return 1;
+                    }
+                },
+                writable: true,
+                configurable: true
+            }
+        });
+
+        return AdapterSortableTable;
+    })();
+
+    module.exports = AdapterSortableTable;
+});
+//# sourceMappingURL=adapterSortabletable.js.map;
+/*----------------------------------------------------------------------------\
+|                            Sortable Table 1.12                              |
+|-----------------------------------------------------------------------------|
+|                         Created by Erik Arvidsson                           |
+|                  (http://webfx.eae.net/contact.html#erik)                   |
+|                      For WebFX (http://webfx.eae.net/)                      |
+|-----------------------------------------------------------------------------|
+| A DOM 1 based script that allows an ordinary HTML table to be sortable.     |
+|-----------------------------------------------------------------------------|
+|                  Copyright (c) 1998 - 2006 Erik Arvidsson                   |
+|-----------------------------------------------------------------------------|
+| Licensed under the Apache License, Version 2.0 (the "License"); you may not |
+| use this file except in compliance with the License.  You may obtain a copy |
+| of the License at http://www.apache.org/licenses/LICENSE-2.0                |
+| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
+| Unless  required  by  applicable law or  agreed  to  in  writing,  software |
+| distributed under the License is distributed on an  "AS IS" BASIS,  WITHOUT |
+| WARRANTIES OR  CONDITIONS OF ANY KIND,  either express or implied.  See the |
+| License  for the  specific language  governing permissions  and limitations |
+| under the License.                                                          |
+|-----------------------------------------------------------------------------|
+| 2003-01-10 | First version                                                  |
+| 2003-01-19 | Minor changes to the date parsing                              |
+| 2003-01-28 | JScript 5.0 fixes (no support for 'in' operator)               |
+| 2003-02-01 | Sloppy typo like error fixed in getInnerText                   |
+| 2003-07-04 | Added workaround for IE cellIndex bug.                         |
+| 2003-11-09 | The bDescending argument to sort was not correctly working     |
+|            | Using onclick DOM0 event if no support for addEventListener    |
+|            | or attachEvent                                                 |
+| 2004-01-13 | Adding addSortType and removeSortType which makes it a lot     |
+|            | easier to add new, custom sort types.                          |
+| 2004-01-27 | Switch to use descending = false as the default sort order.    |
+|            | Change defaultDescending to suit your needs.                   |
+| 2004-03-14 | Improved sort type None look and feel a bit                    |
+| 2004-08-26 | Made the handling of tBody and tHead more flexible. Now you    |
+|            | can use another tHead or no tHead, and you can chose some      |
+|            | other tBody.                                                   |
+| 2006-04-25 | Changed license to Apache Software License 2.0                 |
+|-----------------------------------------------------------------------------|
+| Created 2003-01-10 | All changes are in the log above. | Updated 2006-04-25 |
+\----------------------------------------------------------------------------*/
+
+
+function SortableTable(oTable, oSortTypes) {
+
+	this.sortTypes = oSortTypes || [];
+
+	this.sortColumn = null;
+	this.descending = null;
+
+	var oThis = this;
+	this._headerOnclick = function (e) {
+		oThis.headerOnclick(e);
+	};
+
+	if (oTable) {
+		this.setTable( oTable );
+		this.document = oTable.ownerDocument || oTable.document;
+	}
+	else {
+		this.document = document;
+	}
+
+
+	// only IE needs this
+	var win = this.document.defaultView || this.document.parentWindow;
+	this._onunload = function () {
+		oThis.destroy();
+	};
+	if (win && typeof win.attachEvent != "undefined") {
+		win.attachEvent("onunload", this._onunload);
+	}
+}
+
+SortableTable.gecko = navigator.product == "Gecko";
+SortableTable.msie = /msie/i.test(navigator.userAgent);
+// Mozilla is faster when doing the DOM manipulations on
+// an orphaned element. MSIE is not
+SortableTable.removeBeforeSort = SortableTable.gecko;
+
+SortableTable.prototype.onsort = function () {};
+
+// default sort order. true -> descending, false -> ascending
+SortableTable.prototype.defaultDescending = false;
+
+// shared between all instances. This is intentional to allow external files
+// to modify the prototype
+SortableTable.prototype._sortTypeInfo = {};
+
+SortableTable.prototype.setTable = function (oTable) {
+	if ( this.tHead )
+		this.uninitHeader();
+	this.element = oTable;
+	this.setTHead( oTable.tHead );
+	this.setTBody( oTable.tBodies[0] );
+};
+
+SortableTable.prototype.setTHead = function (oTHead) {
+	if (this.tHead && this.tHead != oTHead )
+		this.uninitHeader();
+	this.tHead = oTHead;
+	this.initHeader( this.sortTypes );
+};
+
+SortableTable.prototype.setTBody = function (oTBody) {
+	this.tBody = oTBody;
+};
+
+SortableTable.prototype.setSortTypes = function ( oSortTypes ) {
+	if ( this.tHead )
+		this.uninitHeader();
+	this.sortTypes = oSortTypes || [];
+	if ( this.tHead )
+		this.initHeader( this.sortTypes );
+};
+
+// adds arrow containers and events
+// also binds sort type to the header cells so that reordering columns does
+// not break the sort types
+SortableTable.prototype.initHeader = function (oSortTypes) {
+	if (!this.tHead) return;
+	var cells = this.tHead.rows[0].cells;
+	var doc = this.tHead.ownerDocument || this.tHead.document;
+	this.sortTypes = oSortTypes || [];
+	var l = cells.length;
+	var img, c;
+	for (var i = 0; i < l; i++) {
+		c = cells[i];
+		if (this.sortTypes[i] != null && this.sortTypes[i] != "None") {
+			img = doc.createElement("IMG");
+			img.src = "images/blank.png";
+			c.appendChild(img);
+			if (this.sortTypes[i] != null)
+				c._sortType = this.sortTypes[i];
+			if (typeof c.addEventListener != "undefined")
+				c.addEventListener("click", this._headerOnclick, false);
+			else if (typeof c.attachEvent != "undefined")
+				c.attachEvent("onclick", this._headerOnclick);
+			else
+				c.onclick = this._headerOnclick;
+		}
+		else
+		{
+			c.setAttribute( "_sortType", oSortTypes[i] );
+			c._sortType = "None";
+		}
+	}
+	this.updateHeaderArrows();
+};
+
+// remove arrows and events
+SortableTable.prototype.uninitHeader = function () {
+	if (!this.tHead) return;
+	var cells = this.tHead.rows[0].cells;
+	var l = cells.length;
+	var c;
+	for (var i = 0; i < l; i++) {
+		c = cells[i];
+		if (c._sortType != null && c._sortType != "None") {
+			c.removeChild(c.lastChild);
+			if (typeof c.removeEventListener != "undefined")
+				c.removeEventListener("click", this._headerOnclick, false);
+			else if (typeof c.detachEvent != "undefined")
+				c.detachEvent("onclick", this._headerOnclick);
+			c._sortType = null;
+			c.removeAttribute( "_sortType" );
+		}
+	}
+};
+
+SortableTable.prototype.updateHeaderArrows = function () {
+	if (!this.tHead) return;
+	var cells = this.tHead.rows[0].cells;
+	var l = cells.length;
+	var img;
+	for (var i = 0; i < l; i++) {
+		if (cells[i]._sortType != null && cells[i]._sortType != "None") {
+			img = cells[i].lastChild;
+			if (i == this.sortColumn)
+				img.className = "sort-arrow " + (this.descending ? "descending" : "ascending");
+			else
+				img.className = "sort-arrow";
+		}
+	}
+};
+
+SortableTable.prototype.headerOnclick = function (e) {
+	// find TD element
+	var el = e.target || e.srcElement;
+	while (el.tagName != "TD")
+		el = el.parentNode;
+
+	this.sort(SortableTable.msie ? SortableTable.getCellIndex(el) : el.cellIndex);
+};
+
+// IE returns wrong cellIndex when columns are hidden
+SortableTable.getCellIndex = function (oTd) {
+	var cells = oTd.parentNode.childNodes
+	var l = cells.length;
+	var i;
+	for (i = 0; cells[i] != oTd && i < l; i++)
+		;
+	return i;
+};
+
+SortableTable.prototype.getSortType = function (nColumn) {
+	return this.sortTypes[nColumn] || "String";
+};
+
+// only nColumn is required
+// if bDescending is left out the old value is taken into account
+// if sSortType is left out the sort type is found from the sortTypes array
+
+SortableTable.prototype.sort = function (nColumn, bDescending, sSortType) {
+	if (!this.tBody) return;
+	if (sSortType == null)
+		sSortType = this.getSortType(nColumn);
+
+	// exit if None
+	if (sSortType == "None")
+		return;
+
+	if (bDescending == null) {
+		if (this.sortColumn != nColumn)
+			this.descending = this.defaultDescending;
+		else
+			this.descending = !this.descending;
+	}
+	else
+		this.descending = bDescending;
+
+	this.sortColumn = nColumn;
+
+	if (typeof this.onbeforesort == "function")
+		this.onbeforesort();
+
+	var f = this.getSortFunction(sSortType, nColumn);
+	var a = this.getCache(sSortType, nColumn);
+	var tBody = this.tBody;
+
+	a.sort(f);
+
+	if (this.descending)
+		a.reverse();
+
+	if (SortableTable.removeBeforeSort) {
+		// remove from doc
+		var nextSibling = tBody.nextSibling;
+		var p = tBody.parentNode;
+		p.removeChild(tBody);
+	}
+
+	// insert in the new order
+	var l = a.length;
+	for (var i = 0; i < l; i++)
+		tBody.appendChild(a[i].element);
+
+	if (SortableTable.removeBeforeSort) {
+		// insert into doc
+		p.insertBefore(tBody, nextSibling);
+	}
+
+	this.updateHeaderArrows();
+
+	this.destroyCache(a);
+
+	if (typeof this.onsort == "function")
+		this.onsort();
+};
+
+SortableTable.prototype.asyncSort = function (nColumn, bDescending, sSortType) {
+	var oThis = this;
+	this._asyncsort = function () {
+		oThis.sort(nColumn, bDescending, sSortType);
+	};
+	window.setTimeout(this._asyncsort, 1);
+};
+
+SortableTable.prototype.getCache = function (sType, nColumn) {
+	if (!this.tBody) return [];
+	var rows = this.tBody.rows;
+	var l = rows.length;
+	var a = new Array(l);
+	var r;
+	for (var i = 0; i < l; i++) {
+		r = rows[i];
+		a[i] = {
+			value:		this.getRowValue(r, sType, nColumn),
+			element:	r
+		};
+	};
+	return a;
+};
+
+SortableTable.prototype.destroyCache = function (oArray) {
+	var l = oArray.length;
+	for (var i = 0; i < l; i++) {
+		oArray[i].value = null;
+		oArray[i].element = null;
+		oArray[i] = null;
+	}
+};
+
+SortableTable.prototype.getRowValue = function (oRow, sType, nColumn) {
+	// if we have defined a custom getRowValue use that
+	if (this._sortTypeInfo[sType] && this._sortTypeInfo[sType].getRowValue)
+		return this._sortTypeInfo[sType].getRowValue(oRow, nColumn);
+
+	var s;
+	var c = oRow.cells[nColumn];
+	if (typeof c.innerText != "undefined")
+		s = c.innerText;
+	else
+		s = SortableTable.getInnerText(c);
+	return this.getValueFromString(s, sType);
+};
+
+SortableTable.getInnerText = function (oNode) {
+	var s = "";
+	var cs = oNode.childNodes;
+	var l = cs.length;
+	for (var i = 0; i < l; i++) {
+		switch (cs[i].nodeType) {
+			case 1: //ELEMENT_NODE
+				s += SortableTable.getInnerText(cs[i]);
+				break;
+			case 3:	//TEXT_NODE
+				s += cs[i].nodeValue;
+				break;
+		}
+	}
+	return s;
+};
+
+SortableTable.prototype.getValueFromString = function (sText, sType) {
+	if (this._sortTypeInfo[sType])
+		return this._sortTypeInfo[sType].getValueFromString( sText );
+	return sText;
+	/*
+	switch (sType) {
+		case "Number":
+			return Number(sText);
+		case "CaseInsensitiveString":
+			return sText.toUpperCase();
+		case "Date":
+			var parts = sText.split("-");
+			var d = new Date(0);
+			d.setFullYear(parts[0]);
+			d.setDate(parts[2]);
+			d.setMonth(parts[1] - 1);
+			return d.valueOf();
+	}
+	return sText;
+	*/
+	};
+
+SortableTable.prototype.getSortFunction = function (sType, nColumn) {
+	if (this._sortTypeInfo[sType])
+		return this._sortTypeInfo[sType].compare;
+	return SortableTable.basicCompare;
+};
+
+SortableTable.prototype.destroy = function () {
+	this.uninitHeader();
+	var win = this.document.parentWindow;
+	if (win && typeof win.detachEvent != "undefined") {	// only IE needs this
+		win.detachEvent("onunload", this._onunload);
+	}
+	this._onunload = null;
+	this.element = null;
+	this.tHead = null;
+	this.tBody = null;
+	this.document = null;
+	this._headerOnclick = null;
+	this.sortTypes = null;
+	this._asyncsort = null;
+	this.onsort = null;
+};
+
+// Adds a sort type to all instance of SortableTable
+// sType : String - the identifier of the sort type
+// fGetValueFromString : function ( s : string ) : T - A function that takes a
+//    string and casts it to a desired format. If left out the string is just
+//    returned
+// fCompareFunction : function ( n1 : T, n2 : T ) : Number - A normal JS sort
+//    compare function. Takes two values and compares them. If left out less than,
+//    <, compare is used
+// fGetRowValue : function( oRow : HTMLTRElement, nColumn : int ) : T - A function
+//    that takes the row and the column index and returns the value used to compare.
+//    If left out then the innerText is first taken for the cell and then the
+//    fGetValueFromString is used to convert that string the desired value and type
+
+SortableTable.prototype.addSortType = function (sType, fGetValueFromString, fCompareFunction, fGetRowValue) {
+	this._sortTypeInfo[sType] = {
+		type:				sType,
+		getValueFromString:	fGetValueFromString || SortableTable.idFunction,
+		compare:			fCompareFunction || SortableTable.basicCompare,
+		getRowValue:		fGetRowValue
+	};
+};
+
+// this removes the sort type from all instances of SortableTable
+SortableTable.prototype.removeSortType = function (sType) {
+	delete this._sortTypeInfo[sType];
+};
+
+SortableTable.basicCompare = function compare(n1, n2) {
+	if (n1.value < n2.value)
+		return -1;
+	if (n2.value < n1.value)
+		return 1;
+	return 0;
+};
+
+SortableTable.idFunction = function (x) {
+	return x;
+};
+
+SortableTable.toUpperCase = function (s) {
+	return s.toUpperCase();
+};
+
+SortableTable.toDate = function (s) {
+	var parts = s.split("-");
+	var d = new Date(0);
+	d.setFullYear(parts[0]);
+	d.setDate(parts[2]);
+	d.setMonth(parts[1] - 1);
+	return d.valueOf();
+};
+
+
+// add sort types
+SortableTable.prototype.addSortType("Number", Number);
+SortableTable.prototype.addSortType("CaseInsensitiveString", SortableTable.toUpperCase);
+SortableTable.prototype.addSortType("Date", SortableTable.toDate);
+SortableTable.prototype.addSortType("String");
+// None is a special case
+;
+define("extensions/sortabletable/sortabletable", function(){});
+
+
+    return require('extensions/sortabletable/adapterSortabletable');
+
+});
\ No newline at end of file
diff --git a/dist/filtergrid.css b/dist/filtergrid.css
index a20dc1ce..46e891ad 100644
--- a/dist/filtergrid.css
+++ b/dist/filtergrid.css
@@ -1,6 +1,6 @@
 /*------------------------------------------------------------------------ 
 	- TableFilter stylesheet by Max Guglielmi 
-	- (build date: Sat Mar 14 2015 21:48:11) 
+	- (build date: Sun Mar 29 2015 20:55:57) 
 	- Edit below for your projects' needs  
 ------------------------------------------------------------------------*/ 
 
diff --git a/dist/index.html b/dist/index.html
new file mode 100644
index 00000000..6a5c142b
--- /dev/null
+++ b/dist/index.html
@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>HTML Table Filter Generator</title>
+    <link href="./filtergrid.css" rel="stylesheet" type="text/css">
+    <script type="text/javascript">
+        var tf;
+    </script>
+</head>
+<body>
+    <p align="right">
+        <input type="button" value="Reset paging"
+            onclick="
+                if( tf.paging ) return;
+                tf.Cpt.paging.addPaging();" >
+    <input type="button" value="Remove paging"
+        onclick="
+            if( !tf.paging ) return;
+            tf.paging = false; //behaviour is removed here
+            tf.Cpt.paging.destroy();
+            tf.Filter();" >
+    </p>
+    <div style="width: 900px;">
+        <table id="demo" cellpadding="0" cellspacing="0">
+            <thead>
+                <tr>
+                    <th>From</th>
+                    <th>Destination</th>
+                    <th>Road Distance (km)</th>
+                    <th>By Air (hrs)</th>
+                    <th>By Rail (hrs)</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Adelaide</td>
+                    <td>1412</td>
+                    <td>1.4</td>
+                    <td>25.3</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Brisbane</td>
+                    <td>982</td>
+                    <td>1.5</td>
+                    <td>16</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Canberra</td>
+                    <td>286</td>
+                    <td>.6</td>
+                    <td>4.3</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Melbourne</td>
+                    <td>872</td>
+                    <td>1.1</td>
+                    <td>10.5</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Perth</td>
+                    <td>2781</td>
+                    <td>3.1</td>
+                    <td>38</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Alice Springs</td>
+                    <td>1533</td>
+                    <td>2</td>
+                    <td>20.25</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Brisbane</td>
+                    <td>2045</td>
+                    <td>2.15</td>
+                    <td>40</td>
+                </tr>
+            </tbody>
+        </table>
+    </div>
+
+    <script src="../libs/requirejs/require.js"></script>
+    <script>
+        requirejs(['tablefilter'], function(TableFilter){
+            // Your logic here
+            tf = new TableFilter("demo", {
+                col_0: 'select',
+                col_2: 'multiple',
+                col_3: 'checklist',
+                base_path: './',
+                loader: false,
+                rows_counter: true,
+                enable_default_theme: true,
+                // slc_filling_method: 'innerhtml',
+                sort: true,
+                sort_config: {
+                    sort_types: ['string','string','number','number','number']
+                },
+                paging: true,
+                paging_length: 4,
+                // page_selector_type: 'input',
+                //results_per_page: ['Results per page', [2,4,6]],
+                remember_grid_values: true,
+                // remember_page_number: true,
+                // remember_page_length: true,
+                fill_slc_on_demand: false,
+                linked_filters: false,
+                popup_filters: false,
+                alternate_rows: true,
+                highlight_keywords: true,
+                match_case: false,
+                btn_reset: true,
+                status_bar: true,
+                watermark: [null, 'Filter column...', null, null, 'Helo'],
+                grid_layout: false,
+                // grid_width: '500px',
+                // grid_height: '200px',
+                on_before_show_msg: function(tf){
+                    // console.log('on_before_show_msg');
+                }
+            });
+
+            tf.init();
+        });
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dist/require.js b/dist/require.js
new file mode 100644
index 00000000..77a5bb1d
--- /dev/null
+++ b/dist/require.js
@@ -0,0 +1,2076 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.1.15 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+var requirejs, require, define;
+(function (global) {
+    var req, s, head, baseElement, dataMain, src,
+        interactiveScript, currentlyAddingScript, mainScript, subPath,
+        version = '2.1.15',
+        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+        jsSuffixRegExp = /\.js$/,
+        currDirRegExp = /^\.\//,
+        op = Object.prototype,
+        ostring = op.toString,
+        hasOwn = op.hasOwnProperty,
+        ap = Array.prototype,
+        apsp = ap.splice,
+        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
+        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                      /^complete$/ : /^(complete|loaded)$/,
+        defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+        contexts = {},
+        cfg = {},
+        globalDefQueue = [],
+        useInteractive = false;
+
+    function isFunction(it) {
+        return ostring.call(it) === '[object Function]';
+    }
+
+    function isArray(it) {
+        return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+        if (ary) {
+            var i;
+            for (i = ary.length - 1; i > -1; i -= 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function getOwn(obj, prop) {
+        return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+        var prop;
+        for (prop in obj) {
+            if (hasProp(obj, prop)) {
+                if (func(obj[prop], prop)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+        if (source) {
+            eachProp(source, function (value, prop) {
+                if (force || !hasProp(target, prop)) {
+                    if (deepStringMixin && typeof value === 'object' && value &&
+                        !isArray(value) && !isFunction(value) &&
+                        !(value instanceof RegExp)) {
+
+                        if (!target[prop]) {
+                            target[prop] = {};
+                        }
+                        mixin(target[prop], value, force, deepStringMixin);
+                    } else {
+                        target[prop] = value;
+                    }
+                }
+            });
+        }
+        return target;
+    }
+
+    //Similar to Function.prototype.bind, but the 'this' object is specified
+    //first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+        return function () {
+            return fn.apply(obj, arguments);
+        };
+    }
+
+    function scripts() {
+        return document.getElementsByTagName('script');
+    }
+
+    function defaultOnError(err) {
+        throw err;
+    }
+
+    //Allow getting a global that is expressed in
+    //dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+        if (!value) {
+            return value;
+        }
+        var g = global;
+        each(value.split('.'), function (part) {
+            g = g[part];
+        });
+        return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+        e.requireType = id;
+        e.requireModules = requireModules;
+        if (err) {
+            e.originalError = err;
+        }
+        return e;
+    }
+
+    if (typeof define !== 'undefined') {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    if (typeof requirejs !== 'undefined') {
+        if (isFunction(requirejs)) {
+            //Do not overwrite an existing requirejs instance.
+            return;
+        }
+        cfg = requirejs;
+        requirejs = undefined;
+    }
+
+    //Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+        //assume it is a config object.
+        cfg = require;
+        require = undefined;
+    }
+
+    function newContext(contextName) {
+        var inCheckLoaded, Module, context, handlers,
+            checkLoadedTimeoutId,
+            config = {
+                //Defaults. Do not set a default for map
+                //config to speed up normalize(), which
+                //will run faster if there is no default.
+                waitSeconds: 7,
+                baseUrl: './',
+                paths: {},
+                bundles: {},
+                pkgs: {},
+                shim: {},
+                config: {}
+            },
+            registry = {},
+            //registry of just enabled modules, to speed
+            //cycle breaking code when lots of modules
+            //are registered, but not activated.
+            enabledRegistry = {},
+            undefEvents = {},
+            defQueue = [],
+            defined = {},
+            urlFetched = {},
+            bundlesMap = {},
+            requireCounter = 1,
+            unnormalizedCounter = 1;
+
+        /**
+         * Trims the . and .. from an array of path segments.
+         * It will keep a leading path segment if a .. will become
+         * the first path segment, to help with module name lookups,
+         * which act like paths, but can be remapped. But the end result,
+         * all paths that use this function should look normalized.
+         * NOTE: this method MODIFIES the input array.
+         * @param {Array} ary the array of path segments.
+         */
+        function trimDots(ary) {
+            var i, part;
+            for (i = 0; i < ary.length; i++) {
+                part = ary[i];
+                if (part === '.') {
+                    ary.splice(i, 1);
+                    i -= 1;
+                } else if (part === '..') {
+                    // If at the start, or previous value is still ..,
+                    // keep them so that when converted to a path it may
+                    // still work when converted to a path, even though
+                    // as an ID it is less than ideal. In larger point
+                    // releases, may be better to just kick out an error.
+                    if (i === 0 || (i == 1 && ary[2] === '..') || ary[i - 1] === '..') {
+                        continue;
+                    } else if (i > 0) {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Given a relative module name, like ./something, normalize it to
+         * a real name that can be mapped to a path.
+         * @param {String} name the relative name
+         * @param {String} baseName a real name that the name arg is relative
+         * to.
+         * @param {Boolean} applyMap apply the map config to the value. Should
+         * only be done if this normalization is for a dependency ID.
+         * @returns {String} normalized name
+         */
+        function normalize(name, baseName, applyMap) {
+            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
+                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
+                baseParts = (baseName && baseName.split('/')),
+                map = config.map,
+                starMap = map && map['*'];
+
+            //Adjust any relative paths.
+            if (name) {
+                name = name.split('/');
+                lastIndex = name.length - 1;
+
+                // If wanting node ID compatibility, strip .js from end
+                // of IDs. Have to do this here, and not in nameToUrl
+                // because node allows either .js or non .js to map
+                // to same file.
+                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+                }
+
+                // Starts with a '.' so need the baseName
+                if (name[0].charAt(0) === '.' && baseParts) {
+                    //Convert baseName to array, and lop off the last part,
+                    //so that . matches that 'directory' and not name of the baseName's
+                    //module. For instance, baseName of 'one/two/three', maps to
+                    //'one/two/three.js', but we want the directory, 'one/two' for
+                    //this normalization.
+                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+                    name = normalizedBaseParts.concat(name);
+                }
+
+                trimDots(name);
+                name = name.join('/');
+            }
+
+            //Apply map config if available.
+            if (applyMap && map && (baseParts || starMap)) {
+                nameParts = name.split('/');
+
+                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
+                    nameSegment = nameParts.slice(0, i).join('/');
+
+                    if (baseParts) {
+                        //Find the longest baseName segment match in the config.
+                        //So, do joins on the biggest to smallest lengths of baseParts.
+                        for (j = baseParts.length; j > 0; j -= 1) {
+                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                            //baseName segment has config, find if it has one for
+                            //this name.
+                            if (mapValue) {
+                                mapValue = getOwn(mapValue, nameSegment);
+                                if (mapValue) {
+                                    //Match, update name to the new value.
+                                    foundMap = mapValue;
+                                    foundI = i;
+                                    break outerLoop;
+                                }
+                            }
+                        }
+                    }
+
+                    //Check for a star map match, but just hold on to it,
+                    //if there is a shorter segment match later in a matching
+                    //config, then favor over this star map.
+                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+                        foundStarMap = getOwn(starMap, nameSegment);
+                        starI = i;
+                    }
+                }
+
+                if (!foundMap && foundStarMap) {
+                    foundMap = foundStarMap;
+                    foundI = starI;
+                }
+
+                if (foundMap) {
+                    nameParts.splice(0, foundI, foundMap);
+                    name = nameParts.join('/');
+                }
+            }
+
+            // If the name points to a package's name, use
+            // the package main instead.
+            pkgMain = getOwn(config.pkgs, name);
+
+            return pkgMain ? pkgMain : name;
+        }
+
+        function removeScript(name) {
+            if (isBrowser) {
+                each(scripts(), function (scriptNode) {
+                    if (scriptNode.getAttribute('data-requiremodule') === name &&
+                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+                        scriptNode.parentNode.removeChild(scriptNode);
+                        return true;
+                    }
+                });
+            }
+        }
+
+        function hasPathFallback(id) {
+            var pathConfig = getOwn(config.paths, id);
+            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+                //Pop off the first array value, since it failed, and
+                //retry
+                pathConfig.shift();
+                context.require.undef(id);
+
+                //Custom require that does not do map translation, since
+                //ID is "absolute", already mapped/resolved.
+                context.makeRequire(null, {
+                    skipMap: true
+                })([id]);
+
+                return true;
+            }
+        }
+
+        //Turns a plugin!resource to [plugin, resource]
+        //with the plugin being undefined if the name
+        //did not have a plugin prefix.
+        function splitPrefix(name) {
+            var prefix,
+                index = name ? name.indexOf('!') : -1;
+            if (index > -1) {
+                prefix = name.substring(0, index);
+                name = name.substring(index + 1, name.length);
+            }
+            return [prefix, name];
+        }
+
+        /**
+         * Creates a module mapping that includes plugin prefix, module
+         * name, and path. If parentModuleMap is provided it will
+         * also normalize the name via require.normalize()
+         *
+         * @param {String} name the module name
+         * @param {String} [parentModuleMap] parent module map
+         * for the module name, used to resolve relative names.
+         * @param {Boolean} isNormalized: is the ID already normalized.
+         * This is true if this call is done for a define() module ID.
+         * @param {Boolean} applyMap: apply the map config to the ID.
+         * Should only be true if this map is for a dependency.
+         *
+         * @returns {Object}
+         */
+        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+            var url, pluginModule, suffix, nameParts,
+                prefix = null,
+                parentName = parentModuleMap ? parentModuleMap.name : null,
+                originalName = name,
+                isDefine = true,
+                normalizedName = '';
+
+            //If no name, then it means it is a require call, generate an
+            //internal name.
+            if (!name) {
+                isDefine = false;
+                name = '_@r' + (requireCounter += 1);
+            }
+
+            nameParts = splitPrefix(name);
+            prefix = nameParts[0];
+            name = nameParts[1];
+
+            if (prefix) {
+                prefix = normalize(prefix, parentName, applyMap);
+                pluginModule = getOwn(defined, prefix);
+            }
+
+            //Account for relative paths if there is a base name.
+            if (name) {
+                if (prefix) {
+                    if (pluginModule && pluginModule.normalize) {
+                        //Plugin is loaded, use its normalize method.
+                        normalizedName = pluginModule.normalize(name, function (name) {
+                            return normalize(name, parentName, applyMap);
+                        });
+                    } else {
+                        // If nested plugin references, then do not try to
+                        // normalize, as it will not normalize correctly. This
+                        // places a restriction on resourceIds, and the longer
+                        // term solution is not to normalize until plugins are
+                        // loaded and all normalizations to allow for async
+                        // loading of a loader plugin. But for now, fixes the
+                        // common uses. Details in #1131
+                        normalizedName = name.indexOf('!') === -1 ?
+                                         normalize(name, parentName, applyMap) :
+                                         name;
+                    }
+                } else {
+                    //A regular module.
+                    normalizedName = normalize(name, parentName, applyMap);
+
+                    //Normalized name may be a plugin ID due to map config
+                    //application in normalize. The map config values must
+                    //already be normalized, so do not need to redo that part.
+                    nameParts = splitPrefix(normalizedName);
+                    prefix = nameParts[0];
+                    normalizedName = nameParts[1];
+                    isNormalized = true;
+
+                    url = context.nameToUrl(normalizedName);
+                }
+            }
+
+            //If the id is a plugin id that cannot be determined if it needs
+            //normalization, stamp it with a unique ID so two matching relative
+            //ids that may conflict can be separate.
+            suffix = prefix && !pluginModule && !isNormalized ?
+                     '_unnormalized' + (unnormalizedCounter += 1) :
+                     '';
+
+            return {
+                prefix: prefix,
+                name: normalizedName,
+                parentMap: parentModuleMap,
+                unnormalized: !!suffix,
+                url: url,
+                originalName: originalName,
+                isDefine: isDefine,
+                id: (prefix ?
+                        prefix + '!' + normalizedName :
+                        normalizedName) + suffix
+            };
+        }
+
+        function getModule(depMap) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (!mod) {
+                mod = registry[id] = new context.Module(depMap);
+            }
+
+            return mod;
+        }
+
+        function on(depMap, name, fn) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (hasProp(defined, id) &&
+                    (!mod || mod.defineEmitComplete)) {
+                if (name === 'defined') {
+                    fn(defined[id]);
+                }
+            } else {
+                mod = getModule(depMap);
+                if (mod.error && name === 'error') {
+                    fn(mod.error);
+                } else {
+                    mod.on(name, fn);
+                }
+            }
+        }
+
+        function onError(err, errback) {
+            var ids = err.requireModules,
+                notified = false;
+
+            if (errback) {
+                errback(err);
+            } else {
+                each(ids, function (id) {
+                    var mod = getOwn(registry, id);
+                    if (mod) {
+                        //Set error on module, so it skips timeout checks.
+                        mod.error = err;
+                        if (mod.events.error) {
+                            notified = true;
+                            mod.emit('error', err);
+                        }
+                    }
+                });
+
+                if (!notified) {
+                    req.onError(err);
+                }
+            }
+        }
+
+        /**
+         * Internal method to transfer globalQueue items to this context's
+         * defQueue.
+         */
+        function takeGlobalQueue() {
+            //Push all the globalDefQueue items into the context's defQueue
+            if (globalDefQueue.length) {
+                //Array splice in the values since the context code has a
+                //local var ref to defQueue, so cannot just reassign the one
+                //on context.
+                apsp.apply(defQueue,
+                           [defQueue.length, 0].concat(globalDefQueue));
+                globalDefQueue = [];
+            }
+        }
+
+        handlers = {
+            'require': function (mod) {
+                if (mod.require) {
+                    return mod.require;
+                } else {
+                    return (mod.require = context.makeRequire(mod.map));
+                }
+            },
+            'exports': function (mod) {
+                mod.usingExports = true;
+                if (mod.map.isDefine) {
+                    if (mod.exports) {
+                        return (defined[mod.map.id] = mod.exports);
+                    } else {
+                        return (mod.exports = defined[mod.map.id] = {});
+                    }
+                }
+            },
+            'module': function (mod) {
+                if (mod.module) {
+                    return mod.module;
+                } else {
+                    return (mod.module = {
+                        id: mod.map.id,
+                        uri: mod.map.url,
+                        config: function () {
+                            return  getOwn(config.config, mod.map.id) || {};
+                        },
+                        exports: mod.exports || (mod.exports = {})
+                    });
+                }
+            }
+        };
+
+        function cleanRegistry(id) {
+            //Clean up machinery used for waiting modules.
+            delete registry[id];
+            delete enabledRegistry[id];
+        }
+
+        function breakCycle(mod, traced, processed) {
+            var id = mod.map.id;
+
+            if (mod.error) {
+                mod.emit('error', mod.error);
+            } else {
+                traced[id] = true;
+                each(mod.depMaps, function (depMap, i) {
+                    var depId = depMap.id,
+                        dep = getOwn(registry, depId);
+
+                    //Only force things that have not completed
+                    //being defined, so still in the registry,
+                    //and only if it has not been matched up
+                    //in the module already.
+                    if (dep && !mod.depMatched[i] && !processed[depId]) {
+                        if (getOwn(traced, depId)) {
+                            mod.defineDep(i, defined[depId]);
+                            mod.check(); //pass false?
+                        } else {
+                            breakCycle(dep, traced, processed);
+                        }
+                    }
+                });
+                processed[id] = true;
+            }
+        }
+
+        function checkLoaded() {
+            var err, usingPathFallback,
+                waitInterval = config.waitSeconds * 1000,
+                //It is possible to disable the wait interval by using waitSeconds of 0.
+                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+                noLoads = [],
+                reqCalls = [],
+                stillLoading = false,
+                needCycleCheck = true;
+
+            //Do not bother if this call was a result of a cycle break.
+            if (inCheckLoaded) {
+                return;
+            }
+
+            inCheckLoaded = true;
+
+            //Figure out the state of all the modules.
+            eachProp(enabledRegistry, function (mod) {
+                var map = mod.map,
+                    modId = map.id;
+
+                //Skip things that are not enabled or in error state.
+                if (!mod.enabled) {
+                    return;
+                }
+
+                if (!map.isDefine) {
+                    reqCalls.push(mod);
+                }
+
+                if (!mod.error) {
+                    //If the module should be executed, and it has not
+                    //been inited and time is up, remember it.
+                    if (!mod.inited && expired) {
+                        if (hasPathFallback(modId)) {
+                            usingPathFallback = true;
+                            stillLoading = true;
+                        } else {
+                            noLoads.push(modId);
+                            removeScript(modId);
+                        }
+                    } else if (!mod.inited && mod.fetched && map.isDefine) {
+                        stillLoading = true;
+                        if (!map.prefix) {
+                            //No reason to keep looking for unfinished
+                            //loading. If the only stillLoading is a
+                            //plugin resource though, keep going,
+                            //because it may be that a plugin resource
+                            //is waiting on a non-plugin cycle.
+                            return (needCycleCheck = false);
+                        }
+                    }
+                }
+            });
+
+            if (expired && noLoads.length) {
+                //If wait time expired, throw error of unloaded modules.
+                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+                err.contextName = context.contextName;
+                return onError(err);
+            }
+
+            //Not expired, check for a cycle.
+            if (needCycleCheck) {
+                each(reqCalls, function (mod) {
+                    breakCycle(mod, {}, {});
+                });
+            }
+
+            //If still waiting on loads, and the waiting load is something
+            //other than a plugin resource, or there are still outstanding
+            //scripts, then just try back later.
+            if ((!expired || usingPathFallback) && stillLoading) {
+                //Something is still waiting to load. Wait for it, but only
+                //if a timeout is not already in effect.
+                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+                    checkLoadedTimeoutId = setTimeout(function () {
+                        checkLoadedTimeoutId = 0;
+                        checkLoaded();
+                    }, 50);
+                }
+            }
+
+            inCheckLoaded = false;
+        }
+
+        Module = function (map) {
+            this.events = getOwn(undefEvents, map.id) || {};
+            this.map = map;
+            this.shim = getOwn(config.shim, map.id);
+            this.depExports = [];
+            this.depMaps = [];
+            this.depMatched = [];
+            this.pluginMaps = {};
+            this.depCount = 0;
+
+            /* this.exports this.factory
+               this.depMaps = [],
+               this.enabled, this.fetched
+            */
+        };
+
+        Module.prototype = {
+            init: function (depMaps, factory, errback, options) {
+                options = options || {};
+
+                //Do not do more inits if already done. Can happen if there
+                //are multiple define calls for the same module. That is not
+                //a normal, common case, but it is also not unexpected.
+                if (this.inited) {
+                    return;
+                }
+
+                this.factory = factory;
+
+                if (errback) {
+                    //Register for errors on this module.
+                    this.on('error', errback);
+                } else if (this.events.error) {
+                    //If no errback already, but there are error listeners
+                    //on this module, set up an errback to pass to the deps.
+                    errback = bind(this, function (err) {
+                        this.emit('error', err);
+                    });
+                }
+
+                //Do a copy of the dependency array, so that
+                //source inputs are not modified. For example
+                //"shim" deps are passed in here directly, and
+                //doing a direct modification of the depMaps array
+                //would affect that config.
+                this.depMaps = depMaps && depMaps.slice(0);
+
+                this.errback = errback;
+
+                //Indicate this module has be initialized
+                this.inited = true;
+
+                this.ignore = options.ignore;
+
+                //Could have option to init this module in enabled mode,
+                //or could have been previously marked as enabled. However,
+                //the dependencies are not known until init is called. So
+                //if enabled previously, now trigger dependencies as enabled.
+                if (options.enabled || this.enabled) {
+                    //Enable this module and dependencies.
+                    //Will call this.check()
+                    this.enable();
+                } else {
+                    this.check();
+                }
+            },
+
+            defineDep: function (i, depExports) {
+                //Because of cycles, defined callback for a given
+                //export can be called more than once.
+                if (!this.depMatched[i]) {
+                    this.depMatched[i] = true;
+                    this.depCount -= 1;
+                    this.depExports[i] = depExports;
+                }
+            },
+
+            fetch: function () {
+                if (this.fetched) {
+                    return;
+                }
+                this.fetched = true;
+
+                context.startTime = (new Date()).getTime();
+
+                var map = this.map;
+
+                //If the manager is for a plugin managed resource,
+                //ask the plugin to load it now.
+                if (this.shim) {
+                    context.makeRequire(this.map, {
+                        enableBuildCallback: true
+                    })(this.shim.deps || [], bind(this, function () {
+                        return map.prefix ? this.callPlugin() : this.load();
+                    }));
+                } else {
+                    //Regular dependency.
+                    return map.prefix ? this.callPlugin() : this.load();
+                }
+            },
+
+            load: function () {
+                var url = this.map.url;
+
+                //Regular dependency.
+                if (!urlFetched[url]) {
+                    urlFetched[url] = true;
+                    context.load(this.map.id, url);
+                }
+            },
+
+            /**
+             * Checks if the module is ready to define itself, and if so,
+             * define it.
+             */
+            check: function () {
+                if (!this.enabled || this.enabling) {
+                    return;
+                }
+
+                var err, cjsModule,
+                    id = this.map.id,
+                    depExports = this.depExports,
+                    exports = this.exports,
+                    factory = this.factory;
+
+                if (!this.inited) {
+                    this.fetch();
+                } else if (this.error) {
+                    this.emit('error', this.error);
+                } else if (!this.defining) {
+                    //The factory could trigger another require call
+                    //that would result in checking this module to
+                    //define itself again. If already in the process
+                    //of doing that, skip this work.
+                    this.defining = true;
+
+                    if (this.depCount < 1 && !this.defined) {
+                        if (isFunction(factory)) {
+                            //If there is an error listener, favor passing
+                            //to that instead of throwing an error. However,
+                            //only do it for define()'d  modules. require
+                            //errbacks should not be called for failures in
+                            //their callbacks (#699). However if a global
+                            //onError is set, use that.
+                            if ((this.events.error && this.map.isDefine) ||
+                                req.onError !== defaultOnError) {
+                                try {
+                                    exports = context.execCb(id, factory, depExports, exports);
+                                } catch (e) {
+                                    err = e;
+                                }
+                            } else {
+                                exports = context.execCb(id, factory, depExports, exports);
+                            }
+
+                            // Favor return value over exports. If node/cjs in play,
+                            // then will not have a return value anyway. Favor
+                            // module.exports assignment over exports object.
+                            if (this.map.isDefine && exports === undefined) {
+                                cjsModule = this.module;
+                                if (cjsModule) {
+                                    exports = cjsModule.exports;
+                                } else if (this.usingExports) {
+                                    //exports already set the defined value.
+                                    exports = this.exports;
+                                }
+                            }
+
+                            if (err) {
+                                err.requireMap = this.map;
+                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
+                                err.requireType = this.map.isDefine ? 'define' : 'require';
+                                return onError((this.error = err));
+                            }
+
+                        } else {
+                            //Just a literal value
+                            exports = factory;
+                        }
+
+                        this.exports = exports;
+
+                        if (this.map.isDefine && !this.ignore) {
+                            defined[id] = exports;
+
+                            if (req.onResourceLoad) {
+                                req.onResourceLoad(context, this.map, this.depMaps);
+                            }
+                        }
+
+                        //Clean up
+                        cleanRegistry(id);
+
+                        this.defined = true;
+                    }
+
+                    //Finished the define stage. Allow calling check again
+                    //to allow define notifications below in the case of a
+                    //cycle.
+                    this.defining = false;
+
+                    if (this.defined && !this.defineEmitted) {
+                        this.defineEmitted = true;
+                        this.emit('defined', this.exports);
+                        this.defineEmitComplete = true;
+                    }
+
+                }
+            },
+
+            callPlugin: function () {
+                var map = this.map,
+                    id = map.id,
+                    //Map already normalized the prefix.
+                    pluginMap = makeModuleMap(map.prefix);
+
+                //Mark this as a dependency for this plugin, so it
+                //can be traced for cycles.
+                this.depMaps.push(pluginMap);
+
+                on(pluginMap, 'defined', bind(this, function (plugin) {
+                    var load, normalizedMap, normalizedMod,
+                        bundleId = getOwn(bundlesMap, this.map.id),
+                        name = this.map.name,
+                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
+                        localRequire = context.makeRequire(map.parentMap, {
+                            enableBuildCallback: true
+                        });
+
+                    //If current map is not normalized, wait for that
+                    //normalized name to load instead of continuing.
+                    if (this.map.unnormalized) {
+                        //Normalize the ID if the plugin allows it.
+                        if (plugin.normalize) {
+                            name = plugin.normalize(name, function (name) {
+                                return normalize(name, parentName, true);
+                            }) || '';
+                        }
+
+                        //prefix and name should already be normalized, no need
+                        //for applying map config again either.
+                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
+                                                      this.map.parentMap);
+                        on(normalizedMap,
+                            'defined', bind(this, function (value) {
+                                this.init([], function () { return value; }, null, {
+                                    enabled: true,
+                                    ignore: true
+                                });
+                            }));
+
+                        normalizedMod = getOwn(registry, normalizedMap.id);
+                        if (normalizedMod) {
+                            //Mark this as a dependency for this plugin, so it
+                            //can be traced for cycles.
+                            this.depMaps.push(normalizedMap);
+
+                            if (this.events.error) {
+                                normalizedMod.on('error', bind(this, function (err) {
+                                    this.emit('error', err);
+                                }));
+                            }
+                            normalizedMod.enable();
+                        }
+
+                        return;
+                    }
+
+                    //If a paths config, then just load that file instead to
+                    //resolve the plugin, as it is built into that paths layer.
+                    if (bundleId) {
+                        this.map.url = context.nameToUrl(bundleId);
+                        this.load();
+                        return;
+                    }
+
+                    load = bind(this, function (value) {
+                        this.init([], function () { return value; }, null, {
+                            enabled: true
+                        });
+                    });
+
+                    load.error = bind(this, function (err) {
+                        this.inited = true;
+                        this.error = err;
+                        err.requireModules = [id];
+
+                        //Remove temp unnormalized modules for this module,
+                        //since they will never be resolved otherwise now.
+                        eachProp(registry, function (mod) {
+                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                                cleanRegistry(mod.map.id);
+                            }
+                        });
+
+                        onError(err);
+                    });
+
+                    //Allow plugins to load other code without having to know the
+                    //context or how to 'complete' the load.
+                    load.fromText = bind(this, function (text, textAlt) {
+                        /*jslint evil: true */
+                        var moduleName = map.name,
+                            moduleMap = makeModuleMap(moduleName),
+                            hasInteractive = useInteractive;
+
+                        //As of 2.1.0, support just passing the text, to reinforce
+                        //fromText only being called once per resource. Still
+                        //support old style of passing moduleName but discard
+                        //that moduleName in favor of the internal ref.
+                        if (textAlt) {
+                            text = textAlt;
+                        }
+
+                        //Turn off interactive script matching for IE for any define
+                        //calls in the text, then turn it back on at the end.
+                        if (hasInteractive) {
+                            useInteractive = false;
+                        }
+
+                        //Prime the system by creating a module instance for
+                        //it.
+                        getModule(moduleMap);
+
+                        //Transfer any config to this other module.
+                        if (hasProp(config.config, id)) {
+                            config.config[moduleName] = config.config[id];
+                        }
+
+                        try {
+                            req.exec(text);
+                        } catch (e) {
+                            return onError(makeError('fromtexteval',
+                                             'fromText eval for ' + id +
+                                            ' failed: ' + e,
+                                             e,
+                                             [id]));
+                        }
+
+                        if (hasInteractive) {
+                            useInteractive = true;
+                        }
+
+                        //Mark this as a dependency for the plugin
+                        //resource
+                        this.depMaps.push(moduleMap);
+
+                        //Support anonymous modules.
+                        context.completeLoad(moduleName);
+
+                        //Bind the value of that module to the value for this
+                        //resource ID.
+                        localRequire([moduleName], load);
+                    });
+
+                    //Use parentName here since the plugin's name is not reliable,
+                    //could be some weird string with no path that actually wants to
+                    //reference the parentName's path.
+                    plugin.load(map.name, localRequire, load, config);
+                }));
+
+                context.enable(pluginMap, this);
+                this.pluginMaps[pluginMap.id] = pluginMap;
+            },
+
+            enable: function () {
+                enabledRegistry[this.map.id] = this;
+                this.enabled = true;
+
+                //Set flag mentioning that the module is enabling,
+                //so that immediate calls to the defined callbacks
+                //for dependencies do not trigger inadvertent load
+                //with the depCount still being zero.
+                this.enabling = true;
+
+                //Enable each dependency
+                each(this.depMaps, bind(this, function (depMap, i) {
+                    var id, mod, handler;
+
+                    if (typeof depMap === 'string') {
+                        //Dependency needs to be converted to a depMap
+                        //and wired up to this module.
+                        depMap = makeModuleMap(depMap,
+                                               (this.map.isDefine ? this.map : this.map.parentMap),
+                                               false,
+                                               !this.skipMap);
+                        this.depMaps[i] = depMap;
+
+                        handler = getOwn(handlers, depMap.id);
+
+                        if (handler) {
+                            this.depExports[i] = handler(this);
+                            return;
+                        }
+
+                        this.depCount += 1;
+
+                        on(depMap, 'defined', bind(this, function (depExports) {
+                            this.defineDep(i, depExports);
+                            this.check();
+                        }));
+
+                        if (this.errback) {
+                            on(depMap, 'error', bind(this, this.errback));
+                        }
+                    }
+
+                    id = depMap.id;
+                    mod = registry[id];
+
+                    //Skip special modules like 'require', 'exports', 'module'
+                    //Also, don't call enable if it is already enabled,
+                    //important in circular dependency cases.
+                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
+                        context.enable(depMap, this);
+                    }
+                }));
+
+                //Enable each plugin that is used in
+                //a dependency
+                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+                    var mod = getOwn(registry, pluginMap.id);
+                    if (mod && !mod.enabled) {
+                        context.enable(pluginMap, this);
+                    }
+                }));
+
+                this.enabling = false;
+
+                this.check();
+            },
+
+            on: function (name, cb) {
+                var cbs = this.events[name];
+                if (!cbs) {
+                    cbs = this.events[name] = [];
+                }
+                cbs.push(cb);
+            },
+
+            emit: function (name, evt) {
+                each(this.events[name], function (cb) {
+                    cb(evt);
+                });
+                if (name === 'error') {
+                    //Now that the error handler was triggered, remove
+                    //the listeners, since this broken Module instance
+                    //can stay around for a while in the registry.
+                    delete this.events[name];
+                }
+            }
+        };
+
+        function callGetModule(args) {
+            //Skip modules already defined.
+            if (!hasProp(defined, args[0])) {
+                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+            }
+        }
+
+        function removeListener(node, func, name, ieName) {
+            //Favor detachEvent because of IE9
+            //issue, see attachEvent/addEventListener comment elsewhere
+            //in this file.
+            if (node.detachEvent && !isOpera) {
+                //Probably IE. If not it will throw an error, which will be
+                //useful to know.
+                if (ieName) {
+                    node.detachEvent(ieName, func);
+                }
+            } else {
+                node.removeEventListener(name, func, false);
+            }
+        }
+
+        /**
+         * Given an event from a script node, get the requirejs info from it,
+         * and then removes the event listeners on the node.
+         * @param {Event} evt
+         * @returns {Object}
+         */
+        function getScriptData(evt) {
+            //Using currentTarget instead of target for Firefox 2.0's sake. Not
+            //all old browsers will be supported, but this one was easy enough
+            //to support and still makes sense.
+            var node = evt.currentTarget || evt.srcElement;
+
+            //Remove the listeners once here.
+            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+            removeListener(node, context.onScriptError, 'error');
+
+            return {
+                node: node,
+                id: node && node.getAttribute('data-requiremodule')
+            };
+        }
+
+        function intakeDefines() {
+            var args;
+
+            //Any defined modules in the global queue, intake them now.
+            takeGlobalQueue();
+
+            //Make sure any remaining defQueue items get properly processed.
+            while (defQueue.length) {
+                args = defQueue.shift();
+                if (args[0] === null) {
+                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+                } else {
+                    //args are id, deps, factory. Should be normalized by the
+                    //define() function.
+                    callGetModule(args);
+                }
+            }
+        }
+
+        context = {
+            config: config,
+            contextName: contextName,
+            registry: registry,
+            defined: defined,
+            urlFetched: urlFetched,
+            defQueue: defQueue,
+            Module: Module,
+            makeModuleMap: makeModuleMap,
+            nextTick: req.nextTick,
+            onError: onError,
+
+            /**
+             * Set a configuration for the context.
+             * @param {Object} cfg config object to integrate.
+             */
+            configure: function (cfg) {
+                //Make sure the baseUrl ends in a slash.
+                if (cfg.baseUrl) {
+                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+                        cfg.baseUrl += '/';
+                    }
+                }
+
+                //Save off the paths since they require special processing,
+                //they are additive.
+                var shim = config.shim,
+                    objs = {
+                        paths: true,
+                        bundles: true,
+                        config: true,
+                        map: true
+                    };
+
+                eachProp(cfg, function (value, prop) {
+                    if (objs[prop]) {
+                        if (!config[prop]) {
+                            config[prop] = {};
+                        }
+                        mixin(config[prop], value, true, true);
+                    } else {
+                        config[prop] = value;
+                    }
+                });
+
+                //Reverse map the bundles
+                if (cfg.bundles) {
+                    eachProp(cfg.bundles, function (value, prop) {
+                        each(value, function (v) {
+                            if (v !== prop) {
+                                bundlesMap[v] = prop;
+                            }
+                        });
+                    });
+                }
+
+                //Merge shim
+                if (cfg.shim) {
+                    eachProp(cfg.shim, function (value, id) {
+                        //Normalize the structure
+                        if (isArray(value)) {
+                            value = {
+                                deps: value
+                            };
+                        }
+                        if ((value.exports || value.init) && !value.exportsFn) {
+                            value.exportsFn = context.makeShimExports(value);
+                        }
+                        shim[id] = value;
+                    });
+                    config.shim = shim;
+                }
+
+                //Adjust packages if necessary.
+                if (cfg.packages) {
+                    each(cfg.packages, function (pkgObj) {
+                        var location, name;
+
+                        pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+
+                        name = pkgObj.name;
+                        location = pkgObj.location;
+                        if (location) {
+                            config.paths[name] = pkgObj.location;
+                        }
+
+                        //Save pointer to main module ID for pkg name.
+                        //Remove leading dot in main, so main paths are normalized,
+                        //and remove any trailing .js, since different package
+                        //envs have different conventions: some use a module name,
+                        //some use a file name.
+                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
+                                     .replace(currDirRegExp, '')
+                                     .replace(jsSuffixRegExp, '');
+                    });
+                }
+
+                //If there are any "waiting to execute" modules in the registry,
+                //update the maps for them, since their info, like URLs to load,
+                //may have changed.
+                eachProp(registry, function (mod, id) {
+                    //If module already has init called, since it is too
+                    //late to modify them, and ignore unnormalized ones
+                    //since they are transient.
+                    if (!mod.inited && !mod.map.unnormalized) {
+                        mod.map = makeModuleMap(id);
+                    }
+                });
+
+                //If a deps array or a config callback is specified, then call
+                //require with those args. This is useful when require is defined as a
+                //config object before require.js is loaded.
+                if (cfg.deps || cfg.callback) {
+                    context.require(cfg.deps || [], cfg.callback);
+                }
+            },
+
+            makeShimExports: function (value) {
+                function fn() {
+                    var ret;
+                    if (value.init) {
+                        ret = value.init.apply(global, arguments);
+                    }
+                    return ret || (value.exports && getGlobal(value.exports));
+                }
+                return fn;
+            },
+
+            makeRequire: function (relMap, options) {
+                options = options || {};
+
+                function localRequire(deps, callback, errback) {
+                    var id, map, requireMod;
+
+                    if (options.enableBuildCallback && callback && isFunction(callback)) {
+                        callback.__requireJsBuild = true;
+                    }
+
+                    if (typeof deps === 'string') {
+                        if (isFunction(callback)) {
+                            //Invalid call
+                            return onError(makeError('requireargs', 'Invalid require call'), errback);
+                        }
+
+                        //If require|exports|module are requested, get the
+                        //value for them from the special handlers. Caveat:
+                        //this only works while module is being defined.
+                        if (relMap && hasProp(handlers, deps)) {
+                            return handlers[deps](registry[relMap.id]);
+                        }
+
+                        //Synchronous access to one module. If require.get is
+                        //available (as in the Node adapter), prefer that.
+                        if (req.get) {
+                            return req.get(context, deps, relMap, localRequire);
+                        }
+
+                        //Normalize module name, if it contains . or ..
+                        map = makeModuleMap(deps, relMap, false, true);
+                        id = map.id;
+
+                        if (!hasProp(defined, id)) {
+                            return onError(makeError('notloaded', 'Module name "' +
+                                        id +
+                                        '" has not been loaded yet for context: ' +
+                                        contextName +
+                                        (relMap ? '' : '. Use require([])')));
+                        }
+                        return defined[id];
+                    }
+
+                    //Grab defines waiting in the global queue.
+                    intakeDefines();
+
+                    //Mark all the dependencies as needing to be loaded.
+                    context.nextTick(function () {
+                        //Some defines could have been added since the
+                        //require call, collect them.
+                        intakeDefines();
+
+                        requireMod = getModule(makeModuleMap(null, relMap));
+
+                        //Store if map config should be applied to this require
+                        //call for dependencies.
+                        requireMod.skipMap = options.skipMap;
+
+                        requireMod.init(deps, callback, errback, {
+                            enabled: true
+                        });
+
+                        checkLoaded();
+                    });
+
+                    return localRequire;
+                }
+
+                mixin(localRequire, {
+                    isBrowser: isBrowser,
+
+                    /**
+                     * Converts a module name + .extension into an URL path.
+                     * *Requires* the use of a module name. It does not support using
+                     * plain URLs like nameToUrl.
+                     */
+                    toUrl: function (moduleNamePlusExt) {
+                        var ext,
+                            index = moduleNamePlusExt.lastIndexOf('.'),
+                            segment = moduleNamePlusExt.split('/')[0],
+                            isRelative = segment === '.' || segment === '..';
+
+                        //Have a file extension alias, and it is not the
+                        //dots from a relative path.
+                        if (index !== -1 && (!isRelative || index > 1)) {
+                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+                        }
+
+                        return context.nameToUrl(normalize(moduleNamePlusExt,
+                                                relMap && relMap.id, true), ext,  true);
+                    },
+
+                    defined: function (id) {
+                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+                    },
+
+                    specified: function (id) {
+                        id = makeModuleMap(id, relMap, false, true).id;
+                        return hasProp(defined, id) || hasProp(registry, id);
+                    }
+                });
+
+                //Only allow undef on top level require calls
+                if (!relMap) {
+                    localRequire.undef = function (id) {
+                        //Bind any waiting define() calls to this context,
+                        //fix for #408
+                        takeGlobalQueue();
+
+                        var map = makeModuleMap(id, relMap, true),
+                            mod = getOwn(registry, id);
+
+                        removeScript(id);
+
+                        delete defined[id];
+                        delete urlFetched[map.url];
+                        delete undefEvents[id];
+
+                        //Clean queued defines too. Go backwards
+                        //in array so that the splices do not
+                        //mess up the iteration.
+                        eachReverse(defQueue, function(args, i) {
+                            if(args[0] === id) {
+                                defQueue.splice(i, 1);
+                            }
+                        });
+
+                        if (mod) {
+                            //Hold on to listeners in case the
+                            //module will be attempted to be reloaded
+                            //using a different config.
+                            if (mod.events.defined) {
+                                undefEvents[id] = mod.events;
+                            }
+
+                            cleanRegistry(id);
+                        }
+                    };
+                }
+
+                return localRequire;
+            },
+
+            /**
+             * Called to enable a module if it is still in the registry
+             * awaiting enablement. A second arg, parent, the parent module,
+             * is passed in for context, when this method is overridden by
+             * the optimizer. Not shown here to keep code compact.
+             */
+            enable: function (depMap) {
+                var mod = getOwn(registry, depMap.id);
+                if (mod) {
+                    getModule(depMap).enable();
+                }
+            },
+
+            /**
+             * Internal method used by environment adapters to complete a load event.
+             * A load event could be a script load or just a load pass from a synchronous
+             * load call.
+             * @param {String} moduleName the name of the module to potentially complete.
+             */
+            completeLoad: function (moduleName) {
+                var found, args, mod,
+                    shim = getOwn(config.shim, moduleName) || {},
+                    shExports = shim.exports;
+
+                takeGlobalQueue();
+
+                while (defQueue.length) {
+                    args = defQueue.shift();
+                    if (args[0] === null) {
+                        args[0] = moduleName;
+                        //If already found an anonymous module and bound it
+                        //to this name, then this is some other anon module
+                        //waiting for its completeLoad to fire.
+                        if (found) {
+                            break;
+                        }
+                        found = true;
+                    } else if (args[0] === moduleName) {
+                        //Found matching define call for this script!
+                        found = true;
+                    }
+
+                    callGetModule(args);
+                }
+
+                //Do this after the cycle of callGetModule in case the result
+                //of those calls/init calls changes the registry.
+                mod = getOwn(registry, moduleName);
+
+                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+                        if (hasPathFallback(moduleName)) {
+                            return;
+                        } else {
+                            return onError(makeError('nodefine',
+                                             'No define call for ' + moduleName,
+                                             null,
+                                             [moduleName]));
+                        }
+                    } else {
+                        //A script that does not call define(), so just simulate
+                        //the call for it.
+                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+                    }
+                }
+
+                checkLoaded();
+            },
+
+            /**
+             * Converts a module name to a file path. Supports cases where
+             * moduleName may actually be just an URL.
+             * Note that it **does not** call normalize on the moduleName,
+             * it is assumed to have already been normalized. This is an
+             * internal API, not a public one. Use toUrl for the public API.
+             */
+            nameToUrl: function (moduleName, ext, skipExt) {
+                var paths, syms, i, parentModule, url,
+                    parentPath, bundleId,
+                    pkgMain = getOwn(config.pkgs, moduleName);
+
+                if (pkgMain) {
+                    moduleName = pkgMain;
+                }
+
+                bundleId = getOwn(bundlesMap, moduleName);
+
+                if (bundleId) {
+                    return context.nameToUrl(bundleId, ext, skipExt);
+                }
+
+                //If a colon is in the URL, it indicates a protocol is used and it is just
+                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+                //or ends with .js, then assume the user meant to use an url and not a module id.
+                //The slash is important for protocol-less URLs as well as full paths.
+                if (req.jsExtRegExp.test(moduleName)) {
+                    //Just a plain path, not module name lookup, so just return it.
+                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
+                    //an extension, this method probably needs to be reworked.
+                    url = moduleName + (ext || '');
+                } else {
+                    //A module that needs to be converted to a path.
+                    paths = config.paths;
+
+                    syms = moduleName.split('/');
+                    //For each module name segment, see if there is a path
+                    //registered for it. Start with most specific name
+                    //and work up from it.
+                    for (i = syms.length; i > 0; i -= 1) {
+                        parentModule = syms.slice(0, i).join('/');
+
+                        parentPath = getOwn(paths, parentModule);
+                        if (parentPath) {
+                            //If an array, it means there are a few choices,
+                            //Choose the one that is desired
+                            if (isArray(parentPath)) {
+                                parentPath = parentPath[0];
+                            }
+                            syms.splice(0, i, parentPath);
+                            break;
+                        }
+                    }
+
+                    //Join the path parts together, then figure out if baseUrl is needed.
+                    url = syms.join('/');
+                    url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
+                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+                }
+
+                return config.urlArgs ? url +
+                                        ((url.indexOf('?') === -1 ? '?' : '&') +
+                                         config.urlArgs) : url;
+            },
+
+            //Delegates to req.load. Broken out as a separate function to
+            //allow overriding in the optimizer.
+            load: function (id, url) {
+                req.load(context, id, url);
+            },
+
+            /**
+             * Executes a module callback function. Broken out as a separate function
+             * solely to allow the build system to sequence the files in the built
+             * layer in the right sequence.
+             *
+             * @private
+             */
+            execCb: function (name, callback, args, exports) {
+                return callback.apply(exports, args);
+            },
+
+            /**
+             * callback for script loads, used to check status of loading.
+             *
+             * @param {Event} evt the event from the browser for the script
+             * that was loaded.
+             */
+            onScriptLoad: function (evt) {
+                //Using currentTarget instead of target for Firefox 2.0's sake. Not
+                //all old browsers will be supported, but this one was easy enough
+                //to support and still makes sense.
+                if (evt.type === 'load' ||
+                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+                    //Reset interactive script so a script node is not held onto for
+                    //to long.
+                    interactiveScript = null;
+
+                    //Pull out the name of the module and the context.
+                    var data = getScriptData(evt);
+                    context.completeLoad(data.id);
+                }
+            },
+
+            /**
+             * Callback for script errors.
+             */
+            onScriptError: function (evt) {
+                var data = getScriptData(evt);
+                if (!hasPathFallback(data.id)) {
+                    return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
+                }
+            }
+        };
+
+        context.require = context.makeRequire();
+        return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function (deps, callback, errback, optional) {
+
+        //Find the right context, use default
+        var context, config,
+            contextName = defContextName;
+
+        // Determine if have config object in the call.
+        if (!isArray(deps) && typeof deps !== 'string') {
+            // deps is a config object
+            config = deps;
+            if (isArray(callback)) {
+                // Adjust args if there are dependencies
+                deps = callback;
+                callback = errback;
+                errback = optional;
+            } else {
+                deps = [];
+            }
+        }
+
+        if (config && config.context) {
+            contextName = config.context;
+        }
+
+        context = getOwn(contexts, contextName);
+        if (!context) {
+            context = contexts[contextName] = req.s.newContext(contextName);
+        }
+
+        if (config) {
+            context.configure(config);
+        }
+
+        return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+        return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+        setTimeout(fn, 4);
+    } : function (fn) { fn(); };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = req;
+    }
+
+    req.version = version;
+
+    //Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+        contexts: contexts,
+        newContext: newContext
+    };
+
+    //Create default context.
+    req({});
+
+    //Exports some context-sensitive methods on global require.
+    each([
+        'toUrl',
+        'undef',
+        'defined',
+        'specified'
+    ], function (prop) {
+        //Reference from contexts instead of early binding to default context,
+        //so that during builds, the latest instance of the default context
+        //with its config gets used.
+        req[prop] = function () {
+            var ctx = contexts[defContextName];
+            return ctx.require[prop].apply(ctx, arguments);
+        };
+    });
+
+    if (isBrowser) {
+        head = s.head = document.getElementsByTagName('head')[0];
+        //If BASE tag is in play, using appendChild is a problem for IE6.
+        //When that browser dies, this can be removed. Details in this jQuery bug:
+        //http://dev.jquery.com/ticket/2709
+        baseElement = document.getElementsByTagName('base')[0];
+        if (baseElement) {
+            head = s.head = baseElement.parentNode;
+        }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = defaultOnError;
+
+    /**
+     * Creates the node for the load command. Only used in browser envs.
+     */
+    req.createNode = function (config, moduleName, url) {
+        var node = config.xhtml ?
+                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+                document.createElement('script');
+        node.type = config.scriptType || 'text/javascript';
+        node.charset = 'utf-8';
+        node.async = true;
+        return node;
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+        var config = (context && context.config) || {},
+            node;
+        if (isBrowser) {
+            //In the browser so use a script tag
+            node = req.createNode(config, moduleName, url);
+
+            node.setAttribute('data-requirecontext', context.contextName);
+            node.setAttribute('data-requiremodule', moduleName);
+
+            //Set up load listener. Test attachEvent first because IE9 has
+            //a subtle issue in its addEventListener and script onload firings
+            //that do not match the behavior of all other browsers with
+            //addEventListener support, which fire the onload event for a
+            //script right after the script execution. See:
+            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+            //script execution mode.
+            if (node.attachEvent &&
+                    //Check if node.attachEvent is artificially added by custom script or
+                    //natively supported by browser
+                    //read https://github.com/jrburke/requirejs/issues/187
+                    //if we can NOT find [native code] then it must NOT natively supported.
+                    //in IE8, node.attachEvent does not have toString()
+                    //Note the test for "[native code" with no closing brace, see:
+                    //https://github.com/jrburke/requirejs/issues/273
+                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+                    !isOpera) {
+                //Probably IE. IE (at least 6-8) do not fire
+                //script onload right after executing the script, so
+                //we cannot tie the anonymous define call to a name.
+                //However, IE reports the script as being in 'interactive'
+                //readyState at the time of the define call.
+                useInteractive = true;
+
+                node.attachEvent('onreadystatechange', context.onScriptLoad);
+                //It would be great to add an error handler here to catch
+                //404s in IE9+. However, onreadystatechange will fire before
+                //the error handler, so that does not help. If addEventListener
+                //is used, then IE will fire error before load, but we cannot
+                //use that pathway given the connect.microsoft.com issue
+                //mentioned above about not doing the 'script execute,
+                //then fire the script load event listener before execute
+                //next script' that other browsers do.
+                //Best hope: IE10 fixes the issues,
+                //and then destroys all installs of IE 6-9.
+                //node.attachEvent('onerror', context.onScriptError);
+            } else {
+                node.addEventListener('load', context.onScriptLoad, false);
+                node.addEventListener('error', context.onScriptError, false);
+            }
+            node.src = url;
+
+            //For some cache cases in IE 6-8, the script executes before the end
+            //of the appendChild execution, so to tie an anonymous define
+            //call to the module name (which is stored on the node), hold on
+            //to a reference to this node, but clear after the DOM insertion.
+            currentlyAddingScript = node;
+            if (baseElement) {
+                head.insertBefore(node, baseElement);
+            } else {
+                head.appendChild(node);
+            }
+            currentlyAddingScript = null;
+
+            return node;
+        } else if (isWebWorker) {
+            try {
+                //In a web worker, use importScripts. This is not a very
+                //efficient use of importScripts, importScripts will block until
+                //its script is downloaded and evaluated. However, if web workers
+                //are in play, the expectation that a build has been done so that
+                //only one script needs to be loaded anyway. This may need to be
+                //reevaluated if other use cases become common.
+                importScripts(url);
+
+                //Account for anonymous modules
+                context.completeLoad(moduleName);
+            } catch (e) {
+                context.onError(makeError('importscripts',
+                                'importScripts failed for ' +
+                                    moduleName + ' at ' + url,
+                                e,
+                                [moduleName]));
+            }
+        }
+    };
+
+    function getInteractiveScript() {
+        if (interactiveScript && interactiveScript.readyState === 'interactive') {
+            return interactiveScript;
+        }
+
+        eachReverse(scripts(), function (script) {
+            if (script.readyState === 'interactive') {
+                return (interactiveScript = script);
+            }
+        });
+        return interactiveScript;
+    }
+
+    //Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser && !cfg.skipDataMain) {
+        //Figure out baseUrl. Get it from the script tag with require.js in it.
+        eachReverse(scripts(), function (script) {
+            //Set the 'head' where we can append children by
+            //using the script's parent.
+            if (!head) {
+                head = script.parentNode;
+            }
+
+            //Look for a data-main attribute to set main script for the page
+            //to load. If it is there, the path to data main becomes the
+            //baseUrl, if it is not already set.
+            dataMain = script.getAttribute('data-main');
+            if (dataMain) {
+                //Preserve dataMain in case it is a path (i.e. contains '?')
+                mainScript = dataMain;
+
+                //Set final baseUrl if there is not already an explicit one.
+                if (!cfg.baseUrl) {
+                    //Pull off the directory of data-main for use as the
+                    //baseUrl.
+                    src = mainScript.split('/');
+                    mainScript = src.pop();
+                    subPath = src.length ? src.join('/')  + '/' : './';
+
+                    cfg.baseUrl = subPath;
+                }
+
+                //Strip off any trailing .js since mainScript is now
+                //like a module name.
+                mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+                 //If mainScript is still a path, fall back to dataMain
+                if (req.jsExtRegExp.test(mainScript)) {
+                    mainScript = dataMain;
+                }
+
+                //Put the data-main script in the files to load.
+                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function (name, deps, callback) {
+        var node, context;
+
+        //Allow for anonymous modules
+        if (typeof name !== 'string') {
+            //Adjust args appropriately
+            callback = deps;
+            deps = name;
+            name = null;
+        }
+
+        //This module may not have dependencies
+        if (!isArray(deps)) {
+            callback = deps;
+            deps = null;
+        }
+
+        //If no name, and callback is a function, then figure out if it a
+        //CommonJS thing with dependencies.
+        if (!deps && isFunction(callback)) {
+            deps = [];
+            //Remove comments from the callback string,
+            //look for require calls, and pull them into the dependencies,
+            //but only if there are function args.
+            if (callback.length) {
+                callback
+                    .toString()
+                    .replace(commentRegExp, '')
+                    .replace(cjsRequireRegExp, function (match, dep) {
+                        deps.push(dep);
+                    });
+
+                //May be a CommonJS thing even without require calls, but still
+                //could use exports, and module. Avoid doing exports and module
+                //work though if it just needs require.
+                //REQUIRES the function to expect the CommonJS variables in the
+                //order listed below.
+                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+            }
+        }
+
+        //If in IE 6-8 and hit an anonymous define() call, do the interactive
+        //work.
+        if (useInteractive) {
+            node = currentlyAddingScript || getInteractiveScript();
+            if (node) {
+                if (!name) {
+                    name = node.getAttribute('data-requiremodule');
+                }
+                context = contexts[node.getAttribute('data-requirecontext')];
+            }
+        }
+
+        //Always save off evaluating the def call until the script onload handler.
+        //This allows multiple modules to be in a file without prematurely
+        //tracing dependencies, and allows for anonymous module support,
+        //where the module name is not known until the script onload event
+        //occurs. If no context, use the global queue, and get it processed
+        //in the onscript load callback.
+        (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+        /*jslint evil: true */
+        return eval(text);
+    };
+
+    //Set up with config info.
+    req(cfg);
+}(this));
diff --git a/test/test-config.js b/test/test-config.js
index aeffe7ce..66a18ae2 100644
--- a/test/test-config.js
+++ b/test/test-config.js
@@ -3,7 +3,11 @@
     // Configure RequireJS so it resolves relative module paths from the `src`
     // folder.
     require.config({
-        baseUrl: '../src'
+        baseUrl: '../src',
+        paths: {
+            extensions: '../src/extensions'/*,
+            sortabletable: 'extensions/sortabletable/'*/
+        }
     });
 
 }());
\ No newline at end of file
diff --git a/test/test-sort.html b/test/test-sort.html
new file mode 100644
index 00000000..f97b9a53
--- /dev/null
+++ b/test/test-sort.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>TableFilter column sort</title>
+        <link rel="stylesheet" href="libs/qunit/qunit.css">
+        <link rel="stylesheet" href="../src/filtergrid.css">
+        <script src="libs/qunit/qunit.js"></script>
+        <script>
+            // Defer Qunit so RequireJS can work its magic and resolve all modules.
+            QUnit.config.autostart = false;
+            QUnit.config.autoload = false;
+        </script>
+    </head>
+    <body>
+        <table id="demo" cellpadding="0" cellspacing="0">
+            <thead>
+                <tr>
+                    <th>From</th>
+                    <th>Destination</th>
+                    <th>Road Distance (km)</th>
+                    <th>By Air (hrs)</th>
+                    <th>By Rail (hrs)</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Adelaide</td>
+                    <td>1412</td>
+                    <td>1.4</td>
+                    <td>25.3</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Brisbane</td>
+                    <td>982</td>
+                    <td>1.5</td>
+                    <td>16</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Canberra</td>
+                    <td>286</td>
+                    <td>.6</td>
+                    <td>4.3</td>
+                </tr>
+                <tr>
+                    <td><strong>Sydney</strong></td>
+                    <td>Melbourne</td>
+                    <td>872</td>
+                    <td>1.1</td>
+                    <td>10.5</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Perth</td>
+                    <td>2781</td>
+                    <td>3.1</td>
+                    <td>38</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Alice Springs</td>
+                    <td>1533</td>
+                    <td>2</td>
+                    <td>20.25</td>
+                </tr>
+                <tr>
+                    <td><strong>Adelaide</strong></td>
+                    <td>Brisbane</td>
+                    <td>2045</td>
+                    <td>2.15</td>
+                    <td>40</td>
+                </tr>
+            </tbody>
+        </table>
+
+        <script data-main="test-sort" src="../libs/requirejs/require.js"></script>
+
+        <div id="qunit"></div>
+        <div id="qunit-fixture"></div>
+    </body>
+</html>
\ No newline at end of file
diff --git a/test/test-sort.js b/test/test-sort.js
new file mode 100644
index 00000000..cc28471b
--- /dev/null
+++ b/test/test-sort.js
@@ -0,0 +1,54 @@
+requirejs(['test-config', '../src/tablefilter'], function(config, TableFilter){
+
+    var types = require('types').Types,
+        dom = require('dom').Dom;
+
+    var tf = new TableFilter('demo', {
+        base_path: '../src/',
+        sort: true,
+        sort_config: {
+            sort_types: ['string','string','number','number','number']
+        },
+        on_sort_loaded: startTests
+    });
+    tf.init();
+
+    function startTests(tf){
+        var sort = tf.Extensions.sort;
+        QUnit.start();
+
+        module('Sanity checks');
+        test('Sort extension', function() {
+            notEqual(sort, null, 'Sort instanciated');
+            deepEqual(sort.stt instanceof SortableTable, true, 'Sort type');
+            // notEqual(clearButton.btnResetEl, null, 'btnResetEl property');
+        });
+
+        // module('UI elements');
+        // test('ClearButton UI elements', function() {
+        //     var container = clearButton.btnResetEl;
+        //     deepEqual(container.nodeName, 'INPUT', 'Clear button container');
+        //     deepEqual(container.parentNode.id, tf.prfxResetSpan+tf.id, 'Container id');
+        // });
+
+        // module('Destroy and re-init');
+        // test('Remove UI', function() {
+        //     clearButton.destroy();
+        //     var btnResetEl = tf.Cpt.clearButton.btnResetEl;
+        //     deepEqual(btnResetEl, null, 'Clear button is removed');
+        // });
+
+        // test('Re-set UI', function() {
+        //     tf.enableIcons = false;
+        //     tf.Cpt.clearButton.btnResetHtml = null;
+        //     tf.Cpt.clearButton.btnResetText = 'Clear';
+        //     tf.Cpt.clearButton.init();
+
+        //     var btnResetEl = tf.Cpt.clearButton.btnResetEl;
+        //     deepEqual(btnResetEl.nodeName, 'A', 'Clear button tag changed');
+        //     deepEqual(dom.getText(btnResetEl), 'Clear', 'Clear button text');
+        // });
+
+    }
+
+});