'); //the grips container object is added. Signature class forces table rendering in fixed-layout mode to prevent column's min-width t.g = []; t.c = []; t.w = t.width(); t.gc = t.prev(); t.f = t.opt.fixed; //t.c and t.g are arrays of columns and grips respectively if (options.marginLeft) t.gc.css("marginLeft", options.marginLeft); //if the table contains margins, it must be specified if (options.marginRight) t.gc.css("marginRight", options.marginRight); //since there is no (direct) way to obtain margin values in its original units (%, em, ...) t.cs = I(ie ? tb.cellSpacing || tb.currentStyle.borderSpacing : t.css('border-spacing')) || 2; //table cellspacing (not even jQuery is fully cross-browser) t.b = I(ie ? tb.border || tb.currentStyle.borderLeftWidth : t.css('border-left-width')) || 1; //outer border width (again cross-browser issues) // if(!(tb.style.width || tb.width)) t.width(t.width()); //I am not an IE fan at all, but it is a pity that only IE has the currentStyle attribute working as expected. For this reason I can not check easily if the table has an explicit width or if it is rendered as "auto" tables[id] = t; //the table object is stored using its id as key createGrips(t); //grips are created var cb = t.opt.onResize; if (cb) { cb(); } //necessary to call during init to reallign the extra table after adding new fields to the extended grid tables }; var bindWindowEvents = function () { //bind resize event, to update grips position $(window).bind('resize.' + SIGNATURE, onResize); //We need to call this function to recalculate the table width (especially table wrapped using responsive div container) //to ensure the draggable div is able to wrap the table correctly. $(window).load(function () { onResize(); }); }; /** * This function allows to remove any enhancements performed by this plugin on a previously processed table. * @param {jQuery ref} t - table object */ var destroy = function (t) { var id = t.attr(ID), t = tables[id]; //its table object is found if (!t || !t.is("table")) return; //if none, then it wasn't processed t.removeClass(SIGNATURE + " " + FLEX).gc.remove(); //class and grips are removed delete tables[id]; //clean up data }; /** * Function to create all the grips associated with the table given by parameters * @param {jQuery ref} t - table object */ var createGrips = function (t) { var th = t.find(">thead>tr:first>th.resizable-col,>thead>tr:first>td.resizable-col"); //table headers are obtained if (!th.length) th = t.find(">tbody>tr:first>th.resizable-col,>tr:first>th.resizable-col,>tbody>tr:first>td.resizable-col, >tr:first>td.resizable-col"); //but headers can also be included in different ways th = th.filter(":visible"); //filter invisible columns t.cg = t.find("col.resizable-col"); //a table can also contain a colgroup with col elements t.ln = th.length; //table length is stored userResizedColumns = hasDefaultResizedColumnData(t.id); updateResizableColumnJSONData(t.id, t, th); var sessionStoreExist = (t.p && S && S[getResizableSessionStorageKeyBy(t.id)]); if (sessionStoreExist) { memento(t, th); //if 'postbackSafe' is enabled and there is data for the current table, its coloumn layout is restored } th.each(function (i) { //iterate through the table column headers var c = $(this); //jquery wrap for the current column var dc = t.dc.indexOf(i) != -1; //is this a disabled column? var g = $(t.gc.append('

')[0].lastChild); //add the visual node to be used as grip g.append(dc ? "" : t.opt.gripInnerHtml).append('

'); if (i == t.ln - 1) { //if the current grip is the las one g.addClass("JCLRLastGrip"); //add a different css class to stlye it in a different way if needed if (t.f) g.html(""); //if the table resizing mode is set to fixed, the last grip is removed since table with can not change } g.bind('touchstart mousedown', onGripMouseDown); //bind the mousedown event to start dragging if (!dc) { //if normal column bind the mousedown event to start dragging, if disabled then apply its css class g.removeClass('JCLRdisabledGrip').bind('touchstart mousedown', onGripMouseDown); } else { g.addClass('JCLRdisabledGrip'); } g.t = t; g.i = i; g.c = c; c.w = c.width(); //some values are stored in the grip's node data as shortcut t.g.push(g); t.c.push(c); //the current grip and column are added to its table object c.width(c.w).removeAttr("width"); //the width of the column is converted into pixel-based measurements g.data(SIGNATURE, { i: i, t: t.attr(ID), last: i == t.ln - 1 }); //grip index and its table name are stored in the HTML }); t.cg.removeAttr("width"); //remove the width attribute from elements in the colgroup t.find("td.resizable-col, th.resizable-col").not(th).not("table th.resizable-col, table td.resizable-col").each(function () { $(this).removeAttr('width'); //the width attribute is removed from all table cells which are not nested in other tables and dont belong to the header }); if (!t.f) { t.removeAttr('width').addClass(FLEX); //if not fixed, let the table grow as needed } syncGrips(t); //the grips are positioned according to the current table layout //there is a small problem, some cells in the table could contain dimension values interfering with the //width value set by this plugin. Those values are removed }; /** * Function to allow the persistence of columns dimensions after a browser postback. It is based in * the HTML5 sessionStorage object, which can be emulated for older browsers using sessionstorage.js * @param {jQuery ref} t - table object * @param {jQuery ref} th - reference to the first row elements (only set in deserialization) */ var memento = function (t, th) { var w, m = 0, i = 0, aux = [], tw; if (th) { //in deserialization mode (after a postback) //Triggered when page is refresh and session store is exist updateResizableColumnJSONData(t.id, t, th); t.cg.removeAttr("width"); if (t.opt.flush) { S[getResizableSessionStorageKeyBy(t.id)] = ""; return; } //if flush is activated, stored data is removed var totalPixelUsedByColumns = resizableColumnJSONData["totalPixelUsedByColumns"]; tw = resizableColumnJSONData["totalPixelUsedByColumns"]; if (!t.f && tw) { //if not fixed and table width data available its size is restored t.width(tw *= 1); if (t.opt.overflow) { //if overfolw flag is set, restore table width also as table min-width t.css('min-width', tw + PX); t.w = tw; } } for (i = 0; i < t.ln; i++) { //for each visible column var columnId = th.eq(i).attr("id"); var columnWidth = resizableColumnJSONData[columnId]; //width is stored in an array since it will be required again a couple of lines ahead //aux.push(100 * columnWidth / totalPixelUsedByColumns + "%"); // after resizing, table is rendered fit to the screen when the page is reloaded if (!(hasResizableColumnsUserSettings || userResizedColumns)) { columnWidth += 12; //each column has 6px of margin on each side thus the value 12. The margin pixel count is lost when the table is rendered the 1st time. } aux.push(columnWidth + "PX"); //if a table is resized smaller than the page, it should be rendered with the same width next time (not fit to screen) th.eq(i).css("width", aux[i]); //each column width in % is restored } for (i = 0; i < t.ln; i++) { t.cg.eq(i).css("width", aux[i]); //this code is required in order to create an inline CSS rule with higher precedence than an existing CSS class in the "col" elements } } else { //in serialization mode (after resizing a column) //Triggered when column is resizable for (i = 0; i < t.c.length; i++) { //iterate through columns var columnId = t.c[i].attr('id'); //w = t.c[i].width(); //width is obtained w = t.c[i][0].clientWidth; //width including the padding size is obtained //Set Minimum width to ensure column width will not be too small. if (w <= 0) { w = 30; } if (columnId !== undefined) { saveResizableColumnJSONData(t.id, columnId, w); } m += w; //carriage is updated to obtain the full size used by columns } saveResizableColumnJSONData(t.id, "totalPixelUsedByColumns", m); //if not fixed, table width is stored if (!t.f) { saveResizableColumnJSONData(t.id, "tableWidth", t.width); } } }; /** * Function that places each grip in the correct position according to the current table layout * @param {jQuery ref} t - table object */ var syncGrips = function (t) { t.gc.width(t.w); //the grip's container width is updated for (var i = 0; i < t.ln; i++) { //for each column var c = t.c[i]; var pagingRowHeight = 0; var pagingButton = t.find("tr.Header:visible .pgButton"); if (pagingButton.length) { var pagingHeader = pagingButton.closest("tr.Header"); pagingRowHeight = pagingHeader ? $(pagingHeader).outerHeight() : 0; } var footerHeight = 0; $.each(t.find("tr.Footer:visible"), function (index, value) { footerHeight += $(value).outerHeight(); }); //height and position of the grip is updated according to the table layout //if there is a footer and paging, exclude it in the height of the grip. t.g[i].css({ left: c.offset().left - t.offset().left + c.outerWidth(false) + t.cs / 2 + PX, height: t.opt.headerOnly ? t.c[0].outerHeight(false) : t.outerHeight(false) - pagingRowHeight - footerHeight }); } }; /** * This function updates column's width according to the horizontal position increment of the grip being * dragged. The function can be called while dragging if liveDragging is enabled and also from the onGripDragOver * event handler to synchronize grip's position with their related columns. * @param {jQuery ref} t - table object * @param {number} i - index of the grip being dragged * @param {bool} isOver - to identify when the function is being called from the onGripDragOver event */ var syncCols = function (t, i, isOver) { var inc = drag.x - drag.l, c = t.c[i], c2 = t.c[i + 1]; var w = c.w + inc; var w2 = 0; //their new width is obtained if (c2 != undefined) w2 = c2.w - inc; c.width(w + PX); t.cg.eq(i).width(w + PX); if (t.f) { //if fixed mode c2.width(w2 + PX); t.cg.eq(i + 1).width(w2 + PX); } else if (t.opt.overflow) { //if overflow is set, incriment min-width to force overflow t.css('min-width', t.w + inc); reAssignColumnWidth(t, i); } if (isOver) { c.w = w; c2.w = t.f ? w2 : c2.w; } }; //as the drag action happens, loop thru each grid column, //get the column widths and reassign back so that they do not adjust var reAssignColumnWidth = function (t, i) { for (count = 0; count < t.ln; count++) { if (count != i) { //if current index is not the dragged grip index t.cg.eq(count).width(t.c[count].w + PX); } else { //change the width of the column to the left of the grip //being dragged var draggedLength = drag.x - drag.l; var columnLeft = t.c[i]; var columnLeftNewWidth = columnLeft.w + draggedLength; columnLeft.width(columnLeftNewWidth + PX); t.cg.eq(i).width(columnLeftNewWidth + PX); } } }; /** * This function updates all columns width according to its real width. It must be taken into account that the * sum of all columns can exceed the table width in some cases (if fixed is set to false and table has some kind * of max-width). * @param {jQuery ref} t - table object */ var applyBounds = function (t) { var w = $.map(t.c, function (c) { //obtain real widths return c.width(); }); t.width(t.w = t.width()).removeClass(FLEX); //prevent table width changes $.each(t.c, function (i, c) { c.width(w[i]).w = w[i]; //set column widths applying bounds (table's max-width) }); t.addClass(FLEX); //allow table width changes }; /** * Event handler used while dragging a grip. It checks if the next grip's position is valid and updates it. * @param {event} e - mousemove event binded to the window object */ var onGripDrag = function (e) { if (!drag) return; var t = drag.t; //table object reference var oe = e.originalEvent.touches; var ox = oe ? oe[0].pageX : e.pageX; //original position (touch or mouse) var x = ox - drag.ox + drag.l; //next position according to horizontal mouse position increment var mw = t.opt.minWidth, i = drag.i; //cell's min width var l = t.cs * 1.5 + mw + t.b; var last = i == t.ln - 1; //check if it is the last column's grip (usually hidden) var min = i ? t.g[i - 1].position().left + t.cs + mw : l; //min position according to the contiguous cells var max = t.f ? //fixed mode? i == t.ln - 1 ? t.w - l : t.g[i + 1].position().left - t.cs - mw : Infinity; //max position according to the contiguous cells x = M.max(min, M.min(max, x)); //apply bounding drag.x = x; drag.css("left", x + PX); //apply position increment if (last) { //if it is the last grip var c = t.c[drag.i]; //width of the last column is obtained drag.w = c.w + x - drag.l; } if (t.opt.liveDrag) { //if liveDrag is enabled if (last) { c.width(drag.w); if (!t.f && t.opt.overflow) { //if overflow is set, incriment min-width to force overflow t.css('min-width', t.w + x - drag.l); } else { t.w = t.width(); } } syncCols(t, i); //columns are synchronized syncGrips(t); var cb = t.opt.onDrag; //check if there is an onDrag callback if (cb) { e.currentTarget = t[0]; cb(e); } //if any, it is fired } return false; //prevent text selection while dragging }; /** * Event handler fired when the dragging is over, updating table layout * @param {event} e - grip's drag over event */ var onGripDragOver = function (e) { d.unbind('touchend.' + SIGNATURE + ' mouseup.' + SIGNATURE).unbind('touchmove.' + SIGNATURE + ' mousemove.' + SIGNATURE); $("head :last-child").remove(); //remove the dragging cursor style if (!drag) return; drag.removeClass(drag.t.opt.draggingClass); //remove the grip's dragging css-class if (!(drag.x - drag.l == 0)) { var t = drag.t; var cb = t.opt.onResize; //get some values var i = drag.i; //column index var last = i == t.ln - 1; //check if it is the last column's grip (usually hidden) var c = t.g[i].c; //the column being dragged if (last) { c.width(drag.w); c.w = drag.w; } else { syncCols(t, i, true); //the columns are updated } if (!t.f) applyBounds(t); //if not fixed mode, then apply bounds to obtain real width values syncGrips(t); //the grips are updated if (cb) { e.currentTarget = t[0]; cb(e); } //if there is a callback function, it is fired if (t.p && S) memento(t); //if postbackSafe is enabled and there is sessionStorage support, the new layout is serialized and stored } drag = null; //since the grip's dragging is over }; /** * Event handler fired when the grip's dragging is about to start. Its main goal is to set up events * and store some values used while dragging. * @param {event} e - grip's mousedown event */ var onGripMouseDown = function (e) { var o = $(this).data(SIGNATURE); //retrieve grip's data var t = tables[o.t], g = t.g[o.i]; //shortcuts for the table and grip objects var oe = e.originalEvent.touches; //touch or mouse event? g.ox = oe ? oe[0].pageX : e.pageX; //the initial position is kept g.l = g.position().left; g.x = g.l; d.bind('touchmove.' + SIGNATURE + ' mousemove.' + SIGNATURE, onGripDrag).bind('touchend.' + SIGNATURE + ' mouseup.' + SIGNATURE, onGripDragOver); //mousemove and mouseup events are bound h.append(""); //change the mouse cursor g.addClass(t.opt.draggingClass); //add the dragging class (to allow some visual feedback) drag = g; //the current grip is stored as the current dragging object if (t.c[o.i].l) for (var i = 0, c; i < t.ln; i++) { c = t.c[i]; c.l = false; c.w = c.width(); } //if the colum is locked (after browser resize), then c.w must be updated return false; //prevent text selection }; /** * Event handler fired when the browser is resized. The main purpose of this function is to update * table layout according to the browser's size synchronizing related grips */ var onResize = function () { for (var t in tables) { if (tables.hasOwnProperty(t)) { t = tables[t]; var i, mw = 0; t.removeClass(SIGNATURE); //firefox doesn't like layout-fixed in some cases if (t.f) { //in fixed mode t.w = t.width(); //its new width is kept for (i = 0; i < t.ln; i++) mw += t.c[i].w; //cell rendering is not as trivial as it might seem, and it is slightly different for //each browser. In the beginning i had a big switch for each browser, but since the code //was extremely ugly now I use a different approach with several re-flows. This works //pretty well but it's a bit slower. For now, lets keep things simple... for (i = 0; i < t.ln; i++) t.c[i].css("width", M.round(1024 * t.c[i].w / mw) / 10 + "%").l = true; //c.l locks the column, telling us that its c.w is outdated } else { //in non fixed-sized tables applyBounds(t); //apply the new bounds if (t.mode == 'flex' && t.p && S) { //if postbackSafe is enabled and there is sessionStorage support, memento(t); //the new layout is serialized and stored for 'flex' tables } } syncGrips(t.addClass(SIGNATURE)); } } }; var getResizableSessionStorageKeyBy = function (tableId) { //SysGetApplicationName function is generated on server side. return "resizable_" + SysGetApplicationName() + "_" + SysDivision() + "_" + tableId; }; var getAllTableResizableSessionStorageKey = function () { return "resizable_" + SysGetApplicationName() + "_" + SysDivision() + "_AllTables"; }; var allTableResizableColumnJSONData = {}; //To hold all table resizable JSON data. The page can contains more than 1 table. var resizableColumnJSONData = {}; //To hold 1 table resizable JSON data. var updateResizableColumnsHiddenFieldAndSessionStorage = function (tableId) { allTableResizableColumnJSONData[tableId] = resizableColumnJSONData; var stringifyResizableColumnJSONData = JSON.stringify(resizableColumnJSONData); $('#' + tableId + '_ResizableColumnsCtl').val(stringifyResizableColumnJSONData); S[getResizableSessionStorageKeyBy(tableId)] = stringifyResizableColumnJSONData; S[getAllTableResizableSessionStorageKey()] = JSON.stringify(allTableResizableColumnJSONData); }; var setResizableColumnJSONData = function (tableId) { if (S[getAllTableResizableSessionStorageKey()]) { allTableResizableColumnJSONData = JSON.parse(S[getAllTableResizableSessionStorageKey()]); } //When we have more than 1 table in the page, retrieve table resizable JSON data based on table id. resizableColumnJSONData = allTableResizableColumnJSONData[tableId]; if (resizableColumnJSONData === undefined) { resizableColumnJSONData = {}; } }; // Triggered when column is resized. var saveResizableColumnJSONData = function (tableId, columnId, columnWidth) { setResizableColumnJSONData(tableId); resizableColumnJSONData[columnId] = columnWidth; updateResizableColumnsHiddenFieldAndSessionStorage(tableId); }; // Triggered when page is initialized and refresh mode. var updateResizableColumnJSONData = function (tableId, t, th) { //Update resizable column JSON based on latest updates on the grid visible columns //-- Column already exists with the customized width, we need to restore it instead of overwrite the column width value. //-- New column that just added to the grid will used the default column width assigned to the column header (th) var totalPixelUsedByColumns = 0; var updatedResizableColumnJSONData = {}; setResizableColumnJSONData(tableId); //Load resizable column based on hidden field value. var isEmptyObject = $.isEmptyObject(resizableColumnJSONData); var resizableColumnsHiddenField = $('#' + tableId + '_ResizableColumnsCtl'); if (resizableColumnsHiddenField && resizableColumnsHiddenField.val() !== "" && isEmptyObject) { resizableColumnJSONData = JSON.parse(resizableColumnsHiddenField.val()); } //Re-populate and massage resizable column json data based on latest table changes (Customization) for (i = 0; i < t.ln; i++) { //iterate through columns var columnId = th.eq(i).attr("id"); var thWidth = th.eq(i).width(); var newAddedColumn = (resizableColumnJSONData[columnId] === undefined); if (newAddedColumn) { //Set newly added column with default width. updatedResizableColumnJSONData[columnId] = thWidth; } else { //set existing column with resized width thWidth = resizableColumnJSONData[columnId]; updatedResizableColumnJSONData[columnId] = thWidth; } totalPixelUsedByColumns += thWidth; } updatedResizableColumnJSONData["totalPixelUsedByColumns"] = totalPixelUsedByColumns; //Set the table resizable column JSON data resizableColumnJSONData = updatedResizableColumnJSONData; updateResizableColumnsHiddenFieldAndSessionStorage(tableId); }; var hasDefaultResizedColumnData = function (tableId) { if (S[getAllTableResizableSessionStorageKey()]) { allTableResizableColumnJSONData = JSON.parse(S[getAllTableResizableSessionStorageKey()]); return (allTableResizableColumnJSONData[tableId] !== undefined); } else return 0; }; /** * The plugin is added to the jQuery library * @param {Object} options - an object that holds some basic customization values */ $.fn.extend({ colResizable: function (options) { var defaults = { //attributes: resizeMode: 'fit', //mode can be 'fit', 'flex' or 'overflow' draggingClass: 'JCLRgripDrag', //css-class used when a grip is being dragged (for visual feedback purposes) gripInnerHtml: '', //if it is required to use a custom grip it can be done using some custom HTML liveDrag: false, //enables table-layout updating while dragging minWidth: 15, //minimum width value in pixels allowed for a column headerOnly: false, //specifies that the size of the the column resizing anchors will be bounded to the size of the first row hoverCursor: "e-resize", //cursor to be used on grip hover dragCursor: "e-resize", //cursor to be used while dragging postbackSafe: false, //when it is enabled, table layout can persist after postback or page refresh. It requires browsers with sessionStorage support (it can be emulated with sessionStorage.js). flush: false, //when postbakSafe is enabled, and it is required to prevent layout restoration after postback, 'flush' will remove its associated layout data marginLeft: null, //in case the table contains any margins, colResizable needs to know the values used, e.g. "10%", "15em", "5px" ... marginRight: null, //in case the table contains any margins, colResizable needs to know the values used, e.g. "10%", "15em", "5px" ... disable: false, //disables all the enhancements performed in a previously colResized table partialRefresh: false, //can be used in combination with postbackSafe when the table is inside of an updatePanel, disabledColumns: [], //column indexes to be excluded //events: onDrag: null, //callback function to be fired during the column resizing process if liveDrag is enabled onResize: null //callback function fired when the dragging process is over } var options = $.extend(defaults, options); //since now there are 3 different ways of resizing columns, I changed the external interface to make it clear //calling it 'resizeMode' but also to remove the "fixed" attribute which was confusing for many people options.fixed = true; options.overflow = false; switch (options.resizeMode) { case 'flex': options.fixed = false; break; case 'overflow': options.fixed = false; options.overflow = true; break; } return this.each(function () { init(this, options); }); } }); })(jQuery); ; (function(){ // Apply $.DataTable to the default jQuery instance; // pass through to the specific versioned jQuery instance, because datatable doesn't support jQuery v1.5. // Prepare BCMatrix table before applying DataTable component. $.fn.extend({ DataTableModified: function (options) { var tbl = $(this); prepareBcMatrixTable(tbl); moveHiddenInputs(tbl); return jQuery(tbl.get(0)).DataTable(options); } }); // Move hidden inputs to the last column, so they won't get cloned. // Note: don't use non-hidden input fields in cloned columns, as they can't be moved. function moveHiddenInputs(tbl) { tbl.find('tbody tr input:hidden').each(function () { $(this).appendTo($(this).closest('tr').children('td:last-child')); }); } // Fix DOM issues with BCMatrix before passing it on to the datatables component function prepareBcMatrixTable(tbl) { // rowtotals=false hides the column instead of not rendering, fix this. tbl.find('tr td.RowNumber:hidden:not(:first-child)').remove(); var tblBody = tbl.children('tbody').first(); var bcMatrixRows = tblBody.children('tr'); var bcMatrixHeaderRows = bcMatrixRows.filter('.Header'); if (bcMatrixHeaderRows.length) { var dataRows = bcMatrixRows.not('.Header'); var firstDataRowIndex = bcMatrixRows.index(dataRows.first()); var headers = bcMatrixRows.slice(0, firstDataRowIndex); var footers = bcMatrixHeaderRows.not(headers); // datatables fixedcolumn fixes thead and tfoot // move headers into a thead tag if (headers.length && !tbl.children('thead').length) headers.wrapAll('').parent().insertBefore(tblBody); // don't move footers, as the total field update doesn't apply to the moved footer. // Place double BCMatrix headers on a single row if (headers.length == 2 && headers.children('.CellColumnHeader').length) { var topHeader = headers.eq(0), subHeader = headers.eq(1); var headerTitles = topHeader.children(':not(.CellColumnHeader)'); subHeader.children().slice(0, headerTitles.length).remove(); subHeader.prepend(headerTitles); topHeader.remove(); } } } })();; /* * DataTables supports jQuery 1.7+; * [$, jQuery] currently run v1.5 and an alias [jQuery_v1_11] runs on v1.11.0. * Remapping $ and jQuery to jQuery_v1_11 within this current scope * to have datatables defined on the newer version instance of jQuery. */ (function($, jQuery){ /* * This combined file was created by the DataTables downloader builder: * https://datatables.net/download * * To rebuild or modify this file with the latest versions of the included * software please visit: * https://datatables.net/download/#dt/dt-2.1.5/fc-5.0.1 * * Included libraries: * DataTables 2.1.5, FixedColumns 5.0.1 */ /*! DataTables 2.1.5 * © SpryMedia Ltd - datatables.net/license */ /** * @summary DataTables * @description Paginate, search and order HTML tables * @version 2.1.5 * @author SpryMedia Ltd * @contact www.datatables.net * @copyright SpryMedia Ltd. * * This source file is free software, available under the following license: * MIT license - https://datatables.net/license * * This source file is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details. * * For details please refer to: https://www.datatables.net */ (function( factory ) { "use strict"; if ( typeof define === 'function' && define.amd ) { // AMD define( ['jquery'], function ( $ ) { return factory( $, window, document ); } ); } else if ( typeof exports === 'object' ) { // CommonJS // jQuery's factory checks for a global window - if it isn't present then it // returns a factory function that expects the window object var jq = require('jquery'); if (typeof window === 'undefined') { module.exports = function (root, $) { if ( ! root ) { // CommonJS environments without a window global must pass a // root. This will give an error otherwise root = window; } if ( ! $ ) { $ = jq( root ); } return factory( $, root, root.document ); }; } else { module.exports = factory( jq, window, window.document ); } } else { // Browser window.DataTable = factory( jQuery, window, document ); } }(function( $, window, document ) { "use strict"; var DataTable = function ( selector, options ) { // Check if called with a window or jQuery object for DOM less applications // This is for backwards compatibility if (DataTable.factory(selector, options)) { return DataTable; } // When creating with `new`, create a new DataTable, returning the API instance if (this instanceof DataTable) { return $(selector).DataTable(options); } else { // Argument switching options = selector; } var _that = this; var emptyInit = options === undefined; var len = this.length; if ( emptyInit ) { options = {}; } // Method to get DT API instance from jQuery object this.api = function () { return new _Api( this ); }; this.each(function() { // For each initialisation we want to give it a clean initialisation // object that can be bashed around var o = {}; var oInit = len > 1 ? // optimisation for single table case _fnExtend( o, options, true ) : options; var i=0, iLen; var sId = this.getAttribute( 'id' ); var defaults = DataTable.defaults; var $this = $(this); /* Sanity check */ if ( this.nodeName.toLowerCase() != 'table' ) { _fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 ); return; } $(this).trigger( 'options.dt', oInit ); /* Backwards compatibility for the defaults */ _fnCompatOpts( defaults ); _fnCompatCols( defaults.column ); /* Convert the camel-case defaults to Hungarian */ _fnCamelToHungarian( defaults, defaults, true ); _fnCamelToHungarian( defaults.column, defaults.column, true ); /* Setting up the initialisation object */ _fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true ); /* Check to see if we are re-initialising a table */ var allSettings = DataTable.settings; for ( i=0, iLen=allSettings.length ; i').prependTo(this), fastData: function (row, column, type) { return _fnGetCellData(oSettings, row, column, type); } } ); oSettings.nTable = this; oSettings.oInit = oInit; allSettings.push( oSettings ); // Make a single API instance available for internal handling oSettings.api = new _Api( oSettings ); // Need to add the instance after the instance after the settings object has been added // to the settings array, so we can self reference the table instance if more than one oSettings.oInstance = (_that.length===1) ? _that : $this.dataTable(); // Backwards compatibility, before we apply all the defaults _fnCompatOpts( oInit ); // If the length menu is given, but the init display length is not, use the length menu if ( oInit.aLengthMenu && ! oInit.iDisplayLength ) { oInit.iDisplayLength = Array.isArray(oInit.aLengthMenu[0]) ? oInit.aLengthMenu[0][0] : $.isPlainObject( oInit.aLengthMenu[0] ) ? oInit.aLengthMenu[0].value : oInit.aLengthMenu[0]; } // Apply the defaults and init options to make a single init object will all // options defined from defaults and instance options. oInit = _fnExtend( $.extend( true, {}, defaults ), oInit ); // Map the initialisation options onto the settings object _fnMap( oSettings.oFeatures, oInit, [ "bPaginate", "bLengthChange", "bFilter", "bSort", "bSortMulti", "bInfo", "bProcessing", "bAutoWidth", "bSortClasses", "bServerSide", "bDeferRender" ] ); _fnMap( oSettings, oInit, [ "ajax", "fnFormatNumber", "sServerMethod", "aaSorting", "aaSortingFixed", "aLengthMenu", "sPaginationType", "iStateDuration", "bSortCellsTop", "iTabIndex", "sDom", "fnStateLoadCallback", "fnStateSaveCallback", "renderer", "searchDelay", "rowId", "caption", "layout", "orderDescReverse", [ "iCookieDuration", "iStateDuration" ], // backwards compat [ "oSearch", "oPreviousSearch" ], [ "aoSearchCols", "aoPreSearchCols" ], [ "iDisplayLength", "_iDisplayLength" ] ] ); _fnMap( oSettings.oScroll, oInit, [ [ "sScrollX", "sX" ], [ "sScrollXInner", "sXInner" ], [ "sScrollY", "sY" ], [ "bScrollCollapse", "bCollapse" ] ] ); _fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" ); /* Callback functions which are array driven */ _fnCallbackReg( oSettings, 'aoDrawCallback', oInit.fnDrawCallback ); _fnCallbackReg( oSettings, 'aoStateSaveParams', oInit.fnStateSaveParams ); _fnCallbackReg( oSettings, 'aoStateLoadParams', oInit.fnStateLoadParams ); _fnCallbackReg( oSettings, 'aoStateLoaded', oInit.fnStateLoaded ); _fnCallbackReg( oSettings, 'aoRowCallback', oInit.fnRowCallback ); _fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow ); _fnCallbackReg( oSettings, 'aoHeaderCallback', oInit.fnHeaderCallback ); _fnCallbackReg( oSettings, 'aoFooterCallback', oInit.fnFooterCallback ); _fnCallbackReg( oSettings, 'aoInitComplete', oInit.fnInitComplete ); _fnCallbackReg( oSettings, 'aoPreDrawCallback', oInit.fnPreDrawCallback ); oSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId ); /* Browser support detection */ _fnBrowserDetect( oSettings ); var oClasses = oSettings.oClasses; $.extend( oClasses, DataTable.ext.classes, oInit.oClasses ); $this.addClass( oClasses.table ); if (! oSettings.oFeatures.bPaginate) { oInit.iDisplayStart = 0; } if ( oSettings.iInitDisplayStart === undefined ) { /* Display start point, taking into account the save saving */ oSettings.iInitDisplayStart = oInit.iDisplayStart; oSettings._iDisplayStart = oInit.iDisplayStart; } var defer = oInit.iDeferLoading; if ( defer !== null ) { oSettings.deferLoading = true; var tmp = Array.isArray(defer); oSettings._iRecordsDisplay = tmp ? defer[0] : defer; oSettings._iRecordsTotal = tmp ? defer[1] : defer; } /* * Columns * See if we should load columns automatically or use defined ones */ var columnsInit = []; var thead = this.getElementsByTagName('thead'); var initHeaderLayout = _fnDetectHeader( oSettings, thead[0] ); // If we don't have a columns array, then generate one with nulls if ( oInit.aoColumns ) { columnsInit = oInit.aoColumns; } else if ( initHeaderLayout.length ) { for ( i=0, iLen=initHeaderLayout[0].length ; i').appendTo( $this ); } caption.html( oSettings.caption ); } // Store the caption side, so we can remove the element from the document // when creating the element if (caption.length) { caption[0]._captionSide = caption.css('caption-side'); oSettings.captionNode = caption[0]; } if ( thead.length === 0 ) { thead = $('').appendTo($this); } oSettings.nTHead = thead[0]; $('tr', thead).addClass(oClasses.thead.row); var tbody = $this.children('tbody'); if ( tbody.length === 0 ) { tbody = $('').insertAfter(thead); } oSettings.nTBody = tbody[0]; var tfoot = $this.children('tfoot'); if ( tfoot.length === 0 ) { // If we are a scrolling table, and no footer has been given, then we need to create // a tfoot element for the caption element to be appended to tfoot = $('').appendTo($this); } oSettings.nTFoot = tfoot[0]; $('tr', tfoot).addClass(oClasses.tfoot.row); // Copy the data index array oSettings.aiDisplay = oSettings.aiDisplayMaster.slice(); // Initialisation complete - table can be drawn oSettings.bInitialised = true; // Language definitions var oLanguage = oSettings.oLanguage; $.extend( true, oLanguage, oInit.oLanguage ); if ( oLanguage.sUrl ) { // Get the language definitions from a file $.ajax( { dataType: 'json', url: oLanguage.sUrl, success: function ( json ) { _fnCamelToHungarian( defaults.oLanguage, json ); $.extend( true, oLanguage, json, oSettings.oInit.oLanguage ); _fnCallbackFire( oSettings, null, 'i18n', [oSettings], true); _fnInitialise( oSettings ); }, error: function () { // Error occurred loading language file _fnLog( oSettings, 0, 'i18n file loading error', 21 ); // Continue on as best we can _fnInitialise( oSettings ); } } ); } else { _fnCallbackFire( oSettings, null, 'i18n', [oSettings]); _fnInitialise( oSettings ); } } ); _that = null; return this; }; /** * DataTables extensions * * This namespace acts as a collection area for plug-ins that can be used to * extend DataTables capabilities. Indeed many of the build in methods * use this method to provide their own capabilities (sorting methods for * example). * * Note that this namespace is aliased to `jQuery.fn.dataTableExt` for legacy * reasons * * @namespace */ DataTable.ext = _ext = { /** * Buttons. For use with the Buttons extension for DataTables. This is * defined here so other extensions can define buttons regardless of load * order. It is _not_ used by DataTables core. * * @type object * @default {} */ buttons: {}, /** * Element class names * * @type object * @default {} */ classes: {}, /** * DataTables build type (expanded by the download builder) * * @type string */ builder: "dt/dt-2.1.5/fc-5.0.1", /** * Error reporting. * * How should DataTables report an error. Can take the value 'alert', * 'throw', 'none' or a function. * * @type string|function * @default alert */ errMode: "alert", /** * Legacy so v1 plug-ins don't throw js errors on load */ feature: [], /** * Feature plug-ins. * * This is an object of callbacks which provide the features for DataTables * to be initialised via the `layout` option. */ features: {}, /** * Row searching. * * This method of searching is complimentary to the default type based * searching, and a lot more comprehensive as it allows you complete control * over the searching logic. Each element in this array is a function * (parameters described below) that is called for every row in the table, * and your logic decides if it should be included in the searching data set * or not. * * Searching functions have the following input parameters: * * 1. `{object}` DataTables settings object: see * {@link DataTable.models.oSettings} * 2. `{array|object}` Data for the row to be processed (same as the * original format that was passed in as the data source, or an array * from a DOM data source * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which * can be useful to retrieve the `TR` element if you need DOM interaction. * * And the following return is expected: * * * {boolean} Include the row in the searched result set (true) or not * (false) * * Note that as with the main search ability in DataTables, technically this * is "filtering", since it is subtractive. However, for consistency in * naming we call it searching here. * * @type array * @default [] * * @example * // The following example shows custom search being applied to the * // fourth column (i.e. the data[3] index) based on two input values * // from the end-user, matching the data in a certain range. * $.fn.dataTable.ext.search.push( * function( settings, data, dataIndex ) { * var min = document.getElementById('min').value * 1; * var max = document.getElementById('max').value * 1; * var version = data[3] == "-" ? 0 : data[3]*1; * * if ( min == "" && max == "" ) { * return true; * } * else if ( min == "" && version < max ) { * return true; * } * else if ( min < version && "" == max ) { * return true; * } * else if ( min < version && version < max ) { * return true; * } * return false; * } * ); */ search: [], /** * Selector extensions * * The `selector` option can be used to extend the options available for the * selector modifier options (`selector-modifier` object data type) that * each of the three built in selector types offer (row, column and cell + * their plural counterparts). For example the Select extension uses this * mechanism to provide an option to select only rows, columns and cells * that have been marked as selected by the end user (`{selected: true}`), * which can be used in conjunction with the existing built in selector * options. * * Each property is an array to which functions can be pushed. The functions * take three attributes: * * * Settings object for the host table * * Options object (`selector-modifier` object type) * * Array of selected item indexes * * The return is an array of the resulting item indexes after the custom * selector has been applied. * * @type object */ selector: { cell: [], column: [], row: [] }, /** * Legacy configuration options. Enable and disable legacy options that * are available in DataTables. * * @type object */ legacy: { /** * Enable / disable DataTables 1.9 compatible server-side processing * requests * * @type boolean * @default null */ ajax: null }, /** * Pagination plug-in methods. * * Each entry in this object is a function and defines which buttons should * be shown by the pagination rendering method that is used for the table: * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the * buttons are displayed in the document, while the functions here tell it * what buttons to display. This is done by returning an array of button * descriptions (what each button will do). * * Pagination types (the four built in options and any additional plug-in * options defined here) can be used through the `paginationType` * initialisation parameter. * * The functions defined take two parameters: * * 1. `{int} page` The current page index * 2. `{int} pages` The number of pages in the table * * Each function is expected to return an array where each element of the * array can be one of: * * * `first` - Jump to first page when activated * * `last` - Jump to last page when activated * * `previous` - Show previous page when activated * * `next` - Show next page when activated * * `{int}` - Show page of the index given * * `{array}` - A nested array containing the above elements to add a * containing 'DIV' element (might be useful for styling). * * Note that DataTables v1.9- used this object slightly differently whereby * an object with two functions would be defined for each plug-in. That * ability is still supported by DataTables 1.10+ to provide backwards * compatibility, but this option of use is now decremented and no longer * documented in DataTables 1.10+. * * @type object * @default {} * * @example * // Show previous, next and current page buttons only * $.fn.dataTableExt.oPagination.current = function ( page, pages ) { * return [ 'previous', page, 'next' ]; * }; */ pager: {}, renderer: { pageButton: {}, header: {} }, /** * Ordering plug-ins - custom data source * * The extension options for ordering of data available here is complimentary * to the default type based ordering that DataTables typically uses. It * allows much greater control over the the data that is being used to * order a column, but is necessarily therefore more complex. * * This type of ordering is useful if you want to do ordering based on data * live from the DOM (for example the contents of an 'input' element) rather * than just the static string that DataTables knows of. * * The way these plug-ins work is that you create an array of the values you * wish to be ordering for the column in question and then return that * array. The data in the array much be in the index order of the rows in * the table (not the currently ordering order!). Which order data gathering * function is run here depends on the `dt-init columns.orderDataType` * parameter that is used for the column (if any). * * The functions defined take two parameters: * * 1. `{object}` DataTables settings object: see * {@link DataTable.models.oSettings} * 2. `{int}` Target column index * * Each function is expected to return an array: * * * `{array}` Data for the column to be ordering upon * * @type array * * @example * // Ordering using `input` node values * $.fn.dataTable.ext.order['dom-text'] = function ( settings, col ) * { * return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) { * return $('input', td).val(); * } ); * } */ order: {}, /** * Type based plug-ins. * * Each column in DataTables has a type assigned to it, either by automatic * detection or by direct assignment using the `type` option for the column. * The type of a column will effect how it is ordering and search (plug-ins * can also make use of the column type if required). * * @namespace */ type: { /** * Automatic column class assignment */ className: {}, /** * Type detection functions. * * The functions defined in this object are used to automatically detect * a column's type, making initialisation of DataTables super easy, even * when complex data is in the table. * * The functions defined take two parameters: * * 1. `{*}` Data from the column cell to be analysed * 2. `{settings}` DataTables settings object. This can be used to * perform context specific type detection - for example detection * based on language settings such as using a comma for a decimal * place. Generally speaking the options from the settings will not * be required * * Each function is expected to return: * * * `{string|null}` Data type detected, or null if unknown (and thus * pass it on to the other type detection functions. * * @type array * * @example * // Currency type detection plug-in: * $.fn.dataTable.ext.type.detect.push( * function ( data, settings ) { * // Check the numeric part * if ( ! data.substring(1).match(/[0-9]/) ) { * return null; * } * * // Check prefixed by currency * if ( data.charAt(0) == '$' || data.charAt(0) == '£' ) { * return 'currency'; * } * return null; * } * ); */ detect: [], /** * Automatic renderer assignment */ render: {}, /** * Type based search formatting. * * The type based searching functions can be used to pre-format the * data to be search on. For example, it can be used to strip HTML * tags or to de-format telephone numbers for numeric only searching. * * Note that is a search is not defined for a column of a given type, * no search formatting will be performed. * * Pre-processing of searching data plug-ins - When you assign the sType * for a column (or have it automatically detected for you by DataTables * or a type detection plug-in), you will typically be using this for * custom sorting, but it can also be used to provide custom searching * by allowing you to pre-processing the data and returning the data in * the format that should be searched upon. This is done by adding * functions this object with a parameter name which matches the sType * for that target column. This is the corollary of afnSortData * for searching data. * * The functions defined take a single parameter: * * 1. `{*}` Data from the column cell to be prepared for searching * * Each function is expected to return: * * * `{string|null}` Formatted string that will be used for the searching. * * @type object * @default {} * * @example * $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) { * return d.replace(/\n/g," ").replace( /<.*?>/g, "" ); * } */ search: {}, /** * Type based ordering. * * The column type tells DataTables what ordering to apply to the table * when a column is sorted upon. The order for each type that is defined, * is defined by the functions available in this object. * * Each ordering option can be described by three properties added to * this object: * * * `{type}-pre` - Pre-formatting function * * `{type}-asc` - Ascending order function * * `{type}-desc` - Descending order function * * All three can be used together, only `{type}-pre` or only * `{type}-asc` and `{type}-desc` together. It is generally recommended * that only `{type}-pre` is used, as this provides the optimal * implementation in terms of speed, although the others are provided * for compatibility with existing Javascript sort functions. * * `{type}-pre`: Functions defined take a single parameter: * * 1. `{*}` Data from the column cell to be prepared for ordering * * And return: * * * `{*}` Data to be sorted upon * * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort * functions, taking two parameters: * * 1. `{*}` Data to compare to the second parameter * 2. `{*}` Data to compare to the first parameter * * And returning: * * * `{*}` Ordering match: <0 if first parameter should be sorted lower * than the second parameter, ===0 if the two parameters are equal and * >0 if the first parameter should be sorted height than the second * parameter. * * @type object * @default {} * * @example * // Numeric ordering of formatted numbers with a pre-formatter * $.extend( $.fn.dataTable.ext.type.order, { * "string-pre": function(x) { * a = (a === "-" || a === "") ? 0 : a.replace( /[^\d\-\.]/g, "" ); * return parseFloat( a ); * } * } ); * * @example * // Case-sensitive string ordering, with no pre-formatting method * $.extend( $.fn.dataTable.ext.order, { * "string-case-asc": function(x,y) { * return ((x < y) ? -1 : ((x > y) ? 1 : 0)); * }, * "string-case-desc": function(x,y) { * return ((x < y) ? 1 : ((x > y) ? -1 : 0)); * } * } ); */ order: {} }, /** * Unique DataTables instance counter * * @type int * @private */ _unique: 0, // // Depreciated // The following properties are retained for backwards compatibility only. // The should not be used in new projects and will be removed in a future // version // /** * Version check function. * @type function * @depreciated Since 1.10 */ fnVersionCheck: DataTable.fnVersionCheck, /** * Index for what 'this' index API functions should use * @type int * @deprecated Since v1.10 */ iApiIndex: 0, /** * Software version * @type string * @deprecated Since v1.10 */ sVersion: DataTable.version }; // // Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts // $.extend( _ext, { afnFiltering: _ext.search, aTypes: _ext.type.detect, ofnSearch: _ext.type.search, oSort: _ext.type.order, afnSortData: _ext.order, aoFeatures: _ext.feature, oStdClasses: _ext.classes, oPagination: _ext.pager } ); $.extend( DataTable.ext.classes, { container: 'dt-container', empty: { row: 'dt-empty' }, info: { container: 'dt-info' }, layout: { row: 'dt-layout-row', cell: 'dt-layout-cell', tableRow: 'dt-layout-table', tableCell: '', start: 'dt-layout-start', end: 'dt-layout-end', full: 'dt-layout-full' }, length: { container: 'dt-length', select: 'dt-input' }, order: { canAsc: 'dt-orderable-asc', canDesc: 'dt-orderable-desc', isAsc: 'dt-ordering-asc', isDesc: 'dt-ordering-desc', none: 'dt-orderable-none', position: 'sorting_' }, processing: { container: 'dt-processing' }, scrolling: { body: 'dt-scroll-body', container: 'dt-scroll', footer: { self: 'dt-scroll-foot', inner: 'dt-scroll-footInner' }, header: { self: 'dt-scroll-head', inner: 'dt-scroll-headInner' } }, search: { container: 'dt-search', input: 'dt-input' }, table: 'dataTable', tbody: { cell: '', row: '' }, thead: { cell: '', row: '' }, tfoot: { cell: '', row: '' }, paging: { active: 'current', button: 'dt-paging-button', container: 'dt-paging', disabled: 'disabled', nav: '' } } ); /* * It is useful to have variables which are scoped locally so only the * DataTables functions can access them and they don't leak into global space. * At the same time these functions are often useful over multiple files in the * core and API, so we list, or at least document, all variables which are used * by DataTables as private variables here. This also ensures that there is no * clashing of variable names and that they can easily referenced for reuse. */ // Defined else where // _selector_run // _selector_opts // _selector_row_indexes var _ext; // DataTable.ext var _Api; // DataTable.Api var _api_register; // DataTable.Api.register var _api_registerPlural; // DataTable.Api.registerPlural var _re_dic = {}; var _re_new_lines = /[\r\n\u2028]/g; var _re_html = /<([^>]*>)/g; var _max_str_len = Math.pow(2, 28); // This is not strict ISO8601 - Date.parse() is quite lax, although // implementations differ between browsers. var _re_date = /^\d{2,4}[./-]\d{1,2}[./-]\d{1,2}([T ]{1}\d{1,2}[:.]\d{2}([.:]\d{2})?)?$/; // Escape regular expression special characters var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' ); // https://en.wikipedia.org/wiki/Foreign_exchange_market // - \u20BD - Russian ruble. // - \u20a9 - South Korean Won // - \u20BA - Turkish Lira // - \u20B9 - Indian Rupee // - R - Brazil (R$) and South Africa // - fr - Swiss Franc // - kr - Swedish krona, Norwegian krone and Danish krone // - \u2009 is thin space and \u202F is narrow no-break space, both used in many // - Ƀ - Bitcoin // - Ξ - Ethereum // standards as thousands separators. var _re_formatted_numeric = /['\u00A0,$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfkɃΞ]/gi; var _empty = function ( d ) { return !d || d === true || d === '-' ? true : false; }; var _intVal = function ( s ) { var integer = parseInt( s, 10 ); return !isNaN(integer) && isFinite(s) ? integer : null; }; // Convert from a formatted number with characters other than `.` as the // decimal place, to a Javascript number var _numToDecimal = function ( num, decimalPoint ) { // Cache created regular expressions for speed as this function is called often if ( ! _re_dic[ decimalPoint ] ) { _re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' ); } return typeof num === 'string' && decimalPoint !== '.' ? num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) : num; }; var _isNumber = function ( d, decimalPoint, formatted, allowEmpty ) { var type = typeof d; var strType = type === 'string'; if ( type === 'number' || type === 'bigint') { return true; } // If empty return immediately so there must be a number if it is a // formatted string (this stops the string "k", or "kr", etc being detected // as a formatted number for currency if ( allowEmpty && _empty( d ) ) { return true; } if ( decimalPoint && strType ) { d = _numToDecimal( d, decimalPoint ); } if ( formatted && strType ) { d = d.replace( _re_formatted_numeric, '' ); } return !isNaN( parseFloat(d) ) && isFinite( d ); }; // A string without HTML in it can be considered to be HTML still var _isHtml = function ( d ) { return _empty( d ) || typeof d === 'string'; }; // Is a string a number surrounded by HTML? var _htmlNumeric = function ( d, decimalPoint, formatted, allowEmpty ) { if ( allowEmpty && _empty( d ) ) { return true; } // input and select strings mean that this isn't just a number if (typeof d === 'string' && d.match(/<(input|select)/i)) { return null; } var html = _isHtml( d ); return ! html ? null : _isNumber( _stripHtml( d ), decimalPoint, formatted, allowEmpty ) ? true : null; }; var _pluck = function ( a, prop, prop2 ) { var out = []; var i=0, ien=a.length; // Could have the test in the loop for slightly smaller code, but speed // is essential here if ( prop2 !== undefined ) { for ( ; i _max_str_len) { throw new Error('Exceeded max str len'); } var previous; input = input.replace(_re_html, ''); // Complete tags // Safety for incomplete script tag - use do / while to ensure that // we get all instances do { previous = input; input = input.replace(/