{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///canvas-datagrid.js","webpack:///webpack/bootstrap ef48c86715f3e382e77c","webpack:///./lib/defaults.js","webpack:///./lib/main.js","webpack:///./lib/component.js","webpack:///./lib/draw.js","webpack:///./lib/events.js","webpack:///./lib/touch.js","webpack:///./lib/intf.js","webpack:///./lib/contextMenu.js","webpack:///./lib/dom.js","webpack:///./lib/publicMethods.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","undefined","self","defaults","attributes","styles","apply","context","component","Grid","args","isComponent","isChildGrid","parentNode","test","nodeType","intf","eval","document","createElement","createGrid","forEach","shadowRoot","createShadowRoot","attachShadow","mode","debug","init","Array","slice","arguments","window","HTMLElement","create","customElements","observedAttributes","getObservableAttributes","disconnectedCallback","attributeChangedCallback","connectedCallback","adoptedCallback","canvasDatagrid","require","tKeys","body","style","width","height","keys","argKey","appendChild","indexOf","tKey","sKey","hyphenateProperty","prop","cust","char","toUpperCase","toLowerCase","getDefaultItem","base","item","filter","applyComponentStyle","supressChangeAndDrawEvents","cStyle","getComputedStyle","defs","computedStyle","def","val","getPropertyValue","setStyleProperty","typeMap","requestAnimationFrame","resize","dispatchEvent","data","strData","JSON","parse","e","Error","schema","strSchema","number","strNum","parseInt","isNaN","boolean","strBool","string","str","attrs","attr","push","connected","observe","attrName","oldVal","newVal","tfn","addEventListener","observer","MutationObserver","mutations","checkInnerHTML","checkStyle","mutation","attributeName","target","nodeName","addedNodes","length","type","innerHTML","characterData","childList","subtree","canvas","querySelectorAll","el","drawPerfLine","w","h","x","y","perfArr","arrIndex","max","color","useAbs","r","canvasOffsetLeft","canvasOffsetTop","ctx","beginPath","moveTo","cx","cy","Math","abs","lineTo","strokeStyle","stroke","drawOnAllImagesLoaded","loaded","htmlImageCache","html","complete","draw","drawHtml","cell","img","v","formattedValue","drawImage","Image","onload","src","btoa","drawOrderByArrow","mt","columnHeaderOrderByArrowMarginTop","scale","ml","columnHeaderOrderByArrowMarginLeft","mr","columnHeaderOrderByArrowMarginRight","aw","columnHeaderOrderByArrowWidth","ah","columnHeaderOrderByArrowHeight","fillStyle","columnHeaderOrderByArrowColor","columnHeaderOrderByArrowBorderColor","orderDirection","fill","drawTreeArrow","treeArrowMarginTop","treeArrowMarginRight","treeArrowMarginLeft","treeArrowWidth","treeArrowHeight","treeArrowColor","treeArrowBorderColor","openChildren","uniqueId","radiusRect","radius","b","quadraticCurveTo","fillRect","strokeRect","fillText","text","fillCircle","arc","PI","strokeCircle","clipFrozenArea","lastFrozenColumnPixel","lastFrozenRowPixel","clip","fillHandle","selectionHandleType","strokeHandle","addselectionHandle","pos","hw","selectionHandleSize","tr","br","tl","bl","addBorderLine","t","addEllipsis","ellipsisCache","measureText","value","drawText","paddingLeft","paddingTop","paddingRight","paddingBottom","vPos","hPos","orderByArrowWidth","fontHeight","horizontalAlignment","verticalAlignment","getFrozenColumnsWidth","column","getVisibleSchema","min","frozenColumn","orders","columns","sizes","cellWidth","perfCounters","drawCount","perfWindowSize","entityCount","scrollDebugCounters","touchPPSCounters","internal","createHandlesOverlayArray","allowMovingSelection","mobile","selectionBorderTop","selectionBorderRight","selectionHandles","selectionHandle","selectionBorderLeft","selectionBorderBottom","selectionHandleBehavior","createBorderOverlayArray","drawArray","propPrefix","offsetPoint","selectionBorder","isRowHeader","selections","rowIndex","columnIndex","isHeader","drawCell","rowOrderIndex","header","headerIndex","columnOrderIndex","cellGridAttributes","cellStyle","isCorner","isColumnHeader","selected","hovered","hovers","active","activeCell","isGrid","activeHeader","rows","f","formatters","orderByArrowSize","treeArrowSize","ev","row","cellBorderWidth","visibleRows","offsetTop","offsetLeft","scrollTop","scrollBox","scrollLeft","cellHeight","offsetWidth","offsetHeight","offsetParent","isHeaderCellCap","rowOpen","sortColumnIndex","sortRowIndex","isNormal","gridId","parentGrid","title","userHeight","rowHeight","userWidth","cornerCell","visibleCells","unshift","lineWidth","cellHeightWithChildGrid","checkScrollHeight","cellWidthWithChildGrid","rd","save","tree","showRowNumbers","childGrids","saveAppearance","cellGridHeight","grid","visible","orderBy","font","console","warn","toString","columnFilters","filterTextPrefix","aCell","selectionBorders","movingSelection","moveBorders","moveOffset","restore","bc","drawRowHeader","rowData","index","a","showRowHeaders","rowHeaderCell","rowHeaderCellWidth","drawRow","treeHeight","rowSansTreeHeight","g","trees","allowFreezingColumns","frozenColumnWidths","scrollIndexLeft","scrollIndexRight","scrollPixelRight","scrollPixelLeft","treeGrid","scrollBarWidth","rowHeaders","visibleRowHeights","gridBorderCollapse","u","currentCell","columnHeaderCellHeight","getColumnHeaderCellHeight","getRowHeaderCellWidth","performance","now","createRowOrders","gridBackgroundColor","ln","frozenRow","allowFreezingRows","frozenMarkerBorderWidth","frozenMarkerWidth","snapToRow","scrollPixelTop","scrollIndexTop","scrollIndexBottom","scrollPixelBottom","showNewRow","newRow","cl","selectionMode","activeCellOverlayBorderWidth","activeCellOverlayBorderColor","getHeaderWidth","drawHeaderColumnRange","start","end","order","columnHeaderCell","nonFrozenHeaderWidth","rArgs","rhIndex","showColumnHeaders","columnHeaderCellBorderWidth","isHeaderCell","endCap","my","mx","xHover","yHover","frozenMarkerHoverColor","frozenMarkerColor","frozenMarkerHoverBorderColor","frozenMarkerBorderColor","freezeMarkerPosition","frozenMarkerActiveColor","frozenMarkerActiveBorderColor","dragMode","dsb","selectionOverlayBorderWidth","selectionOverlayBorderColor","selectionHandleBorderWidth","selectionHandleBorderColor","selectionHandleColor","az","touchSelectHandleZone","ax","ay","reorderObject","dragOffset","reorderMarkerBackgroundColor","reorderMarkerBorderWidth","reorderMarkerBorderColor","reorderMarkerIndexBorderWidth","reorderMarkerIndexBorderColor","reorderTarget","moveOverlayBorderWidth","moveOverlayBorderColor","setLineDash","moveOverlayBorderSegments","vb","nb","co","isScrollBoxCorner","scrollBarBoxMargin","scrollBarBorderColor","scrollBarBorderWidth","scrollBarBackgroundColor","scrollBoxHeight","scrollHeight","scrollBarBoxWidth","scrollBarBoxColor","scrollBarActiveColor","scrollBarBoxBorderRadius","scrollBoxWidth","scrollWidth","scrollBarCornerBorderColor","scrollBarCornerBackgroundColor","bar","box","gridBorderWidth","gridBorderColor","showPerformance","fillArray","pop","perf","reduce","toFixed","htmlImages","startScale","scaleDelta","zoomDeltaStart","touchLength","touches","touchPosition","touchPosition1","scrollIndex","scrollPixel","canvasOffset","touchDelta","touchAnimateTo","scrollAnimation","touchPPS","xPPS","yPPS","touchPPST","xPPST","yPPST","touchDuration","pointerLockPosition","size","mouse","touch","touchStart","entities","hasFocus","dragContext","textAlign","key","dpl","pw","ph","px","py","wheeling","stopPropagation","fn","events","removeEventListener","sfn","idx","splice","preventDefault","defaultPrevented","getRatio","maxPixelRatio","devicePixelRatio","webkitBackingStorePixelRatio","mozBackingStorePixelRatio","msBackingStorePixelRatio","oBackingStorePixelRatio","backingStorePixelRatio","drawAfterResize","ratio","bm","cellBorder","columnHeaderCellBorder","ch","accumulator","hidden","top","left","widthBoxRatio","heightBoxRatio","scrollBarBoxMinSize","page","pageUpDownOverlap","resizeEditInput","scroll","dontDraw","mousemove","overridePos","contextMenu","input","getLayerPos","dragBounds","sBounds","delta","ctrl","ctrlKey","metaKey","persistantSelectionMode","vs","getCellAt","NativeEvent","previousCell","clearTimeout","scrollTimer","isInGrid","rowBoundaryCrossed","columnBoundaryCrossed","cellBoundaryCrossed","prefix","draggingItem","scrollModes","dragItem","cursor","selecting","getSelectionBounds","dragStart","dragStartObject","shiftKey","bottom","right","ignoreNextClick","dragAddToSelection","selectRow","selectionBounds","selectArea","autoScrollZone","click","checkSelectionChange","selectedData","getSelectedData","endEdit","setActiveCell","selectAll","columnHeaderClickBehavior","selectColumn","treeArrowClickRadius","toggleTree","dragResizeColumn","resizingStartingWidth","resizingStartingHeight","minColumnWidth","minRowHeight","resizeScrollZone","resizeChildGrids","globalRowResize","stopDragResize","setStorageData","scrollGrid","scrollPointerLock","scrollStartMode","movementX","movementY","scrollMode","scrollStart","setTimeout","scrollRepeatRate","selectionScrollIncrement","stopScrollGrid","exitPointerLock","dragReorder","allowColumnReordering","allowRowReordering","source","reorderDeadZone","stopDragReorder","oIndex","tIndex","cr","row-reorder","column-reorder","dragMove","stopDragMove","moveSelection","freezeMove","stopFreezeMove","startFreezeMove","mousedown","lastMouseDownTarget","button","move","freeze","requestPointerLock","concat","dragging","mouseup","controlInput","focus","keydown","last","cols","keyCode","beginEditAt","scrollIntoView","selectionFollowsActiveCell","keyup","keypress","dblclick","fitColumnToValues","autosize","scrollWheel","deltaX","deltaY","deltaMode","touchHaltAnimation","scrollTo","pasteItem","clipData","mimeType","normalizeRowData","importingRow","existingRow","offsetX","isArray","map","colKey","substring","split","sel","cellData","colIndex","cName","yi","paste","clipboardData","items","dti","getAsString","cut","copy","forEachSelectedCell","colName","fCopyCell","replace","trows","sData","rt","join","setData","touchScrollTimeout","animationFrames","getTouchPos","touchIndex","rect","getBoundingClientRect","clientX","clientY","easingFunctions","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easing","touchEasingMethod","calculatePPSTimed","touchSigmaTimed","calculatePPS","touchSigma","touchEndAnimation","touchReleaseAnimationDurationMs","stopAnimation","touchEditCell","touchCell","clearInterval","calculatePPSTimer","touchDeadZone","touchingCell","editCell","touchstart","changedTouches","startingCell","disposeContextMenu","touchContextTimeout","touchStartEvent","zoomAltered","touchStart1","touchScrollStart","contextmenuEvent","touchContextMenuTimeMs","setInterval","touchEndEvents","touchmove","passive","touchend","touchcancel","touchSelect","handleType","touchSelecting","bounds","getSchema","touchScroll","rScrollZone","bScrollZone","tScrollZone","lScrollZone","rw","sbw","t1","t2","touchZoomSensitivity","touchZoomMin","touchZoomMax","selectionScrollZone","dz","touchReleaseAcceleration","scrollAnimationPPSThreshold","ctor","storageName","invalidSearchExpClass","localStyleLibraryStorageKey","filters","currentFilter","sorters","schemaHashes","uId","changes","componentL1Events","eventNames","expandToRow","col","low","high","step","visibility","localStorage","setItem","stringify","tempSchema","createColumnOrders","applyDefaultValue","defaultValue","createNewRowData","getSchemaNameHash","getBestGuessDataType","columnName","drawChildGrids","gridKey","setTimer","refreshFromOrigialData","originalData","validateColumn","setDefaults","obj1","obj2","setAttributes","setStyle","dispose","removeChild","eventParent","contextmenu","disconnect","tryLoadStoredOrders","storedSettings","getHeaderByName","getDomRoot","host","getFontName","fontStyle","getFontHeight","parseFloat","parseStyleValue","initProp","propName","getStyleProperty","styleKeys","parentNodeStyle","supressDrawAndEvent","reloadStoredValues","getItem","initialized","publicStyleKeyIntf","initScrollBox","setDom","ie","navigator","userAgent","edge","webKit","moz","cursorGrab","cursorGrabing","cursorGrabbing","appendTo","clearChangeLog","gotoCell","gotoRow","findColumnScrollLeft","findRowScrollTop","findColumnMaxTextLength","isCellVisible","clipElement","getSchemaFromData","setFilter","expandTree","collapseTree","insertRow","deleteRow","addRow","insertColumn","deleteColumn","addColumn","getClippingRect","setRowHeight","setColumnWidth","resetColumnWidths","resetRowHeights","selectNone","assertPxColor","clearPxColorAssertions","integerToAlpha","DOMStyles","set","valueObject","filterFor","String","filterRegExp","regEnd","pattern","exec","flags","flagLength","invalidFilterRegEx","RegExp","toLocaleUpperCase","blur","TypeError","currentCursor","normalizeDataset","callback","syncFnInvoked","0","eventName","RangeError","autoResizeColumns","setScrollTop","preventScrollEvent","setScrollLeft","sHeight","sWidth","supressDrawEvent","applyContextItemStyle","contextItemContainer","createInlineStyle","createContextMenu","parentContextMenu","createItems","removeChildContext","relatedTarget","container","childMenuArrow","contains","children","setAttribute","contextAddCallback","getAttribute","cPos","childContextMenuMarginLeft","childContextMenuMarginTop","createChildContext","addContent","content","childContextMenuArrowHTML","clickIndex","Event","checkArrowVisibility","parentDOMNode","upArrow","downArrow","startHoverScroll","contextHoverScrollAmount","hoverScrollTimeout","contextHoverScrollRateMs","endHoverScroll","selectedIndex","loc","scrollOffset","zIndexTop","contextMenuZIndex","position","contextMenuArrowColor","zIndex","inputDropdown","maxHeight","innerHeight","autocompleteBottomMargin","minWidth","contextMenuArrowUpHTML","contextMenuArrowDownHTML","contextMenuWindowMargin","innerWidth","isFinite","createFilterContextMenuItems","checkRegExpErrorState","filterInput","background","contextFilterInputBackground","contextFilterInputColor","contextFilterInvalidRegExpBackground","contextFilterInvalidRegExpColor","fillAutoComplete","count","autoCompleteItems","maxAutoCompleteItems","disposeAutocomplete","createAutoCompleteContext","iRect","autoCompleteContext","filterContainer","filterLabel","filterAutoCompleteButton","onclick","en","filterOptionText","contextFilterButtonHTML","cf","removeFilterOptionText","addDefaultContextMenuItem","isNormalCell","isBackground","isScrollBar","showFilter","showCopy","copyText","execCommand","showPaste","clipBoardData","pasteText","showColumnSelector","columnSelectorText","toggleColumnVisibility","columnSelectorHiddenText","columnSelectorVisibleText","hideColumnText","showClearSettingsOption","clearSettingsOptionText","columnWidth","allowSorting","showOrderByOption","showOrderByOptionTextAsc","showOrderByOptionTextDesc","createDiposeEvent","contextPosition","contextMenuMarginLeft","contextMenuMarginTop","mobileContextMenuMargin","ele","boundingRect","eleRect","clipRect","parentRect","Infinity","scrollingElement","borderWidth","getVisibleCellByIndex","mobileEditInputHeight","cellPaddingLeft","ignoreScrollOffset","abort","abortEdit","newValue","oldValue","aborted","editable","enumItems","enu","option","valueInEnum","multiLine","editCellZIndex","fontSize","editCellFontSize","nx","ny","className","css","canvas-datagrid-context-menu-filter-input","verticalAlign","marginLeft","padding","border","contextFilterInputBorder","borderRadius","contextFilterInputBorderRadius","lineHeight","fontWeight","fontFamily","contextFilterInputFontFamily","contextFilterInputFontSize","canvas-datagrid-context-menu-filter-button","contextMenuBackground","contextMenuColor","contextFilterButtonBorder","contextFilterButtonBorderRadius","contextMenuFilterButtonFontFamily","contextMenuFilterButtonFontSize","canvas-datagrid-context-child-arrow","cssFloat","childContextMenuArrowColor","contextMenuChildArrowFontSize","contextMenuFontFamily","canvas-datagrid-autocomplete","contextMenuFontSize","contextMenuBorder","contextMenuPadding","contextMenuBorderRadius","opacity","contextMenuOpacity","overflow","canvas-datagrid-autocomplete-item","canvas-datagrid-autocomplete-item:hover","contextMenuHoverBackground","contextMenuHoverColor","canvas-datagrid-canvas","canvas-datagrid","display","canvas-datagrid-control-input","canvas-datagrid-edit-mobile-input","boxSizing","outline","margin","mobileEditFontFamily","mobileEditFontSize","editCellBorder","editCellColor","editCellBackgroundColor","appearance","webkitAppearance","mozAppearance","canvas-datagrid-edit-input","editCellPaddingLeft","editCellFontFamily","boxShadow","editCellBoxShadow","canvas-datagrid-context-menu-item-mobile","contextMenuItemMargin","contextMenuItemBorderRadius","canvas-datagrid-context-menu-item","canvas-datagrid-context-menu-item:hover","canvas-datagrid-context-menu-label","contextMenuLabelMargin","contextMenuLabelDisplay","contextMenuLabelMinWidth","maxWidth","contextMenuLabelMaxWidth","canvas-datagrid-context-menu-mobile","whiteSpace","canvas-datagrid-context-menu","canvas-datagrid-invalid-search-regExp","contextMenuFilterInvalidExpresion","onblur","parentIsCanvas","tagName","getContext","textBaseline","ordA","charCodeAt","ordZ","len","fromCharCode","floor","applyFilter","isColumnSelected","colIsSelected","shift","supressEvent","addCol","ri","st","dragObject","rowId","childGrid","trArgs","treeGridAttributes","treeGridHeight","direction","sortFunction","dontSetStorageData","sort","offsetY","xi","cidx","isColumnVisible","isRowVisible","useTouchScrollZones","moveBorder","tsz","touchScrollZone","moveMode","borderDragBehavior","xBorderBehavior","yBorderBehavior","isVerticalScrollBar","isHorizontalScrollBar","borderResizeZone","allowColumnResize","allowColumnResizeFromCell","allowRowHeaderResize","allowRowResize","allowRowResizeFromCell","rowGrabZoneSize","maxCol","minCol"," ","rowHeaderCellFont","autosizePadding","autosizeHeaderCellPadding","rowHeaderCellPaddingRight","rowHeaderCellPaddingLeft","columnHeaderCellFont","headerCellPaddingRight","headerCellPaddingLeft","cellFont","cellPaddingRight","cellAutoResizePadding","total","headerCell","int","asc","localeCompare","date","Date","getTime"],"mappings":"CAAA,SAAAA,EAAAC,GACA,gBAAAC,UAAA,gBAAAC,QACAA,OAAAD,QAAAD,IACA,kBAAAG,gBAAAC,IACAD,UAAAH,GACA,gBAAAC,SACAA,QAAA,eAAAD,IAEAD,EAAA,eAAAC,KACCK,KAAA,WACD,MCAgB,UAAUC,GCN1B,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAP,OAGA,IAAAC,GAAAO,EAAAD,IACAE,EAAAF,EACAG,GAAA,EACAV,WAUA,OANAK,GAAAE,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAS,GAAA,EAGAT,EAAAD,QAvBA,GAAAQ,KA4DA,OAhCAF,GAAAM,EAAAP,EAGAC,EAAAO,EAAAL,EAGAF,EAAAQ,EAAA,SAAAd,EAAAe,EAAAC,GACAV,EAAAW,EAAAjB,EAAAe,IACAG,OAAAC,eAAAnB,EAAAe,GACAK,cAAA,EACAC,YAAA,EACAC,IAAAN,KAMAV,EAAAiB,EAAA,SAAAtB,GACA,GAAAe,GAAAf,KAAAuB,WACA,WAA2B,MAAAvB,GAAA,SAC3B,WAAiC,MAAAA,GAEjC,OADAK,GAAAQ,EAAAE,EAAA,IAAAA,GACAA,GAIAV,EAAAW,EAAA,SAAAQ,EAAAC,GAAsD,MAAAR,QAAAS,UAAAC,eAAAjB,KAAAc,EAAAC,IAGtDpB,EAAAuB,EAAA,GAGAvB,IAAAwB,EAAA,KDgBM,SAAU7B,EAAQD,EAASM,GE7EjC,GAAAyB,GAAAC,CAEAD,UAkRCE,MAlRDD,EAAA,WACA,YACA,iBAAAE,GACAA,EAAAC,UACAC,aACA,6BACA,yBACA,iCACA,yBACA,4BACA,4BACA,4BACA,0BACA,sBACA,8BACA,oBACA,yBACA,8BACA,wBACA,mDACA,qCACA,kDACA,4CACA,kCACA,+BACA,+BACA,oBACA,aACA,gBACA,iCACA,mCACA,uBACA,6BACA,6BACA,iBACA,YACA,wBACA,sBACA,+BACA,iDACA,sBACA,wBACA,sBACA,sBACA,oCACA,yBACA,wBACA,kCACA,mCACA,yBACA,gCACA,2BACA,+BACA,yBACA,0BACA,gBACA,kBACA,kBACA,yBACA,qDACA,uDACA,iBACA,uBACA,sBACA,sBACA,iBACA,+BACA,oBACA,oCACA,iCACA,wCACA,uBACA,6BACA,8BACA,oBACA,sBACA,oBACA,YACA,4BAEAC,SACA,uDACA,mDACA,4BACA,uCACA,qCACA,4DACA,4CACA,yDACA,mCACA,8BACA,4BACA,6BACA,2BACA,+DACA,+CACA,mEACA,mDACA,gEACA,gDACA,gCACA,gCACA,sBACA,6BACA,iDACA,6CACA,sBACA,iCACA,+BACA,uBACA,kBACA,gCACA,mCACA,sDACA,sCACA,wBACA,sBACA,uBACA,qBACA,yDACA,yCACA,mCACA,kBACA,+BACA,qDACA,yCACA,mCACA,iCACA,6DACA,yDACA,kCACA,gDACA,2CACA,8BACA,+CACA,kEACA,kDACA,oCACA,kCACA,mCACA,iCACA,+CACA,iEACA,0CACA,2DACA,qCACA,yCACA,0CACA,wCACA,qCACA,iEACA,0CACA,uCACA,uDACA,gEACA,uCACA,4CACA,8CACA,sCACA,8DACA,6DACA,gDACA,wCACA,sCACA,mDACA,yDACA,kCACA,yCACA,2CACA,mDACA,2CACA,+DACA,uCACA,+BACA,wDACA,iDACA,sCACA,gCACA,2CACA,uCACA,qCACA,oCACA,4BACA,4BACA,8BACA,6BACA,gCACA,0BACA,uDACA,mDACA,oCACA,sDACA,kDACA,0BACA,oCACA,4BACA,0BACA,uBACA,oDACA,0DACA,qDACA,2DACA,+CACA,qDACA,8BACA,wBACA,iDACA,kCACA,6CACA,sBACA,sBACA,oBACA,+BACA,6BACA,sCACA,8BACA,6BACA,mDACA,sCACA,mBACA,sDACA,kDACA,kCACA,0DACA,uCACA,0DACA,sDACA,+BACA,6CACA,wCACA,2BACA,4CACA,+DACA,+CACA,iCACA,+BACA,gCACA,8BACA,kEACA,qDACA,4CACA,0BACA,kDACA,sDACA,kDACA,4BACA,mCACA,+CACA,yBACA,2BACA,wBACA,4DACA,wDACA,sBACA,wDACA,mCACA,iDACA,0BACA,iCACA,wDA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","file":"canvas-datagrid.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"canvasDatagrid\"] = factory();\n\telse\n\t\troot[\"canvasDatagrid\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"canvasDatagrid\"] = factory();\n\telse\n\t\troot[\"canvasDatagrid\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 1);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        self.defaults = {\n            attributes: [\n                ['allowColumnReordering', true],\n                ['allowColumnResize', true],\n                ['allowColumnResizeFromCell', false],\n                ['allowFreezingRows', false],\n                ['allowFreezingColumns', false],\n                ['allowMovingSelection', true],\n                ['allowRowHeaderResize', true],\n                ['allowRowReordering', false],\n                ['allowRowResize', true],\n                ['allowRowResizeFromCell', false],\n                ['allowSorting', true],\n                ['autoResizeColumns', false],\n                ['borderDragBehavior', 'none'],\n                ['borderResizeZone', 10],\n                ['clearSettingsOptionText', 'Clear saved settings'],\n                ['columnHeaderClickBehavior', 'sort'],\n                ['columnSelectorHiddenText', '&nbsp;&nbsp;&nbsp;'],\n                ['columnSelectorText', 'Add/Remove columns'],\n                ['columnSelectorVisibleText', '\\u2713'],\n                ['contextHoverScrollAmount', 2],\n                ['contextHoverScrollRateMs', 5],\n                ['copyText', 'Copy'],\n                ['debug', false],\n                ['editable', true],\n                ['filterOptionText', 'Filter %s'],\n                ['filterTextPrefix', '(filtered) '],\n                ['globalRowResize', false],\n                ['hideColumnText', 'Hide %s'],\n                ['maxAutoCompleteItems', 200],\n                ['multiLine', false],\n                ['name', ''],\n                ['pageUpDownOverlap', 1],\n                ['pasteText', 'Paste'],\n                ['persistantSelectionMode', false],\n                ['removeFilterOptionText', 'Remove filter on %s'],\n                ['reorderDeadZone', 3],\n                ['resizeScrollZone', 20],\n                ['rowGrabZoneSize', 5],\n                ['saveAppearance', true],\n                ['scrollAnimationPPSThreshold', 0.75],\n                ['scrollPointerLock', false],\n                ['scrollRepeatRate', 75],\n                ['selectionFollowsActiveCell', false],\n                ['selectionHandleBehavior', 'none'],\n                ['selectionMode', 'cell'],\n                ['selectionScrollIncrement', 20],\n                ['selectionScrollZone', 20],\n                ['showClearSettingsOption', true],\n                ['showColumnHeaders', true],\n                ['showColumnSelector', true],\n                ['showCopy', true],\n                ['showFilter', true],\n                ['showNewRow', false],\n                ['showOrderByOption', true],\n                ['showOrderByOptionTextAsc', 'Order by %s ascending'],\n                ['showOrderByOptionTextDesc', 'Order by %s descending'],\n                ['showPaste', false],\n                ['showPerformance', false],\n                ['showRowHeaders', true],\n                ['showRowNumbers', true],\n                ['snapToRow', false],\n                ['touchContextMenuTimeMs', 800],\n                ['touchDeadZone', 3],\n                ['touchEasingMethod', 'easeOutQuad'],\n                ['touchReleaseAcceleration', 1000],\n                ['touchReleaseAnimationDurationMs', 2000],\n                ['touchScrollZone', 20],\n                ['touchSelectHandleZone', 20],\n                ['touchZoomSensitivity', 0.005],\n                ['touchZoomMin', 0.5],\n                ['touchZoomMax', 1.75],\n                ['maxPixelRatio', 1],\n                ['tree', false],\n                ['treeHorizontalScroll', false]\n            ],\n            styles: [\n                ['activeCellBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['activeCellBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['activeCellBorderWidth', 1],\n                ['activeCellColor', 'rgba(0, 0, 0, 1)'],\n                ['activeCellFont', '16px sans-serif'],\n                ['activeCellHoverBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['activeCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['activeCellOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['activeCellOverlayBorderWidth', 1],\n                ['activeCellPaddingBottom', 5],\n                ['activeCellPaddingLeft', 5],\n                ['activeCellPaddingRight', 7],\n                ['activeCellPaddingTop', 5],\n                ['activeCellSelectedBackgroundColor', 'rgba(236, 243, 255, 1)'],\n                ['activeCellSelectedColor', 'rgba(0, 0, 0, 1)'],\n                ['activeColumnHeaderCellBackgroundColor', 'rgba(225, 225, 225, 1)'],\n                ['activeColumnHeaderCellColor', 'rgba(0, 0, 0, 1)'],\n                ['activeRowHeaderCellBackgroundColor', 'rgba(225, 225, 225, 1)'],\n                ['activeRowHeaderCellColor', 'rgba(0, 0, 0, 1)'],\n                ['autocompleteBottomMargin', 60],\n                ['autosizeHeaderCellPadding', 8],\n                ['autosizePadding', 5],\n                ['cellAutoResizePadding', 13],\n                ['cellBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['cellBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['cellBorderWidth', 1],\n                ['cellColor', 'rgba(0, 0, 0, 1)'],\n                ['cellFont', '16px sans-serif'],\n                ['cellGridHeight', 250],\n                ['cellHeight', 24],\n                ['cellHeightWithChildGrid', 150],\n                ['cellHorizontalAlignment', 'left'],\n                ['cellHoverBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['cellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['cellPaddingBottom', 5],\n                ['cellPaddingLeft', 5],\n                ['cellPaddingRight', 7],\n                ['cellPaddingTop', 5],\n                ['cellSelectedBackgroundColor', 'rgba(236, 243, 255, 1)'],\n                ['cellSelectedColor', 'rgba(0, 0, 0, 1)'],\n                ['cellVerticalAlignment', 'center'],\n                ['cellWidth', 250],\n                ['cellWidthWithChildGrid', 250],\n                ['childContextMenuArrowColor', 'rgba(43, 48, 43, 1)'],\n                ['childContextMenuArrowHTML', '&#x25BA;'],\n                ['childContextMenuMarginLeft', -11],\n                ['childContextMenuMarginTop', -6],\n                ['columnHeaderCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['columnHeaderCellBorderColor', 'rgba(172, 172, 172, 1)'],\n                ['columnHeaderCellBorderWidth', 1],\n                ['columnHeaderCellColor', 'rgba(50, 50, 50, 1)'],\n                ['columnHeaderCellFont', '16px sans-serif'],\n                ['columnHeaderCellHeight', 25],\n                ['columnHeaderCellHorizontalAlignment', 'left'],\n                ['columnHeaderCellHoverBackgroundColor', 'rgba(235, 235, 235, 1)'],\n                ['columnHeaderCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['columnHeaderCellPaddingBottom', 5],\n                ['columnHeaderCellPaddingLeft', 5],\n                ['columnHeaderCellPaddingRight', 7],\n                ['columnHeaderCellPaddingTop', 5],\n                ['columnHeaderCellVerticalAlignment', 'center'],\n                ['columnHeaderOrderByArrowBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['columnHeaderOrderByArrowBorderWidth', 1],\n                ['columnHeaderOrderByArrowColor', 'rgba(155, 155, 155, 1)'],\n                ['columnHeaderOrderByArrowHeight', 8],\n                ['columnHeaderOrderByArrowMarginLeft', 0],\n                ['columnHeaderOrderByArrowMarginRight', 5],\n                ['columnHeaderOrderByArrowMarginTop', 6],\n                ['columnHeaderOrderByArrowWidth', 13],\n                ['contextFilterButtonBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextFilterButtonBorderRadius', '3px'],\n                ['contextFilterButtonHTML', '&#x25BC;'],\n                ['contextFilterInputBackground', 'rgba(255,255,255,1)'],\n                ['contextFilterInputBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextFilterInputBorderRadius', '0'],\n                ['contextFilterInputColor', 'rgba(0,0,0,1)'],\n                ['contextFilterInputFontFamily', 'sans-serif'],\n                ['contextFilterInputFontSize', '14px'],\n                ['contextFilterInvalidRegExpBackground', 'rgba(180, 6, 1, 1)'],\n                ['contextFilterInvalidRegExpColor', 'rgba(255, 255, 255, 1)'],\n                ['contextMenuArrowColor', 'rgba(43, 48, 43, 1)'],\n                ['contextMenuArrowDownHTML', '&#x25BC;'],\n                ['contextMenuArrowUpHTML', '&#x25B2;'],\n                ['contextMenuBackground', 'rgba(240, 240, 240, 1)'],\n                ['contextMenuBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextMenuBorderRadius', '3px'],\n                ['contextMenuChildArrowFontSize', '12px'],\n                ['contextMenuColor', 'rgba(43, 48, 43, 1)'],\n                ['contextMenuFilterButtonFontFamily', 'sans-serif'],\n                ['contextMenuFilterButtonFontSize', '10px'],\n                ['contextMenuFilterInvalidExpresion', 'rgba(237, 155, 156, 1)'],\n                ['contextMenuFontFamily', 'sans-serif'],\n                ['contextMenuFontSize', '16px'],\n                ['contextMenuHoverBackground', 'rgba(182, 205, 250, 1)'],\n                ['contextMenuHoverColor', 'rgba(43, 48, 153, 1)'],\n                ['contextMenuItemBorderRadius', '3px'],\n                ['contextMenuItemMargin', '2px'],\n                ['contextMenuLabelDisplay', 'inline-block'],\n                ['contextMenuLabelMargin', '0 3px 0 0'],\n                ['contextMenuLabelMaxWidth', '700px'],\n                ['contextMenuLabelMinWidth', '75px'],\n                ['contextMenuMarginLeft', 3],\n                ['contextMenuMarginTop', -3],\n                ['contextMenuOpacity', '0.98'],\n                ['contextMenuPadding', '2px'],\n                ['contextMenuWindowMargin', 100],\n                ['contextMenuZIndex', 10000],\n                ['cornerCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['cornerCellBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['editCellBackgroundColor', 'white'],\n                ['editCellBorder', 'solid 1px rgba(110, 168, 255, 1)'],\n                ['editCellBoxShadow', '0 2px 5px rgba(0,0,0,0.4)'],\n                ['editCellColor', 'black'],\n                ['editCellFontFamily', 'sans-serif'],\n                ['editCellFontSize', '16px'],\n                ['editCellPaddingLeft', 4],\n                ['editCellZIndex', 10000],\n                ['frozenMarkerHoverColor', 'rgba(236, 243, 255, 1)'],\n                ['frozenMarkerHoverBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['frozenMarkerActiveColor', 'rgba(236, 243, 255, 1)'],\n                ['frozenMarkerActiveBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['frozenMarkerColor', 'rgba(222, 222, 222, 1)'],\n                ['frozenMarkerBorderColor', 'rgba(168, 168, 168, 1)'],\n                ['frozenMarkerBorderWidth', 1],\n                ['frozenMarkerWidth', 2],\n                ['gridBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['gridBorderCollapse', 'collapse'],\n                ['gridBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['gridBorderWidth', 1],\n                ['minColumnWidth', 45],\n                ['minRowHeight', 24],\n                ['mobileContextMenuMargin', 10],\n                ['mobileEditInputHeight', 30],\n                ['mobileEditFontFamily', 'sans-serif'],\n                ['mobileEditFontSize', '16px'],\n                ['moveOverlayBorderWidth', 1],\n                ['moveOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['moveOverlayBorderSegments', '12, 7'],\n                ['name', 'default'],\n                ['reorderMarkerBackgroundColor', 'rgba(0, 0, 0, 0.1)'],\n                ['reorderMarkerBorderColor', 'rgba(0, 0, 0, 0.2)'],\n                ['reorderMarkerBorderWidth', 1.25],\n                ['reorderMarkerIndexBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['reorderMarkerIndexBorderWidth', 2.75],\n                ['rowHeaderCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['rowHeaderCellBorderColor', 'rgba(200, 200, 200, 1)'],\n                ['rowHeaderCellBorderWidth', 1],\n                ['rowHeaderCellColor', 'rgba(50, 50, 50, 1)'],\n                ['rowHeaderCellFont', '16px sans-serif'],\n                ['rowHeaderCellHeight', 25],\n                ['rowHeaderCellHorizontalAlignment', 'left'],\n                ['rowHeaderCellHoverBackgroundColor', 'rgba(235, 235, 235, 1)'],\n                ['rowHeaderCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['rowHeaderCellPaddingBottom', 5],\n                ['rowHeaderCellPaddingLeft', 5],\n                ['rowHeaderCellPaddingRight', 5],\n                ['rowHeaderCellPaddingTop', 5],\n                ['rowHeaderCellSelectedBackgroundColor', 'rgba(217, 217, 217, 1)'],\n                ['rowHeaderCellSelectedColor', 'rgba(50, 50, 50, 1)'],\n                ['rowHeaderCellVerticalAlignment', 'center'],\n                ['rowHeaderCellWidth', 57],\n                ['scrollBarActiveColor', 'rgba(125, 125, 125, 1)'],\n                ['scrollBarBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['scrollBarBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['scrollBarBorderWidth', 0.5],\n                ['scrollBarBoxBorderRadius', 4.125],\n                ['scrollBarBoxColor', 'rgba(192, 192, 192, 1)'],\n                ['scrollBarBoxMargin', 2],\n                ['scrollBarBoxMinSize', 15],\n                ['scrollBarBoxWidth', 8],\n                ['scrollBarCornerBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['scrollBarCornerBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['scrollBarWidth', 11],\n                ['selectionHandleBorderColor', 'rgba(255, 255, 255, 1)'],\n                ['selectionHandleBorderWidth', 1.5],\n                ['selectionHandleColor', 'rgba(66, 133, 244, 1)'],\n                ['selectionHandleSize', 8],\n                ['selectionHandleType', 'square'],\n                ['selectionOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['selectionOverlayBorderWidth', 1],\n                ['treeArrowBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['treeArrowBorderWidth', 1],\n                ['treeArrowClickRadius', 5],\n                ['treeArrowColor', 'rgba(155, 155, 155, 1)'],\n                ['treeArrowHeight', 8],\n                ['treeArrowMarginLeft', 0],\n                ['treeArrowMarginRight', 5],\n                ['treeArrowMarginTop', 6],\n                ['treeArrowWidth', 13],\n                ['treeGridHeight', 250]\n            ]\n        };\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true, evil: true*/\n/*globals Reflect: false, HTMLElement: true, define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [\n    __webpack_require__(2),\n    __webpack_require__(0),\n    __webpack_require__(3),\n    __webpack_require__(4),\n    __webpack_require__(5),\n    __webpack_require__(6),\n    __webpack_require__(7),\n    __webpack_require__(8),\n    __webpack_require__(9)\n], __WEBPACK_AMD_DEFINE_RESULT__ = function context(component) {\n    'use strict';\n    component = component();\n    var modules = Array.prototype.slice.call(arguments);\n    function Grid(args) {\n        args = args || {};\n        var self = {};\n        self.isComponent = args.component === undefined;\n        self.isChildGrid = args.parentNode && /canvas-datagrid-(cell|tree)/.test(args.parentNode.nodeType);\n        if (self.isChildGrid) {\n            self.intf = {};\n        } else {\n            self.intf = self.isComponent ? eval('Reflect.construct(HTMLElement, [], new.target)')\n                : document.createElement('section');\n        }\n        self.args = args;\n        self.createGrid = function grid(args) {\n            args.component = false;\n            return new Grid(args);\n        };\n        modules.forEach(function (module) {\n            module(self);\n        });\n        if (self.isChildGrid) {\n            self.shadowRoot = args.parentNode.shadowRoot;\n            self.parentNode = args.parentNode;\n        } else if (self.intf.createShadowRoot) {\n            self.shadowRoot = self.intf.attachShadow({mode: self.args.debug ? 'open' : 'closed'});\n            self.parentNode = self.shadowRoot;\n        } else {\n            self.parentNode = self.intf;\n        }\n        self.init();\n        return self.intf;\n    }\n    if (window.HTMLElement) {\n        Grid.prototype = Object.create(window.HTMLElement.prototype);\n    }\n    // export web component\n    if (window.customElements) {\n        Grid.observedAttributes = component.getObservableAttributes();\n        Grid.prototype.disconnectedCallback = component.disconnectedCallback;\n        Grid.prototype.attributeChangedCallback = component.attributeChangedCallback;\n        Grid.prototype.connectedCallback = component.connectedCallback;\n        Grid.prototype.adoptedCallback = component.adoptedCallback;\n        window.customElements.define('canvas-datagrid', Grid);\n    }\n    // export global\n    if (window && !window.canvasDatagrid && !window.require) {\n        window.canvasDatagrid = function (args) { return new Grid(args); };\n    }\n    // export amd loader\n    module.exports = function grid(args) {\n        args = args || {};\n        var i, tKeys = ['style', 'schema', 'data', 'formatters',\n                    'sorters', 'filters'];\n        if (window.customElements && document.body.createShadowRoot) {\n            i = document.createElement('canvas-datagrid');\n            // create \"block\" element effect\n            i.style.width = '100%';\n            i.style.height = '100%';\n            Object.keys(args).forEach(function (argKey) {\n                if (argKey === 'parentNode') {\n                    args.parentNode.appendChild(i);\n                    return;\n                }\n                // top level keys in args\n                if (tKeys.indexOf(argKey) !== -1) {\n                    tKeys.forEach(function (tKey) {\n                        if (args[tKey] === undefined || tKey !== argKey) { return; }\n                        if (['formatters', 'sorters', 'filters'].indexOf(argKey) !== -1) {\n                            if (typeof args[tKey] === 'object' && args[tKey] !== null) {\n                                Object.keys(args[tKey]).forEach(function (sKey) {\n                                    i[tKey][sKey] = args[tKey][sKey];\n                                });\n                            }\n                        } else {\n                            i[tKey] = args[tKey];\n                        }\n                    });\n                    return;\n                }\n                // all others are attribute level keys\n                i.attributes[argKey] = args[argKey];\n            });\n            return i;\n        }\n        args.component = false;\n        i = new Grid(args);\n        if (args.parentNode && args.parentNode.appendChild) {\n            args.parentNode.appendChild(i);\n        }\n        // create \"block\" element effect\n        i.style.width = '100%';\n        i.style.height = '100%';\n        return i;\n    };\n    return module.exports;\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_RESULT__ = function (defaults) {\n    'use strict';\n    return function () {\n        var typeMap, component = {};\n        function hyphenateProperty(prop, cust) {\n            var p = '';\n            Array.prototype.forEach.call(prop, function (char) {\n                if (char === char.toUpperCase()) {\n                    p += '-' + char.toLowerCase();\n                    return;\n                }\n                p += char;\n            });\n            return (cust ? '--cdg-' : '') + p;\n        }\n        function getDefaultItem(base, item) {\n            var i = {},\n                r;\n            defaults(i);\n            r = i.defaults[base].filter(function (i) {\n                return i[0].toLowerCase() === item.toLowerCase()\n                    || hyphenateProperty(i[0]) === item.toLowerCase()\n                    || hyphenateProperty(i[0], true) === item.toLowerCase();\n            })[0];\n            return r;\n        }\n        function applyComponentStyle(supressChangeAndDrawEvents, intf) {\n            var cStyle = window.getComputedStyle(intf, null),\n                defs = {};\n            intf.computedStyle = cStyle;\n            defaults(defs);\n            defs = defs.defaults.styles;\n            defs.forEach(function (def) {\n                var val = cStyle.getPropertyValue(hyphenateProperty(def[0], true));\n                if (val === \"\") {\n                    val = cStyle.getPropertyValue(hyphenateProperty(def[0], false));\n                }\n                if (val !== \"\") {\n                    intf.setStyleProperty(def[0], typeMap[typeof def[1]](val, def[1]));\n                }\n            });\n            requestAnimationFrame(function () { intf.resize(true); });\n            if (!supressChangeAndDrawEvents && intf.dispatchEvent) {\n                intf.dispatchEvent('stylechanged', intf.style);\n            }\n        }\n        typeMap = {\n            data: function (strData) {\n                try {\n                    return JSON.parse(strData);\n                } catch (e) {\n                    throw new Error('Cannot read JSON data in canvas-datagrid data.');\n                }\n            },\n            schema: function (strSchema) {\n                try {\n                    return JSON.parse(strSchema);\n                } catch (e) {\n                    throw new Error('Cannot read JSON data in canvas-datagrid schema attribute.');\n                }\n            },\n            number: function (strNum, def) {\n                var n = parseInt(strNum, 10);\n                return isNaN(n) ? def : n;\n            },\n            boolean: function (strBool) {\n                return (/true/i).test(strBool);\n            },\n            string: function (str) {\n                return str;\n            }\n        };\n        component.getObservableAttributes = function () {\n            var i = {}, attrs = ['data', 'schema', 'style', 'className', 'name'];\n            defaults(i);\n            i.defaults.attributes.forEach(function (attr) {\n                attrs.push(attr[0].toLowerCase());\n            });\n            return attrs;\n        };\n        component.disconnectedCallback = function () {\n            this.connected = false;\n        };\n        component.connectedCallback = function () {\n            var intf = this;\n            intf.connected = true;\n            component.observe(intf);\n            applyComponentStyle(true, intf);\n            intf.resize(true);\n        };\n        component.adoptedCallback = function () {\n            this.resize();\n        };\n        component.attributeChangedCallback = function (attrName, oldVal, newVal) {\n            var tfn, intf = this, def;\n            if (attrName === 'style') {\n                requestAnimationFrame(function () { applyComponentStyle(false, intf); });\n                return;\n            }\n            if (attrName === 'data') {\n                intf.args.data = typeMap.data(newVal);\n                return;\n            }\n            if (attrName === 'schema') {\n                intf.args.schema = typeMap.schema(newVal);\n                return;\n            }\n            if (attrName === 'name') {\n                intf.name = newVal;\n                return;\n            }\n            if (attrName === 'class' || attrName === 'className') {\n                return;\n            }\n            def = getDefaultItem('attributes', attrName);\n            if (def) {\n                tfn = typeMap[typeof def[1]];\n                intf.attributes[def[0]] = tfn(newVal);\n                return;\n            }\n            if (/^on/.test(attrName)) {\n                intf.addEventListener('on' + attrName, function (e) {\n                    eval(newVal);\n                });\n            }\n            return;\n        };\n        component.observe = function (intf) {\n            var observer;\n            if (!window.MutationObserver) { return; }\n            intf.applyComponentStyle = function () { applyComponentStyle(false, intf); intf.resize(); };\n            /**\n             * Applies the computed css styles to the grid.  In some browsers, changing directives in attached style sheets does not automatically update the styles in this component.  It is necessary to call this method to update in these cases.\n             * @memberof canvasDatagrid\n             * @name applyComponentStyle\n             * @method\n             */\n            observer = new window.MutationObserver(function (mutations) {\n                var checkInnerHTML, checkStyle;\n                Array.prototype.forEach.call(mutations, function (mutation) {\n                    if (mutation.attributeName === 'class'\n                            || mutation.attributeName === 'style') {\n                        intf.applyComponentStyle(false, intf);\n                        return;\n                    }\n                    if (mutation.target.parentNode\n                            && mutation.target.parentNode.nodeName === 'STYLE') {\n                        checkStyle = true;\n                        return;\n                    }\n                    if (mutation.addedNodes.length > 0 || mutation.type === 'characterData') {\n                        checkInnerHTML = true;\n                    }\n                });\n                if (checkStyle) {\n                    intf.applyComponentStyle(false, intf);\n                }\n                if (checkInnerHTML) {\n                    intf.data = typeMap.data(intf.innerHTML);\n                }\n            });\n            observer.observe(intf, { characterData: true, childList: true, attributes: true, subtree: true });\n            observer.observe(intf.canvas, { attributes: true });\n            Array.prototype.forEach.call(document.querySelectorAll('style'), function (el) {\n                observer.observe(el, { characterData: true, childList: true, attributes: true, subtree: true });\n            });\n        };\n        return component;\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals XMLSerializer: false, define: true, Blob: false, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        var perfCounters = [],\n            drawCount = 0,\n            perfWindowSize = 300,\n            entityCount = [],\n            scrollDebugCounters = [],\n            touchPPSCounters = [];\n        self.htmlImageCache = {};\n        function drawPerfLine(w, h, x, y, perfArr, arrIndex, max, color, useAbs) {\n            var i = w / perfArr.length,\n                r = h / max;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.moveTo(x, y + h);\n            perfArr.forEach(function (n) {\n                var val = (arrIndex === undefined ? n : n[arrIndex]),\n                    cx,\n                    cy;\n                if (useAbs) {\n                    val = Math.abs(val);\n                }\n                cx = x + i;\n                cy = y + h - (val * r);\n                self.ctx.lineTo(cx, cy);\n                x += i;\n            });\n            self.ctx.moveTo(x + w, y + h);\n            self.ctx.strokeStyle = color;\n            self.ctx.stroke();\n        }\n        function drawOnAllImagesLoaded() {\n            var loaded = true;\n            Object.keys(self.htmlImageCache).forEach(function (html) {\n                if (!self.htmlImageCache[html].complete) {\n                    loaded = false;\n                }\n            });\n            if (loaded) {\n                self.draw();\n            }\n        }\n        function drawHtml(cell) {\n            var img,\n                v = cell.innerHTML || cell.formattedValue,\n                x = cell.x + self.canvasOffsetLeft,\n                y = cell.y + self.canvasOffsetTop;\n            if (self.htmlImageCache[v]) {\n                img = self.htmlImageCache[v];\n                if (img.height !== cell.height || img.width !== cell.width) {\n                    // height and width of the cell has changed, invalidate cache\n                    self.htmlImageCache[v] = undefined;\n                } else {\n                    if (!img.complete) {\n                        return;\n                    }\n                    return self.ctx.drawImage(img, x, y);\n                }\n            }\n            img = new Image(cell.width, cell.height);\n            self.htmlImageCache[v] = img;\n            img.onload = function () {\n                self.ctx.drawImage(img, x, y);\n                drawOnAllImagesLoaded();\n            };\n            img.src = 'data:image/svg+xml;base64,' + btoa(\n                '<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"' + cell.width + '\" height=\"' + cell.height + '\">\\n' +\n                    '<foreignObject class=\"node\" x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\\n' +\n                    '<body xmlns=\"http://www.w3.org/1999/xhtml\" style=\"margin:0;padding:0;\">\\n' +\n                    v + '\\n' +\n                    '</body>' +\n                    '</foreignObject>\\n' +\n                    '</svg>\\n'\n            );\n        }\n        function drawOrderByArrow(x, y) {\n            var mt = self.style.columnHeaderOrderByArrowMarginTop * self.scale,\n                ml = self.style.columnHeaderOrderByArrowMarginLeft * self.scale,\n                mr = self.style.columnHeaderOrderByArrowMarginRight * self.scale,\n                aw = self.style.columnHeaderOrderByArrowWidth * self.scale,\n                ah = self.style.columnHeaderOrderByArrowHeight * self.scale;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillStyle = self.style.columnHeaderOrderByArrowColor;\n            self.ctx.strokeStyle = self.style.columnHeaderOrderByArrowBorderColor;\n            self.ctx.beginPath();\n            x = x + ml;\n            y = y + mt;\n            if (self.orderDirection === 'asc') {\n                self.ctx.moveTo(x, y);\n                self.ctx.lineTo(x + aw, y);\n                self.ctx.lineTo(x + (aw * 0.5), y + ah);\n                self.ctx.moveTo(x, y);\n            } else {\n                self.ctx.lineTo(x, y + ah);\n                self.ctx.lineTo(x + aw, y + ah);\n                self.ctx.lineTo(x + (aw * 0.5), y);\n                self.ctx.lineTo(x, y + ah);\n            }\n            self.ctx.stroke();\n            self.ctx.fill();\n            return ml + aw + mr;\n        }\n        function drawTreeArrow(cell, x, y) {\n            var mt = self.style.treeArrowMarginTop * self.scale,\n                mr = self.style.treeArrowMarginRight * self.scale,\n                ml = self.style.treeArrowMarginLeft * self.scale,\n                aw = self.style.treeArrowWidth * self.scale,\n                ah = self.style.treeArrowHeight * self.scale;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillStyle = self.style.treeArrowColor;\n            self.ctx.strokeStyle = self.style.treeArrowBorderColor;\n            self.ctx.beginPath();\n            x = x + ml;\n            y = y + mt;\n            if (self.openChildren[cell.data[self.uniqueId]]) {\n                self.ctx.moveTo(x, y);\n                self.ctx.lineTo(x + aw, y);\n                self.ctx.lineTo(x + (aw * 0.5), y + ah);\n                self.ctx.moveTo(x, y);\n            } else {\n                self.ctx.lineTo(x, y);\n                self.ctx.lineTo(x + ah, y + (aw * 0.5));\n                self.ctx.lineTo(x, y + aw);\n                self.ctx.lineTo(x, y);\n            }\n            self.ctx.stroke();\n            self.ctx.fill();\n            return ml + aw + mr;\n        }\n        function radiusRect(x, y, w, h, radius) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            var r = x + w, b = y + h;\n            self.ctx.beginPath();\n            self.ctx.moveTo(x + radius, y);\n            self.ctx.lineTo(r - radius, y);\n            self.ctx.quadraticCurveTo(r, y, r, y + radius);\n            self.ctx.lineTo(r, y + h - radius);\n            self.ctx.quadraticCurveTo(r, b, r - radius, b);\n            self.ctx.lineTo(x + radius, b);\n            self.ctx.quadraticCurveTo(x, b, x, b - radius);\n            self.ctx.lineTo(x, y + radius);\n            self.ctx.quadraticCurveTo(x, y, x + radius, y);\n        }\n        function fillRect(x, y, w, h) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillRect(x, y, w, h);\n        }\n        function strokeRect(x, y, w, h) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.strokeRect(x, y, w, h);\n        }\n        function fillText(text, x, y) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillText(text, x, y);\n        }\n        function fillCircle(x, y, r) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.arc(x, y, r, 0, 2 * Math.PI);\n            self.ctx.fill();\n        }\n        function strokeCircle(x, y, r) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.arc(x, y, r, 0, 2 * Math.PI);\n            self.ctx.stroke();\n        }\n        function clipFrozenArea(mode) {\n            // 0 both, 1 rows, 2 cols\n            // self.lastFrozenColumnPixel;\n            // self.lastFrozenRowPixel;\n            self.ctx.beginPath();\n            if (mode === 0) {\n                self.ctx.moveTo(self.lastFrozenColumnPixel, self.lastFrozenRowPixel);\n                self.ctx.lineTo(self.lastFrozenColumnPixel, self.height);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.width, self.lastFrozenRowPixel);\n            }\n            if (mode === 1) {\n                self.ctx.moveTo(0, self.lastFrozenRowPixel);\n                self.ctx.lineTo(0, self.height);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.width, self.lastFrozenRowPixel);\n            }\n            if (mode === 2) {\n                self.ctx.moveTo(self.lastFrozenColumnPixel, 0);\n                self.ctx.lineTo(self.width, 0);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.lastFrozenColumnPixel, self.height);\n            }\n            self.ctx.clip();\n        }\n        function fillHandle(x, y, r) {\n            if (self.style.selectionHandleType === 'circle') {\n                return fillCircle(x, y, r * 0.5);\n            }\n            fillRect(x - r * 0.5, y - r * 0.5, r, r);\n        }\n        function strokeHandle(x, y, r) {\n            if (self.style.selectionHandleType === 'circle') {\n                return strokeCircle(x, y, r * 0.5);\n            }\n            strokeRect(x - r * 0.5, y - r * 0.5, r, r);\n        }\n        function addselectionHandle(c, pos) {\n            var hw = self.style.selectionHandleSize,\n                p = {\n                    tr: function () {\n                        fillHandle(c.x + c.width, c.y, hw);\n                        strokeHandle(c.x + c.width, c.y, hw);\n                    },\n                    br: function () {\n                        fillHandle(c.x + c.width, c.y + c.height, hw);\n                        strokeHandle(c.x + c.width, c.y + c.height, hw);\n                    },\n                    tl: function () {\n                        fillHandle(c.x, c.y, hw);\n                        strokeHandle(c.x, c.y, hw);\n                    },\n                    bl: function () {\n                        fillHandle(c.x, c.y + c.height, hw);\n                        strokeHandle(c.x, c.y + c.height, hw);\n                    }\n                };\n            p[pos]();\n        }\n        function addBorderLine(c, pos) {\n            self.ctx.beginPath();\n            var p = {\n                t: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop);\n                },\n                r: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop + c.height);\n                },\n                b: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop + c.height);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop + c.height);\n                },\n                l: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop + c.height);\n                }\n            };\n            p[pos]();\n            self.ctx.stroke();\n        }\n        function addEllipsis(text, width) {\n            var c, w = 0;\n            if (self.ellipsisCache[text] && self.ellipsisCache[text][width]) {\n                return self.ellipsisCache[text][width];\n            }\n            //TODO Add ellipsis back when there is a fast way to do it\n            w = self.ctx.measureText(text).width;\n            self.ellipsisCache[text] = self.ellipsisCache[text] || {};\n            c = {value: text, width: w};\n            self.ellipsisCache[text][width] = c;\n            return c;\n        }\n        function drawText(cell) {\n            var paddingLeft = self.style[cell.style + 'PaddingLeft'] * self.scale,\n                paddingTop = self.style[cell.style + 'PaddingTop'] * self.scale,\n                paddingRight = self.style[cell.style + 'PaddingRight'] * self.scale,\n                paddingBottom = self.style[cell.style + 'PaddingBottom'] * self.scale,\n                vPos = paddingTop + cell.height - (cell.height * 0.5),\n                hPos = paddingLeft + cell.treeArrowWidth + cell.orderByArrowWidth;\n            cell.text = addEllipsis(cell.formattedValue, cell.width - paddingRight - paddingLeft);\n            cell.text.height = cell.fontHeight;\n            if (cell.horizontalAlignment === 'right') {\n                hPos = cell.width - cell.text.width - paddingRight;\n            } else if (cell.horizontalAlignment === 'center') {\n                hPos = (cell.width / 2) - (cell.text.width / 2);\n            }\n            if (cell.verticalAlignment === 'top') {\n                vPos = paddingTop + cell.text.height;\n            } else if (cell.verticalAlignment === 'bottom') {\n                vPos = cell.height - paddingBottom - cell.text.height;\n            }\n            cell.text.x = cell.x + hPos;\n            cell.text.y = cell.y + vPos;\n            fillText(cell.text.value, cell.text.x, cell.text.y);\n        }\n        function getFrozenColumnsWidth() {\n            var w = 0,\n                s = self.getVisibleSchema(),\n                x = 0,\n                n = Math.min(self.frozenColumn, s.length),\n                column;\n            while (x < n) {\n                column = s[self.orders.columns[x]];\n                w += ((self.sizes.columns[column[self.uniqueId]] || column.width || self.style.cellWidth) * self.scale);\n                x += 1;\n            }\n            return w;\n        }\n        /**\n         * Redraws the grid. No matter what the change, this is the only method required to refresh everything.\n         * @memberof canvasDatagrid\n         * @name draw\n         * @method\n         */\n         // r = literal row index\n         // rd = row data array\n         // i = user order index\n         // o = literal data index\n         // y = y drawing cursor\n         // x = x drawing cursor\n         // s = visible schema array\n         // cx = current x drawing cursor sub calculation var\n         // cy = current y drawing cursor sub calculation var\n         // a = static cell (like corner cell)\n         // p = perf counter\n         // l = data length\n         // u = current cell\n         // h = current height\n         // w = current width\n        self.draw = function (internal) {\n            if (self.dispatchEvent('beforedraw', {})) { return; }\n            if (!self.isChildGrid && (!self.height || !self.width)) {\n                return;\n            }\n            if (self.isChildGrid && internal) {\n                requestAnimationFrame(self.parentGrid.draw);\n                return;\n            }\n            if (self.intf.visible === false) {\n                return;\n            }\n            // initial values\n            var checkScrollHeight, rowHeaderCell, p, cx, cy, treeGrid, rowOpen,\n                rowHeight, cornerCell, y, x, c, h, w, s, r, rd, aCell,\n                bc = self.style.gridBorderCollapse === 'collapse',\n                selectionBorders = [],\n                moveBorders = [],\n                selectionHandles = [],\n                rowHeaders = [],\n                frozenColumnWidths = getFrozenColumnsWidth(),\n                l = self.data.length,\n                u = self.currentCell || {},\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                cellHeight = self.style.cellHeight;\n            drawCount += 1;\n            p = performance.now();\n            self.visibleRowHeights = [];\n            // if data length has changed, there is no way to know\n            if (self.data.length > self.orders.rows.length) {\n                self.createRowOrders();\n            }\n            function drawScrollBars() {\n                var v = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'vertical-scroll-bar'\n                    },\n                    n = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'horizontal-scroll-bar'\n                    },\n                    vb = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'vertical-scroll-box'\n                    },\n                    nb = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'horizontal-scroll-box'\n                    },\n                    co = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        isCorner: true,\n                        isScrollBoxCorner: true,\n                        style: 'scroll-box-corner'\n                    },\n                    m = (self.style.scrollBarBoxMargin * 2),\n                    d = self.style.scrollBarBoxMargin * 0.5;\n                self.ctx.strokeStyle = self.style.scrollBarBorderColor;\n                self.ctx.lineWidth = self.style.scrollBarBorderWidth;\n                // vertical\n                v.x += w - self.style.scrollBarWidth - self.style.scrollBarBorderWidth - d;\n                v.y += columnHeaderCellHeight;\n                v.width = self.style.scrollBarWidth + self.style.scrollBarBorderWidth + d;\n                v.height = h - columnHeaderCellHeight - self.style.scrollBarWidth - d - m;\n                self.ctx.fillStyle = self.style.scrollBarBackgroundColor;\n                fillRect(v.x, v.y, v.width, v.height + m);\n                strokeRect(v.x, v.y, v.width, v.height + m);\n                // vertical box\n                vb.x = v.x + self.style.scrollBarBoxMargin;\n                vb.y = columnHeaderCellHeight + self.style.scrollBarBoxMargin\n                    + ((v.height - self.scrollBox.scrollBoxHeight)\n                        * (self.scrollBox.scrollTop / self.scrollBox.scrollHeight));\n                vb.width = self.style.scrollBarBoxWidth;\n                vb.height = self.scrollBox.scrollBoxHeight;\n                self.ctx.fillStyle = self.style.scrollBarBoxColor;\n                if (/vertical/.test(u.context)) {\n                    self.ctx.fillStyle = self.style.scrollBarActiveColor;\n                }\n                if (vb.height < v.height) {\n                    radiusRect(vb.x, vb.y, vb.width, vb.height, self.style.scrollBarBoxBorderRadius);\n                    self.ctx.stroke();\n                    self.ctx.fill();\n                }\n                // horizontal\n                n.x += rowHeaderCellWidth;\n                n.y += h - self.style.scrollBarWidth - d;\n                n.width = w - self.style.scrollBarWidth - rowHeaderCellWidth - d - m;\n                n.height = self.style.scrollBarWidth + self.style.scrollBarBorderWidth + d;\n                self.ctx.fillStyle = self.style.scrollBarBackgroundColor;\n                fillRect(n.x, n.y, n.width + m, n.height);\n                strokeRect(n.x, n.y, n.width + m, n.height);\n                // horizontal box\n                nb.y = n.y + self.style.scrollBarBoxMargin;\n                nb.x = rowHeaderCellWidth + self.style.scrollBarBoxMargin\n                    + ((n.width - self.scrollBox.scrollBoxWidth)\n                        * (self.scrollBox.scrollLeft / self.scrollBox.scrollWidth));\n                nb.width = self.scrollBox.scrollBoxWidth;\n                nb.height = self.style.scrollBarBoxWidth;\n                self.ctx.fillStyle = self.style.scrollBarBoxColor;\n                if (/horizontal/.test(u.context)) {\n                    self.ctx.fillStyle = self.style.scrollBarActiveColor;\n                }\n                if (nb.width < n.width) {\n                    radiusRect(nb.x, nb.y, nb.width, nb.height, self.style.scrollBarBoxBorderRadius);\n                    self.ctx.stroke();\n                    self.ctx.fill();\n                }\n                //corner\n                self.ctx.strokeStyle = self.style.scrollBarCornerBorderColor;\n                self.ctx.fillStyle = self.style.scrollBarCornerBackgroundColor;\n                co.x = n.x + n.width + m;\n                co.y = v.y + v.height + m;\n                co.width = self.style.scrollBarWidth + self.style.scrollBarBorderWidth;\n                co.height = self.style.scrollBarWidth + self.style.scrollBarBorderWidth;\n                radiusRect(co.x, co.y, co.width, co.height, 0);\n                self.ctx.stroke();\n                self.ctx.fill();\n                self.visibleCells.unshift(v);\n                self.visibleCells.unshift(vb);\n                self.visibleCells.unshift(n);\n                self.visibleCells.unshift(nb);\n                self.visibleCells.unshift(co);\n                self.scrollBox.bar = {\n                    v: v,\n                    h: n\n                };\n                self.scrollBox.box = {\n                    v: vb,\n                    h: nb\n                };\n            }\n            function createHandlesOverlayArray(cell) {\n                if (self.attributes.allowMovingSelection || self.mobile) {\n                    if (cell.selectionBorderTop && cell.selectionBorderRight && self.mobile) {\n                        selectionHandles.push([cell, 'tr']);\n                        cell.selectionHandle = 'tr';\n                    }\n                    if (cell.selectionBorderTop && cell.selectionBorderLeft && self.mobile) {\n                        selectionHandles.push([cell, 'tl']);\n                        cell.selectionHandle = 'tl';\n                    }\n                    if (cell.selectionBorderBottom && cell.selectionBorderLeft && self.mobile) {\n                        selectionHandles.push([cell, 'bl']);\n                        cell.selectionHandle = 'bl';\n                    }\n                    if (cell.selectionBorderBottom && cell.selectionBorderRight\n                            && (self.attributes.selectionHandleBehavior !== 'none' || self.mobile)) {\n                        selectionHandles.push([cell, 'br']);\n                        cell.selectionHandle = 'br';\n                    }\n                }\n            }\n            function createBorderOverlayArray(cell, drawArray, propPrefix, offsetPoint) {\n                offsetPoint = offsetPoint || {x: 0, y: 0};\n                cell.selectionBorder = '';\n                if (!cell.isRowHeader\n                        && self.selections[cell.rowIndex + -offsetPoint.y]\n                        && self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) !== -1) {\n                    if ((!self.selections[cell.rowIndex - 1 + -offsetPoint.y]\n                            || self.selections[cell.rowIndex - 1 + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) === -1\n                            || cell.rowIndex === 0)\n                            && !cell.isHeader) {\n                        drawArray.push([cell, 't']);\n                        cell[propPrefix + 'BorderTop'] = true;\n                        cell[propPrefix + 'Border'] += 't';\n                    }\n                    if (!self.selections[cell.rowIndex + 1 + -offsetPoint.y]\n                            || self.selections[cell.rowIndex + 1 + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'b']);\n                        cell[propPrefix + 'BorderBottom'] = true;\n                        cell[propPrefix + 'Border'] += 'b';\n                    }\n                    if (!self.selections[cell.rowIndex + -offsetPoint.y] || cell.columnIndex === 0\n                            || self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex - 1 + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'l']);\n                        cell[propPrefix + 'BorderLeft'] = true;\n                        cell[propPrefix + 'Border'] += 'l';\n                    }\n                    if (!self.selections[cell.rowIndex + -offsetPoint.y] || cell.columnIndex === s.length\n                            || self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex + 1 + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'r']);\n                        cell[propPrefix + 'BorderRight'] = true;\n                        cell[propPrefix + 'Border'] += 'r';\n                    }\n                }\n            }\n            function drawCell(d, rowOrderIndex, rowIndex) {\n                return function drawEach(header, headerIndex, columnOrderIndex) {\n                    var cellStyle = header.style || 'cell',\n                        cellGridAttributes,\n                        cell,\n                        isHeader = /HeaderCell/.test(cellStyle),\n                        isCorner = /cornerCell/.test(cellStyle),\n                        isRowHeader = 'rowHeaderCell' === cellStyle,\n                        isColumnHeader = 'columnHeaderCell' === cellStyle,\n                        selected = self.selections[rowOrderIndex] && self.selections[rowOrderIndex].indexOf(columnOrderIndex) !== -1,\n                        hovered = self.hovers[d[self.uniqueId]] && self.hovers[d[self.uniqueId]].indexOf(columnOrderIndex) !== -1,\n                        active = self.activeCell.rowIndex === rowOrderIndex && self.activeCell.columnIndex === columnOrderIndex,\n                        isGrid = typeof d[header.name] === 'object' && d[header.name] !== null && d[header.name] !== undefined,\n                        activeHeader = (self.orders.rows[self.activeCell.rowIndex] === rowOrderIndex\n                                || self.orders.columns[self.activeCell.columnIndex] === columnOrderIndex)\n                            && (columnOrderIndex === -1 || rowOrderIndex === -1)\n                            ? (isRowHeader ? 'activeRowHeaderCell' : 'activeColumnHeaderCell') : false,\n                        val,\n                        f = self.formatters[header.type || 'string'],\n                        orderByArrowSize = 0,\n                        treeArrowSize = 0,\n                        cellWidth = self.sizes.columns[isRowHeader ? 'cornerCell' : header[self.uniqueId]] || header.width,\n                        ev = {\n                            value: d[header.name],\n                            row: d,\n                            header: header\n                        };\n                    if (cellStyle === 'headerCellCap') {\n                        cellWidth = w - x;\n                    }\n                    // if no data or schema are defined, a width is provided to the stub column\n                    if (cellWidth === undefined) {\n                        cellWidth = self.style.cellWidth;\n                    }\n                    cellWidth = cellWidth * self.scale;\n                    if (x + cellWidth + self.style.cellBorderWidth < 0) {\n                        x += cellWidth + self.style.cellBorderWidth;\n                    }\n                    if (active && cellStyle !== 'cornerCell') {\n                        cellStyle = 'activeCell';\n                    }\n                    if (self.visibleRows.indexOf(rowIndex) === -1 && !isHeader) {\n                        self.visibleRows.push(rowIndex);\n                    }\n                    val = self.dispatchEvent('formatcellvalue', ev);\n                    cx = x;\n                    cy = y;\n                    if (cellStyle === 'cornerCell') {\n                        cx = 0;\n                        cy = 0;\n                    } else if (isRowHeader) {\n                        cx = 0;\n                    } else if (isHeader) {\n                        cy = 0;\n                    }\n                    cell = {\n                        type: isGrid ? 'canvas-datagrid-cell' : header.type,\n                        style: cellStyle,\n                        nodeType: 'canvas-datagrid-cell',\n                        x: cx,\n                        y: cy,\n                        horizontalAlignment: self.style[cellStyle + 'HorizontalAlignment'],\n                        verticalAlignment: self.style[cellStyle + 'VerticalAlignment'],\n                        offsetTop: self.canvasOffsetTop + cy,\n                        offsetLeft: self.canvasOffsetLeft + cx,\n                        scrollTop: self.scrollBox.scrollTop,\n                        scrollLeft: self.scrollBox.scrollLeft,\n                        active: active || activeHeader,\n                        hovered: hovered,\n                        selected: selected,\n                        width: cellWidth,\n                        height: cellHeight,\n                        offsetWidth: cellWidth,\n                        offsetHeight: cellHeight,\n                        parentNode: self.intf.parentNode,\n                        offsetParent: self.intf.parentNode,\n                        data: d,\n                        isCorner: isCorner,\n                        isHeader: isHeader,\n                        isColumnHeader: isColumnHeader,\n                        isHeaderCellCap: !!header.isHeaderCellCap,\n                        isRowHeader: isRowHeader,\n                        rowOpen: rowOpen,\n                        header: header,\n                        columnIndex: columnOrderIndex,\n                        rowIndex: rowOrderIndex,\n                        sortColumnIndex: headerIndex,\n                        sortRowIndex: rowIndex,\n                        isGrid: isGrid,\n                        isNormal: !isGrid && !isCorner && !isHeader,\n                        gridId: (self.attributes.name || '') + d[self.uniqueId] + ':' + header[self.uniqueId],\n                        parentGrid: self.intf,\n                        innerHTML: '',\n                        activeHeader: activeHeader,\n                        value: isHeader && !isRowHeader ? (header.title || header.name) : d[header.name]\n                    };\n                    ev.cell = cell;\n                    cell.userHeight = cell.isHeader ? self.sizes.rows[-1] : rowHeight;\n                    cell.userWidth = cell.isHeader ? self.sizes.columns.cornerCell : self.sizes.columns[header[self.uniqueId]];\n                    cell[self.uniqueId] = d[self.uniqueId];\n                    self.visibleCells.unshift(cell);\n                    if (self.dispatchEvent('beforerendercell', ev)) { return; }\n                    self.ctx.fillStyle = self.style[cellStyle + 'BackgroundColor'];\n                    self.ctx.strokeStyle = self.style[cellStyle + 'BorderColor'];\n                    self.ctx.lineWidth = self.style[cellStyle + 'BorderWidth'];\n                    if (hovered) {\n                        self.ctx.fillStyle = self.style[cellStyle + 'HoverBackgroundColor'];\n                        self.ctx.strokeStyle = self.style[cellStyle + 'HoverBorderColor'];\n                    }\n                    if (selected) {\n                        self.ctx.fillStyle = self.style[cellStyle + 'SelectedBackgroundColor'];\n                        self.ctx.strokeStyle = self.style[cellStyle + 'SelectedBorderColor'];\n                    }\n                    if (activeHeader) {\n                        self.ctx.fillStyle = self.style[activeHeader + 'BackgroundColor'];\n                    }\n                    self.dispatchEvent('rendercell', ev);\n                    if (cell.isGrid) {\n                        if (cell.height !== rowHeight) {\n                            cell.height = rowHeight || self.style.cellHeightWithChildGrid;\n                            checkScrollHeight = true;\n                        }\n                        cell.width = self.sizes.columns[header[self.uniqueId]] || self.style.cellWidthWithChildGrid;\n                    }\n                    if (rowOpen && !cell.isRowHeader) {\n                        cell.height = self.sizes.rows[rd[self.uniqueId]] || self.style.cellHeight;\n                    }\n                    if (!cell.isGrid) {\n                        fillRect(cx, cy, cell.width, cell.height);\n                        strokeRect(cx, cy, cell.width, cell.height);\n                    }\n                    self.ctx.save();\n                    radiusRect(cell.x, cell.y, cell.width, cell.height, 0);\n                    self.ctx.clip();\n                    self.dispatchEvent('afterrendercell', ev);\n                    if (cell.height !== cellHeight && !(rowOpen && !cell.isRowHeader)) {\n                        self.sizes.rows[isHeader ? -1 : d[self.uniqueId]] = cell.height;\n                        checkScrollHeight = true;\n                    }\n                    if (cell.width !== cellWidth) {\n                        self.sizes.columns[header[self.uniqueId]] = cell.width;\n                        checkScrollHeight = true;\n                    }\n                    if (isRowHeader && self.attributes.tree) {\n                        if (!self.dispatchEvent('rendertreearrow', ev)) {\n                            treeArrowSize = drawTreeArrow(cell, self.style[cellStyle + 'PaddingLeft'], cy, 0);\n                        }\n                    }\n                    if ((self.attributes.showRowNumbers && isRowHeader)\n                            || !isRowHeader) {\n                        if (cell.isGrid && !self.dispatchEvent('beforerendercellgrid', ev)) {\n                            if (!self.childGrids[cell.gridId]) {\n                                cellGridAttributes = self.args.cellGridAttributes || self.args;\n                                cellGridAttributes.name = self.attributes.saveAppearance ? cell.gridId : undefined;\n                                cellGridAttributes.component = false;\n                                cellGridAttributes.parentNode = cell;\n                                cellGridAttributes.data = d[header.name];\n                                cellGridAttributes.style = cellGridAttributes.style || self.style;\n                                ev.cellGridAttributes = cellGridAttributes;\n                                if (self.dispatchEvent('beforecreatecellgrid', ev)) { return; }\n                                self.childGrids[cell.gridId] = self.createGrid(cellGridAttributes);\n                                self.sizes.rows[rd[self.uniqueId]]\n                                    = self.sizes.rows[rd[self.uniqueId]] || self.style.cellGridHeight;\n                                checkScrollHeight = true;\n                            }\n                            cell.grid = self.childGrids[cell.gridId];\n                            cell.grid.parentNode = cell;\n                            cell.grid.visible = true;\n                            cell.grid.draw();\n                            self.dispatchEvent('rendercellgrid', ev);\n                        } else if (!cell.isGrid) {\n                            if (self.childGrids[cell.gridId]) {\n                                self.childGrids[cell.gridId].parentNode.offsetHeight = 0;\n                            }\n                            if (isHeader && self.orderBy === header.name) {\n                                if (!self.dispatchEvent('renderorderbyarrow', ev)) {\n                                    orderByArrowSize = drawOrderByArrow(cx + self.style[cellStyle + 'PaddingLeft'], 0);\n                                }\n                            }\n                            self.ctx.fillStyle = self.style[cellStyle + 'Color'];\n                            if (hovered) {\n                                self.ctx.fillStyle = self.style[cellStyle + 'HoverColor'];\n                            }\n                            if (selected) {\n                                self.ctx.fillStyle = self.style[cellStyle + 'SelectedColor'];\n                            }\n                            if (activeHeader) {\n                                self.ctx.fillStyle = self.style[activeHeader + 'Color'];\n                            }\n                            self.ctx.font = (self.style[cellStyle + 'FontHeight'] * self.scale) + 'px ' + self.style[cellStyle + 'FontName'];\n                            cell.fontHeight = (self.style[cellStyle + 'FontHeight'] * self.scale);\n                            cell.treeArrowWidth = treeArrowSize;\n                            cell.orderByArrowWidth = orderByArrowSize;\n                            val = val !== undefined ? val : f\n                                ? f(ev) : '';\n                            if (val === undefined && !f) {\n                                val = '';\n                                console.warn('canvas-datagrid: Unknown format '\n                                    + header.type + ' add a cellFormater');\n                            }\n                            cell.formattedValue = ((val !== undefined && val !== null) ? val : '').toString();\n                            if (self.columnFilters && self.columnFilters[val] !== undefined && isHeader) {\n                                cell.formattedValue = self.attributes.filterTextPrefix + val;\n                            }\n                            if (!self.dispatchEvent('rendertext', ev)) {\n                                if (cell.innerHTML || header.type === 'html') {\n                                    drawHtml(cell);\n                                } else {\n                                    drawText(cell);\n                                }\n                            }\n                        }\n                    }\n                    if (active) {\n                        aCell = cell;\n                    }\n                    createBorderOverlayArray(cell, selectionBorders, 'selection');\n                    // createBorderOverlayArray calculates data for createHandlesOverlayArray so it must go 2nd\n                    createHandlesOverlayArray(cell);\n                    if (self.movingSelection) {\n                        createBorderOverlayArray(cell, moveBorders, 'move', self.moveOffset);\n                    }\n                    self.ctx.restore();\n                    x += cell.width + (bc ? 0 : self.style.cellBorderWidth);\n                    return cell.width;\n                };\n            }\n            function drawRowHeader(rowData, index, rowOrderIndex) {\n                var a;\n                if (self.attributes.showRowHeaders) {\n                    x = 0;\n                    rowHeaderCell = {'rowHeaderCell': index + 1 };\n                    rowHeaderCell[self.uniqueId] = rowData[self.uniqueId];\n                    a = {\n                        name: 'rowHeaderCell',\n                        width: self.style.rowHeaderCellWidth,\n                        style: 'rowHeaderCell',\n                        type: 'string',\n                        data: rowData[self.uniqueId],\n                        index: -1\n                    };\n                    a[self.uniqueId] = rowData[self.uniqueId];\n                    rowOpen = self.openChildren[rowData[self.uniqueId]];\n                    drawCell(rowHeaderCell, index, rowOrderIndex)(a, -1, -1);\n                }\n            }\n            function drawHeaders() {\n                var d, g = s.length, i, o, columnHeaderCell, header, nonFrozenHeaderWidth;\n                function drawHeaderColumnRange(start, end) {\n                    end = Math.min(end, g);\n                    for (o = start; o < end; o += 1) {\n                        i = self.orders.columns[o];\n                        header = s[i];\n                        d = {\n                            title: header.title,\n                            name: header.name,\n                            width: header.width || self.style.cellWidth,\n                            style: 'columnHeaderCell',\n                            type: 'string',\n                            index: o,\n                            order: i\n                        };\n                        columnHeaderCell = {'columnHeaderCell': header.title || header.name};\n                        columnHeaderCell[self.uniqueId] = 'h' + header[self.uniqueId];\n                        d[self.uniqueId] = header[self.uniqueId];\n                        x += drawCell(columnHeaderCell, -1, -1)(d, o, i);\n                        if (x > self.width + self.scrollBox.scrollLeft) {\n                            break;\n                        }\n                    }\n                }\n                rowHeaders.forEach(function (rArgs, rhIndex) {\n                    y = rArgs[3];\n                    cellHeight = rArgs[4];\n                    if (rhIndex === self.frozenRow) {\n                        self.ctx.save();\n                        radiusRect(0, self.lastFrozenRowPixel, self.width, self.height - self.lastFrozenRowPixel, 0);\n                        self.ctx.clip();\n                    }\n                    drawRowHeader(rArgs[0], rArgs[1], rArgs[2]);\n                });\n                self.ctx.restore();\n                if (self.attributes.showColumnHeaders) {\n                    x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.columnHeaderCellBorderWidth;\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    x += frozenColumnWidths;\n                    y = 0;\n                    // cell height might have changed during drawing\n                    cellHeight = self.getColumnHeaderCellHeight();\n                    drawHeaderColumnRange(self.scrollIndexLeft + self.frozenColumn, g);\n                    nonFrozenHeaderWidth = x;\n                    x = self.style.columnHeaderCellBorderWidth;\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    drawHeaderColumnRange(0, self.frozenColumn);\n                    // fill in the space right of the headers\n                    x = nonFrozenHeaderWidth;\n                    if (x < w) {\n                        c = {\n                            name: '',\n                            width: self.style.scrollBarWidth,\n                            style: 'headerCellCap',\n                            isHeaderCell: true,\n                            isHeaderCellCap: true,\n                            type: 'string',\n                            index: s.length\n                        };\n                        c[self.uniqueId] = 'columnHeaderCell';\n                        drawCell({endCap: ''}, -1, -1)(c, -1, -1);\n                    }\n                    // fill in the space right of the headers\n                    if (self.attributes.showRowHeaders) {\n                        cornerCell = {'cornerCell': '' };\n                        cornerCell[self.uniqueId] = 'cornerCell';\n                        x = 0;\n                        c = {\n                            name: 'cornerCell',\n                            width: self.style.rowHeaderCellWidth,\n                            style: 'cornerCell',\n                            type: 'string',\n                            index: -1\n                        };\n                        c[self.uniqueId] = 'cornerCell';\n                        drawCell(cornerCell, -1, -1)(c, -1, -1);\n                    }\n                }\n            }\n            function drawRow(r, d) {\n                var i, treeHeight, rowSansTreeHeight, o, g = s.length;\n                if (y - (cellHeight * 2) > h) {\n                    return false;\n                }\n                rd = self.data[r];\n                rowOpen = self.openChildren[rd[self.uniqueId]];\n                rowSansTreeHeight = (self.sizes.rows[rd[self.uniqueId]] || self.style.cellHeight) * self.scale;\n                treeHeight = (rowOpen ? self.sizes.trees[rd[self.uniqueId]] : 0) * self.scale;\n                rowHeight = (rowSansTreeHeight + treeHeight);\n                if (y < -rowHeight) {\n                    return false;\n                }\n                if (self.attributes.showRowHeaders) {\n                    x += rowHeaderCellWidth;\n                }\n                cellHeight = rowHeight;\n                if (self.attributes.allowFreezingColumns) {\n                    x += frozenColumnWidths;\n                }\n                //draw normal columns\n                for (o = (self.scrollIndexLeft + self.frozenColumn); o < g; o += 1) {\n                    i = self.orders.columns[o];\n                    x += drawCell(rd, r, d)(s[i], i, o);\n                    if (x > self.width) {\n                        self.scrollIndexRight = o;\n                        self.scrollPixelRight = x;\n                        break;\n                    }\n                }\n                //draw frozen columns\n                x = 0;\n                if (self.attributes.showRowHeaders) {\n                    x += rowHeaderCellWidth;\n                }\n                for (o = 0; o < self.frozenColumn; o += 1) {\n                    i = self.orders.columns[o];\n                    x += drawCell(rd, r, d)(s[i], i, o);\n                    if (x > self.width) {\n                        break;\n                    }\n                }\n                self.lastFrozenColumnPixel = x;\n                // cell height might have changed during drawing\n                cellHeight = rowHeight;\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                // don't draw a tree for the new row\n                treeGrid = self.childGrids[rd[self.uniqueId]];\n                if (r !== self.data.length && rowOpen) {\n                    treeGrid.visible = true;\n                    treeGrid.parentNode = {\n                        offsetTop: y + rowSansTreeHeight + self.canvasOffsetTop,\n                        offsetLeft: rowHeaderCellWidth - 1 + self.canvasOffsetLeft,\n                        offsetHeight: treeHeight,\n                        offsetWidth: self.width - rowHeaderCellWidth - self.style.scrollBarWidth - 1,\n                        offsetParent: self.intf.parentNode,\n                        parentNode: self.intf.parentNode,\n                        style: self.style,\n                        nodeType: 'canvas-datagrid-tree',\n                        scrollTop: self.scrollBox.scrollTop,\n                        scrollLeft: self.scrollBox.scrollLeft,\n                        rowIndex: r\n                    };\n                    self.visibleCells.unshift({\n                        rowIndex: r,\n                        columnIndex: 0,\n                        y: treeGrid.parentNode.offsetTop,\n                        x: treeGrid.parentNode.offsetLeft,\n                        height: treeGrid.height,\n                        width: treeGrid.width,\n                        style: 'tree-grid',\n                        type: treeGrid.parentNode.nodeType\n                    });\n                    treeGrid.draw();\n                } else if (treeGrid) {\n                    treeGrid.parentNode.offsetHeight = 0;\n                    delete self.sizes.trees[rd[self.uniqueId]];\n                }\n                rowHeaders.push([rd, r, d, y, rowHeight]);\n                self.visibleRowHeights[r] = rowHeight;\n                y += cellHeight + (bc ? 0 : self.style.cellBorderWidth);\n                return true;\n            }\n            function initDraw() {\n                self.visibleRows = [];\n                s = self.getVisibleSchema();\n                self.visibleCells = [];\n                self.canvasOffsetTop = self.isChildGrid ? self.parentNode.offsetTop : 0;\n                self.canvasOffsetLeft = self.isChildGrid ? self.parentNode.offsetLeft : 0;\n                h = self.height;\n                w = self.width;\n            }\n            function drawBackground() {\n                radiusRect(0, 0, w, h, 0);\n                self.ctx.clip();\n                self.ctx.fillStyle = self.style.gridBackgroundColor;\n                fillRect(0, 0, w, h);\n            }\n            function drawFrozenRows() {\n                var n, ln = Math.min(self.data.length, self.frozenRow);\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                y = columnHeaderCellHeight;\n                for (r = 0; r < ln; r += 1) {\n                    n = self.orders.rows[r];\n                    if (!drawRow(n, r)) {\n                        break;\n                    }\n                }\n                if (self.attributes.allowFreezingRows) {\n                    // HACK great, another stupid magic number.\n                    // Background will appear as a 0.5px artifact behind the row freeze bar without this hack\n                    y += self.style.frozenMarkerBorderWidth + self.style.frozenMarkerWidth - 0.4999999999;\n                }\n                self.lastFrozenRowPixel = y;\n            }\n            function drawRows() {\n                self.ctx.save();\n                if (self.frozenRow > 0) {\n                    radiusRect(0, self.lastFrozenRowPixel, self.width, self.height - self.lastFrozenRowPixel, 0);\n                    self.ctx.clip();\n                }\n                var o, n, i, g = s.length;\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                if (!self.attributes.snapToRow) {\n                    y += -self.scrollBox.scrollTop + self.scrollPixelTop;\n                }\n                for (r = self.frozenRow + self.scrollIndexTop; r < l; r += 1) {\n                    n = self.orders.rows[r];\n                    if (!drawRow(n, r)) {\n                        self.scrollIndexBottom = r;\n                        self.scrollPixelBottom = y;\n                        break;\n                    }\n                }\n                if (self.attributes.showNewRow) {\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    rowHeight = cellHeight = self.style.cellHeight;\n                    rowOpen = false;\n                    for (o = self.scrollIndexLeft; o < g; o += 1) {\n                        i = self.orders.columns[o];\n                        x += drawCell(self.newRow, self.data.length, self.data.length)(s[i], i, o);\n                        if (x > self.width + self.scrollBox.scrollLeft) {\n                            break;\n                        }\n                    }\n                    rowHeaders.push([self.newRow, self.data.length, self.data.length, y, rowHeight]);\n                }\n                self.ctx.restore();\n            }\n            function drawMoveMarkers() {\n                if (!self.movingSelection) { return; }\n                self.ctx.lineWidth = self.style.moveOverlayBorderWidth;\n                self.ctx.strokeStyle = self.style.moveOverlayBorderColor;\n                self.ctx.setLineDash(self.style.moveOverlayBorderSegments);\n                moveBorders.forEach(function (c) {\n                    addBorderLine(c[0], c[1]);\n                });\n                self.ctx.setLineDash([]);\n            }\n            function drawReorderMarkers() {\n                if (!self.reorderObject) { return; }\n                var b = {\n                        height: self.reorderObject.height,\n                        width: self.reorderObject.width,\n                        x: self.reorderObject.x + self.reorderObject.dragOffset.x,\n                        y: self.reorderObject.y + self.reorderObject.dragOffset.y\n                    },\n                    m = {\n                        width: w,\n                        height: h,\n                        x: 0,\n                        y: 0\n                    };\n                self.ctx.fillStyle = self.style.reorderMarkerBackgroundColor;\n                self.ctx.lineWidth = self.style.reorderMarkerBorderWidth;\n                self.ctx.strokeStyle = self.style.reorderMarkerBorderColor;\n                if (self.dragMode === 'row-reorder') {\n                    b.width = w;\n                    b.x = 0;\n                    m.width = w;\n                    m.height = self.currentCell.height;\n                    m.y = self.currentCell.y;\n                    fillRect(b.x, b.y, b.width, b.height);\n                    strokeRect(b.x, b.y, b.width, b.height);\n                    self.ctx.lineWidth = self.style.reorderMarkerIndexBorderWidth;\n                    self.ctx.strokeStyle = self.style.reorderMarkerIndexBorderColor;\n                    if (self.currentCell.rowIndex !== self.reorderObject.rowIndex\n                            && self.currentCell.rowIndex > -1\n                            && self.currentCell.rowIndex < l) {\n                        addBorderLine(m, self.reorderTarget.sortRowIndex > self.reorderObject.sortRowIndex ? 'b' : 't');\n                    }\n                } else if (self.dragMode === 'column-reorder' && self.reorderObject) {\n                    b.height = h;\n                    b.y = 0;\n                    m.height = h;\n                    m.width = self.currentCell.width;\n                    m.y = 0;\n                    m.x = self.currentCell.x;\n                    fillRect(b.x, b.y, b.width, b.height);\n                    strokeRect(b.x, b.y, b.width, b.height);\n                    self.ctx.lineWidth = self.style.reorderMarkerIndexBorderWidth;\n                    self.ctx.strokeStyle = self.style.reorderMarkerIndexBorderColor;\n                    if (self.currentCell.columnIndex !== self.reorderObject.columnIndex\n                            && self.currentCell.columnIndex > -1\n                            && self.currentCell.columnIndex < s.length) {\n                        addBorderLine(m, self.reorderTarget.sortColumnIndex > self.reorderObject.sortColumnIndex ? 'r' : 'l');\n                    }\n                }\n            }\n            function drawBorder() {\n                self.ctx.lineWidth = self.style.gridBorderWidth;\n                self.ctx.strokeStyle = self.style.gridBorderColor;\n                strokeRect(0, 0, self.width, self.height);\n            }\n            function drawSelectionBorders() {\n                self.ctx.lineWidth = self.style.selectionOverlayBorderWidth;\n                self.ctx.strokeStyle = self.style.selectionOverlayBorderColor;\n                function dsb(c) {\n                    addBorderLine(c[0], c[1]);\n                }\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex < self.frozenRow && c[0].columnIndex < self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.save();\n                clipFrozenArea(0);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex >= self.frozenRow && c[0].columnIndex >= self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n                self.ctx.save();\n                clipFrozenArea(1);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex >= self.frozenRow && c[0].columnIndex < self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n                self.ctx.save();\n                clipFrozenArea(2);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex < self.frozenRow && c[0].columnIndex >= self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n            }\n            function drawSelectionHandles() {\n                if (self.mobile || self.attributes.allowMovingSelection) {\n                    self.ctx.lineWidth = self.style.selectionHandleBorderWidth;\n                    self.ctx.strokeStyle = self.style.selectionHandleBorderColor;\n                    self.ctx.fillStyle = self.style.selectionHandleColor;\n                    selectionHandles.forEach(function (c) {\n                        addselectionHandle(c[0], c[1]);\n                        var az = self.attributes.touchSelectHandleZone / 2,\n                            ax = c[0].x + (c[1] === 'tl' || c[1] === 'bl' ? 0 : c[0].width) - az,\n                            ay = c[0].y + (c[1] === 'bl' || c[1] === 'br' ? c[0].height : 0) - az;\n                        self.visibleCells.unshift({\n                            x: ax,\n                            y: ay,\n                            height: self.style.selectionHandleSize + az,\n                            width: self.style.selectionHandleSize + az,\n                            style: 'selection-handle-' + c[1]\n                        });\n                    });\n                }\n            }\n            function drawActiveCell() {\n                if (!aCell) { return; }\n                self.ctx.save();\n                var cl = self.activeCell.columnIndex + 1 > self.frozenColumn || self.activeCell.rowIndex + 1 > self.frozenRow,\n                    acx = cl ? self.lastFrozenColumnPixel : 0,\n                    acy = cl ? self.lastFrozenRowPixel : 0,\n                    acw = cl ? self.width - self.lastFrozenColumnPixel : self.width,\n                    ach = cl ? self.height - self.lastFrozenRowPixel : self.height;\n                radiusRect(acx, acy, acw, ach, 0);\n                self.ctx.clip();\n                if (self.attributes.selectionMode === 'row') {\n                    if (self.activeCell && self.activeCell.rowIndex === aCell.rowIndex) {\n                        self.ctx.lineWidth = self.style.activeCellOverlayBorderWidth;\n                        self.ctx.strokeStyle = self.style.activeCellOverlayBorderColor;\n                        strokeRect(0, aCell.y, self.getHeaderWidth() + rowHeaderCellWidth, self.visibleRowHeights[aCell.rowIndex]);\n                    }\n                } else {\n                    self.ctx.lineWidth = self.style.activeCellOverlayBorderWidth;\n                    self.ctx.strokeStyle = self.style.activeCellOverlayBorderColor;\n                    strokeRect(aCell.x, aCell.y, aCell.width, aCell.height);\n                }\n                self.ctx.restore();\n            }\n            function drawFrozenMarkers() {\n                var my = self.lastFrozenRowPixel - self.style.frozenMarkerWidth,\n                    mx = self.lastFrozenColumnPixel - self.style.frozenMarkerBorderWidth,\n                    xHover = self.currentCell && self.currentCell.style === 'frozen-row-marker',\n                    yHover = self.currentCell && self.currentCell.style === 'frozen-column-marker';\n                self.ctx.lineWidth = self.style.frozenMarkerBorderWidth;\n                if (self.attributes.allowFreezingColumns) {\n                    self.ctx.fillStyle = yHover ? self.style.frozenMarkerHoverColor : self.style.frozenMarkerColor;\n                    self.ctx.strokeStyle = yHover ? self.style.frozenMarkerHoverBorderColor : self.style.frozenMarkerBorderColor;\n                    fillRect(mx, 0, self.style.frozenMarkerWidth, self.height);\n                    strokeRect(mx, 0, self.style.frozenMarkerWidth, self.height);\n                    self.visibleCells.unshift({\n                        x: mx,\n                        y: 0,\n                        height: self.height,\n                        width: self.style.frozenMarkerWidth + self.style.frozenMarkerBorderWidth,\n                        style: 'frozen-column-marker'\n                    });\n                }\n                if (self.attributes.allowFreezingRows) {\n                    self.ctx.fillStyle = xHover ? self.style.frozenMarkerHoverColor : self.style.frozenMarkerColor;\n                    self.ctx.strokeStyle = xHover ? self.style.frozenMarkerHoverBorderColor : self.style.frozenMarkerBorderColor;\n                    fillRect(0, my, self.width, self.style.frozenMarkerWidth);\n                    strokeRect(0, my, self.width, self.style.frozenMarkerWidth);\n                    self.visibleCells.unshift({\n                        x: 0,\n                        y: my,\n                        height: self.style.frozenMarkerWidth + self.style.frozenMarkerBorderWidth,\n                        width: self.width,\n                        style: 'frozen-row-marker'\n                    });\n                }\n                if (self.freezeMarkerPosition) {\n                    self.ctx.fillStyle = self.style.frozenMarkerActiveColor;\n                    self.ctx.strokeStyle = self.style.frozenMarkerActiveBorderColor;\n                    if (self.dragMode === 'frozen-column-marker') {\n                        fillRect(self.freezeMarkerPosition.x, 0, self.style.frozenMarkerWidth, self.height);\n                        strokeRect(self.freezeMarkerPosition.x, 0, self.style.frozenMarkerWidth, self.height);\n                    } else {\n                        fillRect(0, self.freezeMarkerPosition.y, self.width, self.style.frozenMarkerWidth);\n                        strokeRect(0, self.freezeMarkerPosition.y, self.width, self.style.frozenMarkerWidth);\n                    }\n                }\n            }\n            function drawPerfLines() {\n                if (!self.attributes.showPerformance) { return; }\n                var pw = 250,\n                    px = self.width - pw - self.style.scrollBarWidth - (self.style.scrollBarBorderWidth * 2),\n                    py = columnHeaderCellHeight,\n                    ph = 100;\n                if (scrollDebugCounters.length === 0) { scrollDebugCounters = self.fillArray(0, perfWindowSize, 1, function () { return [0, 0]; }); }\n                if (touchPPSCounters.length === 0) { touchPPSCounters = self.fillArray(0, perfWindowSize, 1, function () { return [0, 0]; }); }\n                if (entityCount.length === 0) { entityCount = self.fillArray(0, perfWindowSize, 1, 0); }\n                self.ctx.lineWidth = 0.5;\n                function dpl(name, perfArr, arrIndex, max, color, useAbs, rowIndex) {\n                    var v;\n                    drawPerfLine(pw, ph, px, py, perfArr, arrIndex, max, color, useAbs);\n                    self.ctx.fillStyle = color;\n                    fillRect(3 + px, py + 9 + (rowIndex * 11), 8, 8);\n                    self.ctx.fillStyle = '#999999';\n                    v = arrIndex !== undefined ? perfArr[0][arrIndex] : perfArr[0];\n                    fillText(name + ' ' + (isNaN(v) ? 0 : v).toFixed(3), 14 + px, py + 16 + (rowIndex * 11));\n                }\n                self.ctx.textAlign = 'left';\n                self.ctx.font = '8px sans-serif';\n                self.ctx.fillStyle = 'rgba(29, 25, 26, 1.00)';\n                fillRect(px, py, pw, ph);\n                [['Scroll Height', scrollDebugCounters, 0, self.scrollBox.scrollHeight, 'rgba(248, 33, 103, 1.00)', false],\n                    ['Scroll Width', scrollDebugCounters, 1, self.scrollBox.scrollWidth, 'rgba(66, 255, 27, 1.00)', false],\n                    ['Performance', perfCounters, undefined, 200, 'rgba(252, 255, 37, 1.00)', false],\n                    ['Entities', entityCount, undefined, 1500, 'rgba(76, 231, 239, 1.00)', false],\n                    ['TouchPPSX', touchPPSCounters, 0, 1000, 'rgba(246, 102, 24, 1.00)', true],\n                    ['TouchPPSY', touchPPSCounters, 1, 1000, 'purple', true]\n                    ].forEach(function (i, index) {\n                    i.push(index);\n                    dpl.apply(null, i);\n                });\n                self.ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';\n                entityCount.pop();\n                entityCount.unshift(self.visibleCells.length);\n                scrollDebugCounters.pop();\n                scrollDebugCounters.unshift([self.scrollBox.scrollTop, self.scrollBox.scrollLeft]);\n                touchPPSCounters.pop();\n                touchPPSCounters.unshift([self.yPPS, self.xPPS]);\n            }\n            function drawDebug() {\n                self.ctx.save();\n                var d;\n                if (self.attributes.showPerformance || self.attributes.debug) {\n                    if (perfCounters.length === 0) { perfCounters = self.fillArray(0, perfWindowSize, 1, 0); }\n                    perfCounters.pop();\n                    perfCounters.unshift(performance.now() - p);\n                }\n                if (!self.attributes.debug) {\n                    self.ctx.restore();\n                    return;\n                }\n                self.ctx.font = '14px sans-serif';\n                d = {};\n                d.perf = (perfCounters.reduce(function (a, b) {\n                    return a + b;\n                }, 0) / Math.min(drawCount, perfCounters.length)).toFixed(1);\n                d.htmlImages = Object.keys(self.htmlImageCache).length;\n                d.reorderObject = 'x: ' + (self.reorderObject || {columnIndex: 0}).columnIndex + ', y: ' + (self.reorderObject || {rowIndex: 0}).rowIndex;\n                d.reorderTarget = 'x: ' + (self.reorderTarget || {columnIndex: 0}).columnIndex + ', y: ' + (self.reorderTarget || {rowIndex: 0}).rowIndex;\n                d.scale = self.scale;\n                d.startScale = self.startScale;\n                d.scaleDelta = self.scaleDelta;\n                d.zoomDeltaStart = self.zoomDeltaStart;\n                d.touchLength = self.touchLength;\n                d.touches = 'y0: ' + (self.touchPosition || {y: 0}).y + ' y1: ' + (self.touchPosition1 || {y: 0}).y;\n                d.scrollBox = self.scrollBox.toString();\n                d.scrollIndex = 'x: ' + self.scrollIndexLeft + ', y: ' + self.scrollIndexTop;\n                d.scrollPixel = 'x: ' + self.scrollPixelLeft + ', y: ' + self.scrollPixelTop;\n                d.canvasOffset = 'x: ' + self.canvasOffsetLeft + ', y: ' + self.canvasOffsetTop;\n                d.touchDelta = 'x: ' + self.touchDelta.x + ', y: ' + self.touchDelta.y;\n                d.touchAnimateTo = 'x: ' + self.touchAnimateTo.x + ', y: ' + self.touchAnimateTo.y;\n                d.scrollAnimation = 'x: ' + self.scrollAnimation.x + ', y: ' + self.scrollAnimation.y;\n                d.touchPPS = 'x: ' + self.xPPS + ', y: ' + self.yPPS;\n                d.touchPPST = 'x: ' + self.xPPST + ', y: ' + self.yPPST;\n                d.touchDuration = self.touchDuration;\n                d.pointerLockPosition =  self.pointerLockPosition ?\n                        self.pointerLockPosition.x + ', ' + self.pointerLockPosition.y : '';\n                d.size = 'w: ' + self.width + ', h: ' + self.height;\n                d.mouse = 'x: ' + self.mouse.x + ', y: ' + self.mouse.y;\n                d.touch = !self.touchStart\n                    ? '' : 'x: ' + self.touchStart.x + ', y: ' + self.touchStart.y;\n                d.entities = self.visibleCells.length;\n                d.hasFocus = self.hasFocus;\n                d.dragMode = self.dragMode;\n                if (self.currentCell) {\n                    d.columnIndex = self.currentCell.columnIndex;\n                    d.rowIndex = self.currentCell.rowIndex;\n                    d.sortColumnIndex = self.currentCell.sortColumnIndex;\n                    d.sortRowIndex = self.currentCell.sortRowIndex;\n                    d.context = self.currentCell.context;\n                    d.dragContext = self.currentCell.dragContext;\n                    d.style = self.currentCell.style;\n                    d.type = self.currentCell.type;\n                }\n                self.ctx.textAlign = 'right';\n                self.ctx.fillStyle = 'rgba(0, 0, 0, .60)';\n                fillRect(0, 0, self.width, self.height);\n                Object.keys(d).forEach(function (key, index) {\n                    var m = key + ': ' + d[key],\n                        lh = 14;\n                    self.ctx.fillStyle = 'rgba(37, 254, 21, 1)';\n                    fillText(m, w - 20, (self.attributes.showPerformance ? 140 : 24) + (index * lh));\n                });\n                self.ctx.restore();\n            }\n            self.ctx.save();\n            initDraw();\n            drawBackground();\n            drawFrozenRows();\n            drawRows();\n            drawActiveCell();\n            drawHeaders();\n            drawFrozenMarkers();\n            drawSelectionBorders();\n            drawSelectionHandles();\n            drawReorderMarkers();\n            drawMoveMarkers();\n            drawScrollBars();\n            if (checkScrollHeight) {\n                self.resize(true);\n            }\n            drawBorder();\n            drawDebug();\n            drawPerfLines();\n            if (self.dispatchEvent('afterdraw', {})) { return; }\n            self.ctx.restore();\n        };\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true, plusplus: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        var wheeling;\n        self.stopPropagation = function (e) { e.stopPropagation(); };\n        /**\n         * Adds an event listener to the given event.\n         * @memberof canvasDatagrid\n         * @name addEventListener\n         * @method\n         * @param {string} ev The name of the event to subscribe to.\n         * @param {function} fn The event procedure to execute when the event is raised.\n         */\n        self.addEventListener = function (ev, fn) {\n            self.events[ev] = self.events[ev] || [];\n            self.events[ev].unshift(fn);\n        };\n        /**\n         * Removes the given listener function from the given event.  Must be an actual reference to the function that was bound.\n         * @memberof canvasDatagrid\n         * @name removeEventListener\n         * @method\n         * @param {string} ev The name of the event to unsubscribe from.\n         * @param {function} fn The event procedure to execute when the event is raised.\n         */\n        self.removeEventListener = function (ev, fn) {\n            (self.events[ev] || []).forEach(function removeEachListener(sfn, idx) {\n                if (fn === sfn) {\n                    self.events[ev].splice(idx, 1);\n                }\n            });\n        };\n        /**\n         * Fires the given event, padding an event object to the event subscribers.\n         * @memberof canvasDatagrid\n         * @name dispatchEvent\n         * @method\n         * @param {number} ev The name of the event to dispatch.\n         * @param {number} e The event object.\n         */\n        self.dispatchEvent = function (ev, e) {\n            e = ev.type ? ev : (e || {});\n            ev = ev.type || ev;\n            var defaultPrevented;\n            function preventDefault() {\n                defaultPrevented = true;\n            }\n            if (!self.events[ev]) { return; }\n            self.events[ev].forEach(function dispatchEachEvent(fn) {\n                e.ctx = self.ctx;\n                e.preventDefault = preventDefault;\n                fn.apply(self.intf, [e]);\n            });\n            return defaultPrevented;\n        };\n        self.getRatio = function () {\n            return Math.min(self.attributes.maxPixelRatio, (window.devicePixelRatio || 1) /\n                (self.ctx.webkitBackingStorePixelRatio ||\n                    self.ctx.mozBackingStorePixelRatio ||\n                    self.ctx.msBackingStorePixelRatio ||\n                    self.ctx.oBackingStorePixelRatio ||\n                    self.ctx.backingStorePixelRatio || 1));\n        };\n        self.resize = function (drawAfterResize) {\n            if (!self.canvas) { return; }\n            var ratio = self.getRatio(),\n                bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                cellBorder = self.style.cellBorderWidth * bm,\n                columnHeaderCellBorder = self.style.columnHeaderCellBorderWidth * bm,\n                scrollHeight,\n                scrollWidth,\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                ch = self.style.cellHeight,\n                // TODO: What the hell are these numbers!?  They are probably some value in the style.\n                scrollDragPositionOffsetY = 30,\n                scrollDragPositionOffsetX = 15;\n            scrollHeight = self.data.reduce(function reduceData(accumulator, row, rowIndex) {\n                return accumulator\n                    + (((self.sizes.rows[row[self.uniqueId]] || ch) + (self.sizes.trees[row[self.uniqueId]] || 0)) * self.scale)\n                    + cellBorder\n                    // HACK? if an expanded tree row is frozen it is necessary to add the tree row's height a second time.\n                    + (self.frozenRow > rowIndex ? (self.sizes.trees[row[self.uniqueId]] || 0) : 0);\n            }, 0) || 0;\n            scrollWidth = self.getVisibleSchema().reduce(function reduceSchema(accumulator, column) {\n                if (column.hidden) { return accumulator; }\n                return accumulator + ((self.sizes.columns[column[self.uniqueId]] || column.width || self.style.cellWidth) * self.scale) + cellBorder;\n            }, 0) || 0;\n            if (self.isChildGrid) {\n                self.width = self.parentNode.offsetWidth;\n                self.height = self.parentNode.offsetHeight;\n            } else {\n                self.height = self.canvas.offsetHeight;\n                self.width = self.canvas.offsetWidth;\n                self.canvas.width = self.width * ratio;\n                self.canvas.height = self.height * ratio;\n                self.ctx.scale(ratio, ratio);\n                self.canvasOffsetLeft = self.args.canvasOffsetLeft || 0;\n                self.canvasOffsetTop = self.args.canvasOffsetTop || 0;\n            }\n            if (self.attributes.showNewRow) {\n                scrollHeight += ch + cellBorder;\n            }\n            self.scrollBox.width = self.width - rowHeaderCellWidth;\n            self.scrollBox.height = self.height - columnHeaderCellHeight - columnHeaderCellBorder;\n            self.scrollBox.top = columnHeaderCellHeight + columnHeaderCellBorder;\n            self.scrollBox.left = rowHeaderCellWidth;\n            self.scrollBox.scrollHeight = scrollHeight + self.style.scrollBarWidth - self.scrollBox.height;\n            self.scrollBox.scrollWidth = scrollWidth + self.style.scrollBarWidth - self.scrollBox.width;\n            self.scrollBox.widthBoxRatio = ((self.scrollBox.width - scrollDragPositionOffsetX)\n                / (self.scrollBox.scrollWidth + self.scrollBox.width - scrollDragPositionOffsetX));\n            self.scrollBox.scrollBoxWidth = self.scrollBox.width\n                * self.scrollBox.widthBoxRatio\n                - self.style.scrollBarWidth;\n            self.scrollBox.heightBoxRatio = ((self.scrollBox.height - scrollDragPositionOffsetY)\n                / (self.scrollBox.scrollHeight + (self.scrollBox.height - scrollDragPositionOffsetY)));\n            self.scrollBox.scrollBoxHeight = self.scrollBox.height\n                * self.scrollBox.heightBoxRatio\n                - self.style.scrollBarWidth;\n            self.scrollBox.scrollBoxWidth = Math.max(self.scrollBox.scrollBoxWidth, self.style.scrollBarBoxMinSize);\n            self.scrollBox.scrollBoxHeight = Math.max(self.scrollBox.scrollBoxHeight, self.style.scrollBarBoxMinSize);\n            self.page = self.visibleRows.length - 3 - self.attributes.pageUpDownOverlap;\n            self.resizeEditInput();\n            self.scroll(true);\n            if (drawAfterResize) {\n                self.draw(true);\n            }\n            self.dispatchEvent('resize', {});\n            return true;\n        };\n        self.scroll = function (dontDraw) {\n            var bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                s = self.getVisibleSchema(),\n                cellBorder = self.style.cellBorderWidth * bm,\n                ch = self.style.cellHeight;\n            self.scrollIndexTop = 0;\n            self.scrollPixelTop = 0;\n            self.scrollIndexLeft = 0;\n            self.scrollPixelLeft = 0;\n            while (self.scrollPixelTop < self.scrollBox.scrollTop && self.scrollIndexTop < self.data.length) {\n                self.scrollPixelTop +=\n                    (((self.sizes.rows[self.data[self.scrollIndexTop][self.uniqueId]] || ch)\n                        + (self.sizes.trees[self.data[self.scrollIndexTop][self.uniqueId]] || 0)) * self.scale)\n                    + cellBorder;\n                self.scrollIndexTop += 1;\n            }\n            while (self.scrollPixelLeft < self.scrollBox.scrollLeft && self.scrollIndexLeft < s.length) {\n                self.scrollPixelLeft +=\n                    ((self.sizes.columns[s[self.scrollIndexLeft][self.uniqueId]]\n                        || s[self.scrollIndexLeft].width\n                        || self.style.cellWidth) * self.scale)\n                    + cellBorder;\n                self.scrollIndexLeft += 1;\n            }\n            if (self.data.length > 0) {\n                self.scrollIndexLeft = Math.max(self.scrollIndexLeft - 1, 0);\n                self.scrollPixelLeft = Math.max(self.scrollPixelLeft\n                    - ((self.sizes.columns[s[self.scrollIndexLeft][self.uniqueId]] || s[self.scrollIndexLeft].width || self.style.cellWidth) * self.scale), 0);\n                self.scrollIndexTop = Math.max(self.scrollIndexTop - 1, 0);\n                self.scrollPixelTop = Math.max((self.scrollPixelTop\n                    - ((self.sizes.rows[self.data[self.scrollIndexTop][self.uniqueId]] || ch)\n                    + (self.sizes.trees[self.data[self.scrollIndexTop][self.uniqueId]] || 0)) * self.scale), 0);\n            }\n            self.ellipsisCache = {};\n            if (!dontDraw) {\n                self.draw(true);\n            }\n            //TODO: figure out why this has to be delayed for child grids\n            //BUG: wheeling event on 3rd level hierarchy fails to move input box\n            requestAnimationFrame(self.resizeEditInput);\n            self.dispatchEvent('scroll', {top: self.scrollBox.scrollTop, left: self.scrollBox.scrollLeft});\n        };\n        self.mousemove = function (e, overridePos) {\n            if (self.contextMenu || self.input) {\n                return;\n            }\n            self.mouse = overridePos || self.getLayerPos(e);\n            var ctrl = (e.ctrlKey || e.metaKey || self.attributes.persistantSelectionMode),\n                i,\n                vs = self.getVisibleSchema(),\n                dragBounds,\n                sBounds,\n                x = self.mouse.x,\n                y = self.mouse.y,\n                o = self.getCellAt(x, y),\n                delta,\n                ev = {NativeEvent: e, cell: o, x: x, y: y},\n                previousCell = self.currentCell;\n            clearTimeout(self.scrollTimer);\n            if (!self.isInGrid({x: x, y: y})) {\n                self.hasFocus = false;\n            }\n            if (self.dispatchEvent('mousemove', ev)) {\n                return;\n            }\n            if (o && self.currentCell) {\n                self.rowBoundaryCrossed = self.currentCell.rowIndex !== o.rowIndex;\n                self.columnBoundaryCrossed = self.currentCell.columnIndex !== o.columnIndex;\n                self.cellBoundaryCrossed = self.rowBoundaryCrossed || self.columnBoundaryCrossed;\n                ['row', 'column', 'cell'].forEach(function (prefix) {\n                    if (self[prefix + 'BoundaryCrossed']) {\n                        ev.cell = previousCell;\n                        self.dispatchEvent(prefix + 'mouseout', ev);\n                        ev.cell = o;\n                        self.dispatchEvent(prefix + 'mouseover', ev);\n                    }\n                });\n            }\n            self.currentCell = o;\n            if (!self.hasFocus) {\n                return;\n            }\n            self.hovers = {};\n            if (!self.draggingItem\n                    && o\n                    && self.scrollModes.indexOf(o.context) === -1) {\n                self.dragItem = o;\n                self.dragMode = o.dragContext;\n                self.cursor = o.context;\n                if (o.context === 'cell' && o.data) {\n                    self.cursor = 'default';\n                    self.hovers[o.data[self.uniqueId]] = [o.columnIndex];\n                }\n                if ((self.selecting || self.reorderObject)\n                        && o.context === 'cell'\n                        && o.data) {\n                    sBounds = self.getSelectionBounds();\n                    delta = {\n                        x: Math.abs(self.dragStart.x - x),\n                        y: Math.abs(self.dragStart.y - y)\n                    };\n                    if (self.dragStartObject.columnIndex !== -1 && e.shiftKey) {\n                        self.dragStartObject = {\n                            rowIndex: self.activeCell.rowIndex,\n                            columnIndex: self.activeCell.columnIndex\n                        };\n                    }\n                    dragBounds = {\n                        top: Math.min(self.dragStartObject.rowIndex, o.rowIndex),\n                        left: Math.min(self.dragStartObject.columnIndex, o.columnIndex),\n                        bottom: Math.max(self.dragStartObject.rowIndex, o.rowIndex),\n                        right: Math.max(self.dragStartObject.columnIndex, o.columnIndex)\n                    };\n                    if (self.dragStartObject.columnIndex === -1) {\n                        dragBounds.left = -1;\n                        dragBounds.right = vs.length - 1;\n                        dragBounds.top = Math.min(sBounds.top, o.rowIndex);\n                        dragBounds.bottom = Math.max(sBounds.bottom, o.rowIndex);\n                    }\n                    if (self.dragStartObject.rowIndex !== o.rowIndex\n                                || self.dragStartObject.columnIndex !== o.columnIndex) {\n                        self.ignoreNextClick = true;\n                    }\n                    if (self.cellBoundaryCrossed || (delta.x === 0 && delta.y === 0) || (self.attributes.selectionMode === 'row')) {\n                        if (((self.attributes.selectionMode === 'row') || self.dragStartObject.columnIndex === -1)\n                                && self.rowBoundaryCrossed) {\n                            self.selectRow(o.rowIndex, ctrl, null, true);\n                        } else if (self.attributes.selectionMode !== 'row') {\n                            if (!self.dragAddToSelection && o.rowIndex !== undefined) {\n                                if (self.selections[o.rowIndex] && self.selections[o.rowIndex].indexOf(o.columnIndex) !== -1) {\n                                    self.selections[o.rowIndex].splice(self.selections[o.rowIndex].indexOf(o.columnIndex), 1);\n                                }\n                            } else {\n                                self.selections[o.rowIndex] = self.selections[o.rowIndex] || [];\n                                if (self.selections[o.rowIndex].indexOf(o.columnIndex) === -1) {\n                                    self.selections[o.rowIndex].push(o.columnIndex);\n                                }\n                            }\n                        }\n                    }\n                    if ((!self.selectionBounds || (dragBounds.top !== self.selectionBounds.top\n                            || dragBounds.left !== self.selectionBounds.left\n                            || dragBounds.bottom !== self.selectionBounds.bottom\n                            || dragBounds.right !== self.selectionBounds.right)) && !ctrl) {\n                        self.selections = [];\n                        sBounds = dragBounds;\n                        if (self.attributes.selectionMode === 'row') {\n                            for (i = sBounds.top; i <= sBounds.bottom; i += 1) {\n                                self.selectRow(i, true, null, true);\n                            }\n                        } else if (dragBounds.top !== -1) {\n                            self.selectArea(sBounds, true);\n                        }\n                    }\n                    self.autoScrollZone(e, x, y, ctrl);\n                }\n            }\n            self.cellBoundaryCrossed = false;\n            self.rowBoundaryCrossed = false;\n            self.columnBoundaryCrossed = false;\n            self.draw(true);\n        };\n        self.click = function (e, overridePos) {\n            var i,\n                ctrl = (e.ctrlKey || e.metaKey || self.attributes.persistantSelectionMode),\n                pos = overridePos || self.getLayerPos(e);\n            self.currentCell = self.getCellAt(pos.x, pos.y);\n            if (self.currentCell.grid !== undefined) {\n                return;\n            }\n            function checkSelectionChange() {\n                self.dispatchEvent('selectionchanged', {\n                    selectedData: self.getSelectedData(),\n                    selections: self.selections,\n                    selectionBounds: self.selectionBounds\n                });\n            }\n            if (self.input) {\n                self.endEdit();\n            }\n            if (self.ignoreNextClick) {\n                self.ignoreNextClick = false;\n                return;\n            }\n            i = self.currentCell;\n            if (self.dispatchEvent('click', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (['rowHeaderCell', 'columnHeaderCell'].indexOf(self.currentCell.style) === -1 && !ctrl) {\n                self.setActiveCell(i.columnIndex, i.rowIndex);\n            }\n            if (self.currentCell.context === 'cell') {\n                if (self.currentCell.style === 'cornerCell') {\n                    self.selectAll();\n                    self.draw();\n                    checkSelectionChange();\n                    return;\n                }\n                if (self.currentCell.style === 'columnHeaderCell') {\n                    if (self.attributes.columnHeaderClickBehavior === 'sort') {\n                        if (self.orderBy === i.header.name) {\n                            self.orderDirection = self.orderDirection === 'asc' ? 'desc' : 'asc';\n                        } else {\n                            self.orderDirection = 'asc';\n                        }\n                        self.order(i.header.name, self.orderDirection);\n                        checkSelectionChange();\n                        return;\n                    }\n                    if (self.attributes.columnHeaderClickBehavior === 'select') {\n                        self.selectColumn(i.header.index, ctrl, e.shiftKey, true);\n                        checkSelectionChange();\n                        self.draw();\n                        return;\n                    }\n                }\n                self.selections[i.rowIndex] = self.selections[i.rowIndex] || [];\n                if (((self.attributes.selectionMode === 'row') || self.currentCell.style === 'rowHeaderCell')) {\n                    if (self.currentCell.style === 'rowHeaderCell'\n                            && self.attributes.tree && pos.x > 0\n                            && pos.x - self.currentCell.x < self.style.treeArrowWidth\n                            + self.style.treeArrowMarginLeft\n                            + self.style.treeArrowMarginRight + self.style.treeArrowClickRadius\n                            && pos.y - self.currentCell.y < self.style.treeArrowHeight\n                            + self.style.treeArrowMarginTop + self.style.treeArrowClickRadius\n                            && pos.y > 0) {\n                        self.toggleTree(i.rowIndex);\n                        return;\n                    }\n                }\n                if (e.shiftKey && !ctrl) {\n                    self.selectionBounds = self.getSelectionBounds();\n                    self.selectArea(undefined, false);\n                }\n            }\n            checkSelectionChange();\n            self.draw(true);\n        };\n        self.dragResizeColumn = function (e) {\n            var pos, x, y;\n            pos = self.getLayerPos(e);\n            x = self.resizingStartingWidth + pos.x - self.dragStart.x;\n            y = self.resizingStartingHeight + pos.y - self.dragStart.y;\n            if (x < self.style.minColumnWidth) {\n                x = self.style.minColumnWidth;\n            }\n            if (y < self.style.minRowHeight) {\n                y = self.style.minRowHeight;\n            }\n            if (self.dispatchEvent('resizecolumn', {x: x, y: y, draggingItem: self.draggingItem})) { return false; }\n            if (self.scrollBox.scrollLeft > self.scrollBox.scrollWidth - self.attributes.resizeScrollZone\n                    && self.dragMode === 'ew-resize') {\n                self.resize(true);\n                self.scrollBox.scrollLeft += x;\n            }\n            if (self.dragMode === 'ew-resize') {\n                self.sizes.columns[self.draggingItem.header.style === 'rowHeaderCell'\n                       ? 'cornerCell' : self.draggingItem.header[self.uniqueId]] = x;\n                if (['rowHeaderCell', 'cornerCell'].indexOf(self.draggingItem.header.style) !== -1) {\n                    self.resize(true);\n                }\n                self.resizeChildGrids();\n                return;\n            }\n            if (self.dragMode === 'ns-resize') {\n                if (self.draggingItem.rowOpen) {\n                    self.sizes.trees[self.draggingItem.data[self.uniqueId]] = y;\n                } else if (self.attributes.globalRowResize) {\n                    self.style.cellHeight = y;\n                } else {\n                    self.sizes.rows[self.draggingItem.data[self.uniqueId]] = y;\n                }\n                self.dispatchEvent('resizerow', {row: y});\n                self.resizeChildGrids();\n                return;\n            }\n            self.ellipsisCache = {};\n        };\n        self.stopDragResize = function () {\n            self.resize();\n            document.body.removeEventListener('mousemove', self.dragResizeColumn, false);\n            document.body.removeEventListener('mouseup', self.stopDragResize, false);\n            self.setStorageData();\n            self.draw(true);\n            self.ignoreNextClick = true;\n        };\n        self.scrollGrid = function (e) {\n            var pos = self.getLayerPos(e);\n            if (self.attributes.scrollPointerLock && self.pointerLockPosition\n                    && ['horizontal-scroll-box', 'vertical-scroll-box'].indexOf(self.scrollStartMode) !== -1) {\n                self.pointerLockPosition.x += e.movementX;\n                self.pointerLockPosition.y += e.movementY;\n                self.pointerLockPosition.x = Math.min(self.width - self.style.scrollBarWidth, Math.max(0, self.pointerLockPosition.x));\n                self.pointerLockPosition.y = Math.min(self.height - self.style.scrollBarWidth, Math.max(0, self.pointerLockPosition.y));\n                pos = self.pointerLockPosition;\n            }\n            self.scrollMode = self.getCellAt(pos.x, pos.y).context;\n            if (self.scrollMode === 'horizontal-scroll-box' && self.scrollStartMode !== 'horizontal-scroll-box') {\n                self.scrollStartMode = 'horizontal-scroll-box';\n                self.dragStart = pos;\n                self.scrollStart.left = self.scrollBox.scrollLeft;\n                clearTimeout(self.scrollTimer);\n                return;\n            }\n            if (self.scrollMode === 'vertical-scroll-box' && self.scrollStartMode !== 'vertical-scroll-box') {\n                self.scrollStartMode = 'vertical-scroll-box';\n                self.dragStart = pos;\n                self.scrollStart.top = self.scrollBox.scrollTop;\n                clearTimeout(self.scrollTimer);\n                return;\n            }\n            if (self.scrollStartMode === 'vertical-scroll-box'\n                    && self.scrollMode !== 'vertical-scroll-box') {\n                self.scrollMode = 'vertical-scroll-box';\n            }\n            if (self.scrollStartMode === 'horizontal-scroll-box'\n                    && self.scrollMode !== 'horizontal-scroll-box') {\n                self.scrollMode = 'horizontal-scroll-box';\n            }\n            clearTimeout(self.scrollTimer);\n            if (self.scrollModes.indexOf(self.scrollMode) === -1) {\n                return;\n            }\n            if (self.scrollMode === 'vertical-scroll-box') {\n                self.scrollBox.scrollTop = self.scrollStart.top + ((pos.y - self.dragStart.y)\n                    / self.scrollBox.heightBoxRatio);\n            } else if (self.scrollMode === 'vertical-scroll-top') {\n                self.scrollBox.scrollTop -= (self.page * self.style.cellHeight);\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            } else if (self.scrollMode === 'vertical-scroll-bottom') {\n                self.scrollBox.scrollTop += (self.page * self.style.cellHeight);\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            }\n            if (self.scrollMode === 'horizontal-scroll-box') {\n                self.scrollBox.scrollLeft = self.scrollStart.left + ((pos.x - self.dragStart.x)\n                    / self.scrollBox.widthBoxRatio);\n            } else if (self.scrollMode === 'horizontal-scroll-right') {\n                self.scrollBox.scrollLeft += self.attributes.selectionScrollIncrement;\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            } else if (self.scrollMode === 'horizontal-scroll-left') {\n                self.scrollBox.scrollLeft -= self.attributes.selectionScrollIncrement;\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            }\n        };\n        self.stopScrollGrid = function () {\n            clearTimeout(self.scrollTimer);\n            if (document.exitPointerLock) {\n                document.exitPointerLock();\n            }\n            document.body.removeEventListener('mousemove', self.scrollGrid, false);\n        };\n        self.dragReorder = function (e) {\n            var pos, x, y;\n            pos = self.getLayerPos(e);\n            x = pos.x - self.dragStart.x;\n            y = pos.y - self.dragStart.y;\n            if (!self.attributes.allowColumnReordering && self.dragMode === 'column-reorder') {\n                return;\n            }\n            if (!self.attributes.allowRowReordering && self.dragMode === 'row-reorder') {\n                return;\n            }\n            if (self.dispatchEvent('reordering', {\n                    NativeEvent: e,\n                    source: self.dragStartObject,\n                    target: self.currentCell,\n                    dragMode: self.dragMode\n                })) {\n                return;\n            }\n            if (Math.abs(x) > self.attributes.reorderDeadZone || Math.abs(y) > self.attributes.reorderDeadZone) {\n                self.reorderObject = self.draggingItem;\n                self.reorderTarget = self.currentCell;\n                self.reorderObject.dragOffset = {\n                    x: x,\n                    y: y\n                };\n                self.autoScrollZone(e, pos.x, pos.y, false);\n            }\n        };\n        self.stopDragReorder = function (e) {\n            var oIndex,\n                tIndex,\n                cr = {\n                    'row-reorder': self.orders.rows,\n                    'column-reorder': self.orders.columns\n                },\n                i = {\n                    'row-reorder': 'rowIndex',\n                    'column-reorder': 'columnIndex'\n                }[self.dragMode];\n            document.body.removeEventListener('mousemove', self.dragReorder, false);\n            document.body.removeEventListener('mouseup', self.stopDragReorder, false);\n            if (self.reorderObject\n                    && self.reorderTarget\n                    && ((self.dragMode === 'column-reorder' && self.reorderTarget.columnIndex > -1\n                        && self.reorderTarget.columnIndex < self.getVisibleSchema().length)\n                    || (self.dragMode === 'row-reorder' && self.reorderTarget.rowIndex > -1\n                        && self.reorderTarget.rowIndex < self.data.length))\n                    && self.reorderObject[i] !== self.reorderTarget[i]\n                    && !self.dispatchEvent('reorder', {\n                        NativeEvent: e,\n                        source: self.reorderObject,\n                        target: self.reorderTarget,\n                        dragMode: self.dragMode\n                    })) {\n                self.ignoreNextClick = true;\n                oIndex = cr[self.dragMode].indexOf(self.reorderObject[i]);\n                tIndex = cr[self.dragMode].indexOf(self.reorderTarget[i]);\n                cr[self.dragMode].splice(oIndex, 1);\n                cr[self.dragMode].splice(tIndex, 0, self.reorderObject[i]);\n                self.setStorageData();\n            }\n            self.reorderObject = undefined;\n            self.reorderTarget = undefined;\n            self.draw(true);\n        };\n        self.dragMove = function (e) {\n            if (self.dispatchEvent('moving', {NativeEvent: e, cell: self.currentCell})) { return; }\n            var pos = self.getLayerPos(e);\n            self.moveOffset = {\n                x: self.currentCell.columnIndex - self.dragStartObject.columnIndex,\n                y: self.currentCell.rowIndex - self.dragStartObject.rowIndex\n            };\n            if (Math.abs(pos.x) > self.attributes.reorderDeadZone || Math.abs(pos.y) > self.attributes.reorderDeadZone) {\n                setTimeout(function () {\n                    self.autoScrollZone(e, pos.x, pos.y, false);\n                }, 1);\n            }\n        };\n        self.stopDragMove = function (e) {\n            document.body.removeEventListener('mousemove', self.dragMove, false);\n            document.body.removeEventListener('mouseup', self.stopDragMove, false);\n            var b = self.getSelectionBounds();\n            if (self.dispatchEvent('endmove', {NativeEvent: e, cell: self.currentCell})) {\n                self.movingSelection = undefined;\n                self.moveOffset = undefined;\n                self.draw(true);\n                return;\n            }\n            if (self.moveOffset) {\n                self.moveTo(self.movingSelection, b.left + self.moveOffset.x, b.top + self.moveOffset.y);\n                self.moveSelection(self.moveOffset.x, self.moveOffset.y);\n            }\n            self.movingSelection = undefined;\n            self.moveOffset = undefined;\n            self.draw(true);\n        };\n        self.freezeMove = function (e) {\n            if (self.dispatchEvent('freezemoving', {NativeEvent: e, cell: self.currentCell})) { return; }\n            var pos = self.getLayerPos(e);\n            self.ignoreNextClick = true;\n            self.freezeMarkerPosition = pos;\n            if (self.currentCell && self.currentCell.rowIndex !== undefined && self.dragMode === 'frozen-row-marker') {\n                self.scrollBox.scrollTop = 0;\n                self.frozenRow = self.currentCell.rowIndex + 1;\n            }\n            if (self.currentCell && self.currentCell.columnIndex !== undefined && self.dragMode === 'frozen-column-marker') {\n                self.scrollBox.scrollLeft = 0;\n                self.frozenColumn = self.currentCell.columnIndex + 1;\n            }\n            if (Math.abs(pos.x) > self.attributes.reorderDeadZone || Math.abs(pos.y) > self.attributes.reorderDeadZone) {\n                setTimeout(function () {\n                    self.autoScrollZone(e, pos.x, pos.y, false);\n                }, 1);\n            }\n        };\n        self.stopFreezeMove = function (e) {\n            document.body.removeEventListener('mousemove', self.freezeMove, false);\n            document.body.removeEventListener('mouseup', self.stopFreezeMove, false);\n            self.freezeMarkerPosition = undefined;\n            if (self.dispatchEvent('endfreezemove', {NativeEvent: e})) {\n                self.frozenRow = self.startFreezeMove.x;\n                self.frozenColumn = self.startFreezeMove.y;\n                self.draw(true);\n                return;\n            }\n            self.draw(true);\n        };\n        self.mousedown = function (e, overridePos) {\n            self.lastMouseDownTarget = e.target;\n            if (self.dispatchEvent('mousedown', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (e.button === 2 || self.input) { return; }\n            var ctrl = (e.ctrlKey || e.metaKey),\n                move = /-move/.test(self.dragMode),\n                freeze = /frozen-row-marker|frozen-column-marker/.test(self.dragMode),\n                resize = /-resize/.test(self.dragMode);\n            self.dragStart = overridePos || self.getLayerPos(e);\n            self.scrollStart = {\n                left: self.scrollBox.scrollLeft,\n                top: self.scrollBox.scrollTop\n            };\n            self.dragStartObject = self.getCellAt(self.dragStart.x, self.dragStart.y);\n            self.dragAddToSelection = !self.dragStartObject.selected;\n            if (!ctrl && !e.shiftKey && !/(vertical|horizontal)-scroll-(bar|box)/\n                    .test(self.dragStartObject.context)\n                    && self.currentCell\n                    && !self.currentCell.isColumnHeader\n                    && !move\n                    && !freeze\n                    && !resize) {\n                self.selections = [];\n            }\n            if (self.dragStartObject.isGrid) {\n                return;\n            }\n            if (self.scrollModes.indexOf(self.dragStartObject.context) !== -1) {\n                self.scrollMode = self.dragStartObject.context;\n                self.scrollStartMode = self.dragStartObject.context;\n                self.scrollGrid(e);\n                if (self.attributes.scrollPointerLock\n                        && ['horizontal-scroll-box', 'vertical-scroll-box'].indexOf(self.scrollStartMode) !== -1) {\n                    self.pointerLockPosition = {\n                        x: self.dragStart.x,\n                        y: self.dragStart.y\n                    };\n                    self.canvas.requestPointerLock();\n                }\n                document.body.addEventListener('mousemove', self.scrollGrid, false);\n                document.body.addEventListener('mouseup', self.stopScrollGrid, false);\n                self.ignoreNextClick = true;\n                return;\n            }\n            if (self.dragMode === 'cell') {\n                self.selecting = true;\n                if ((self.attributes.selectionMode === 'row' || self.dragStartObject.columnIndex === -1)\n                        && self.dragStartObject.rowIndex > -1) {\n                    self.selectRow(self.dragStartObject.rowIndex, ctrl, null, true);\n                } else if (self.attributes.selectionMode !== 'row') {\n                    self.mousemove(e);\n                }\n                return;\n            }\n            if (move) {\n                self.draggingItem = self.dragItem;\n                self.movingSelection = self.selections.concat([]);\n                self.dragging = self.dragStartObject;\n                if (self.dispatchEvent('beginmove', {NativeEvent: e, cell: self.currentCell})) { return; }\n                document.body.addEventListener('mousemove', self.dragMove, false);\n                document.body.addEventListener('mouseup', self.stopDragMove, false);\n                return self.mousemove(e);\n            }\n            if (freeze) {\n                self.draggingItem = self.dragItem;\n                self.startFreezeMove = {\n                    x: self.frozenRow,\n                    y: self.frozenColumn\n                };\n                if (self.dispatchEvent('beginfreezemove', {NativeEvent: e})) { return; }\n                document.body.addEventListener('mousemove', self.freezeMove, false);\n                document.body.addEventListener('mouseup', self.stopFreezeMove, false);\n                return self.mousemove(e);\n            }\n            if (resize) {\n                self.draggingItem = self.dragItem;\n                if (self.draggingItem.rowOpen) {\n                    self.resizingStartingHeight = self.sizes.trees[self.draggingItem.data[self.uniqueId]];\n                } else {\n                    self.resizingStartingHeight = self.sizes.rows[self.draggingItem.data[self.uniqueId]] || self.style.cellHeight;\n                }\n                self.resizingStartingWidth = self.sizes.columns[self.draggingItem.header.style === 'rowHeaderCell'\n                       ? 'cornerCell' : self.draggingItem.header[self.uniqueId]] || self.draggingItem.width;\n                document.body.addEventListener('mousemove', self.dragResizeColumn, false);\n                document.body.addEventListener('mouseup', self.stopDragResize, false);\n                return;\n            }\n            if (['row-reorder', 'column-reorder'].indexOf(self.dragMode) !== -1) {\n                self.draggingItem = self.dragStartObject;\n                document.body.addEventListener('mousemove', self.dragReorder, false);\n                document.body.addEventListener('mouseup', self.stopDragReorder, false);\n                return;\n            }\n        };\n        self.mouseup = function (e) {\n            clearTimeout(self.scrollTimer);\n            self.cellBoundaryCrossed = true;\n            self.rowBoundaryCrossed = true;\n            self.columnBoundaryCrossed = true;\n            self.selecting = undefined;\n            self.draggingItem = undefined;\n            self.dragStartObject = undefined;\n            if (self.dispatchEvent('mouseup', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus && e.target !== self.canvas) {\n                return;\n            }\n            if (self.currentCell && self.currentCell.grid !== undefined) {\n                return;\n            }\n            if (self.contextMenu || self.input) { return; }\n            if (self.dragStart && self.isInGrid(self.dragStart)) {\n                self.controlInput.focus();\n            }\n            e.preventDefault();\n        };\n        self.keydown = function (e) {\n            var i,\n                x = self.activeCell.columnIndex,\n                y = self.activeCell.rowIndex,\n                ctrl = (e.ctrlKey || e.metaKey),\n                last = self.data.length - 1,\n                cols = self.getVisibleSchema().length - 1;\n            if (self.dispatchEvent('keydown', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            self.page = self.visibleRows.length - 3 - self.attributes.pageUpDownOverlap;\n            if (self.attributes.showNewRow) {\n                last += 1;\n            }\n            if (e.keyCode === 9) {\n                e.preventDefault();\n            }\n            // esc\n            if (e.keyCode === 27) {\n                self.selections = [];\n                self.draw(true);\n            // ctrl + a\n            } else if (ctrl && e.keyCode === 65) {\n                self.selectAll();\n            //ArrowDown\n            } else if (e.keyCode === 40) {\n                y += 1;\n            //ArrowUp\n            } else if (e.keyCode === 38) {\n                y -= 1;\n            //ArrowLeft Tab\n            } else if (e.keyCode === 37 || (e.shiftKey && e.keyCode === 9)) {\n                x -= 1;\n            //ArrowRight Tab\n            } else if (e.keyCode === 39 || (!e.shiftKey && e.keyCode === 9)) {\n                x += 1;\n            //PageUp\n            } else if (e.keyCode === 33) {\n                y -= self.page;\n                e.preventDefault();\n            //PageDown\n            } else if (e.keyCode === 34) {\n                y += self.page;\n                e.preventDefault();\n            //Home ArrowUp\n            } else if (e.keyCode === 36 || (ctrl && e.keyCode === 38)) {\n                y = 0;\n            //End ArrowDown\n            } else if (e.keyCode === 35 || (ctrl && e.keyCode === 40)) {\n                y = self.data.length - 1;\n            //ArrowRight\n            } else if (ctrl && e.keyCode === 39) {\n                x = cols;\n            //ArrowLeft\n            } else if (ctrl && e.keyCode === 37) {\n                x = 0;\n            }\n            //Enter\n            if (e.keyCode === 13) {\n                return self.beginEditAt(x, y);\n            }\n            //Space\n            if (e.keyCode === 32) {\n                self.selections = [];\n                self.selections[Math.max(y, 0)] = [];\n                self.selections[Math.max(y, 0)].push(x);\n                self.selectionBounds = self.getSelectionBounds();\n                if (self.attributes.selectionMode === 'row') {\n                    for (i = self.selectionBounds.top; i <= self.selectionBounds.bottom; i += 1) {\n                        self.selectRow(i, ctrl, null, true);\n                    }\n                } else {\n                    self.selectArea(undefined, ctrl);\n                }\n                e.preventDefault();\n                self.draw(true);\n                return;\n            }\n            if (x < 0) {\n                x = 0;\n            }\n            if (y > last) {\n                y = last;\n            }\n            if (y < 0) {\n                y = 0;\n            }\n            if (x > cols) {\n                x = cols;\n            }\n            // Arrows\n            if (e.shiftKey && [37, 38, 39, 40].indexOf(e.keyCode) !== -1) {\n                self.selections[Math.max(y, 0)] = self.selections[Math.max(y, 0)] || [];\n                self.selections[Math.max(y, 0)].push(x);\n                self.selectionBounds = self.getSelectionBounds();\n                self.selectArea(undefined, ctrl);\n                self.draw(true);\n            }\n            if (x !== self.activeCell.columnIndex || y !== self.activeCell.rowIndex) {\n                self.scrollIntoView(x !== self.activeCell.columnIndex ? x : undefined, y !== self.activeCell.rowIndex ? y : undefined);\n                self.setActiveCell(x, y);\n                if (!e.shiftKey && self.attributes.selectionFollowsActiveCell) {\n                    if (!ctrl) {\n                        self.selections = [];\n                    }\n                    self.selections[y] = self.selections[y] || [];\n                    self.selections[y].push(x);\n                    self.dispatchEvent('selectionchanged', {\n                        selectedData: self.getSelectedData(),\n                        selections: self.selections,\n                        selectionBounds: self.selectionBounds\n                    });\n                }\n                self.draw(true);\n            }\n        };\n        self.keyup = function (e) {\n            if (self.dispatchEvent('keyup', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n        };\n        self.keypress = function (e) {\n            if (!self.hasFocus) {\n                return;\n            }\n            if (self.dispatchEvent('keypress', {NativeEvent: e, cell: self.currentCell})) { return; }\n        };\n        self.dblclick = function (e) {\n            if (self.dispatchEvent('dblclick', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (self.currentCell.context === 'ew-resize'\n                    && self.currentCell.style === 'columnHeaderCell') {\n                self.fitColumnToValues(self.currentCell.header.name);\n            } else if (self.currentCell.context === 'ew-resize'\n                    && self.currentCell.style === 'cornerCell') {\n                self.autosize();\n            } else if (['cell', 'activeCell'].indexOf(self.currentCell.style) !== -1) {\n                self.beginEditAt(self.currentCell.columnIndex, self.currentCell.rowIndex);\n            }\n        };\n        self.scrollWheel = function (e) {\n            var l,\n                t,\n                deltaX = e.deltaX === undefined ? e.NativeEvent.deltaX : e.deltaX,\n                deltaY = e.deltaY === undefined ? e.NativeEvent.deltaY : e.deltaY,\n                deltaMode = e.deltaMode === undefined ? e.NativeEvent.deltaMode : e.deltaMode;\n            if (wheeling) {\n                return;\n            }\n            if (self.dispatchEvent('wheel', {NativeEvent: e})) {\n                return;\n            }\n            e = e.NativeEvent || e;\n            self.touchHaltAnimation = true;\n            l = self.scrollBox.scrollLeft;\n            t = self.scrollBox.scrollTop;\n            if (self.hasFocus) {\n                //BUG Issue 42: https://github.com/TonyGermaneri/canvas-datagrid/issues/42\n                //https://stackoverflow.com/questions/20110224/what-is-the-height-of-a-line-in-a-wheel-event-deltamode-dom-delta-line\n                if (deltaMode === 1) {\n                    // line mode = 17 pixels per line\n                    deltaY = deltaY * 17;\n                }\n                if ((self.scrollBox.scrollTop < self.scrollBox.scrollHeight && deltaY > 0)\n                        || (self.scrollBox.scrollLeft < self.scrollBox.scrollWidth && deltaX > 0)\n                        || (self.scrollBox.scrollTop > 0 && deltaY < 0)\n                        || (self.scrollBox.scrollLeft > 0 && deltaX < 0)) {\n                    e.preventDefault(e);\n                }\n                wheeling = setTimeout(function () {\n                    wheeling = undefined;\n                    self.scrollBox.scrollTo(deltaX + l, deltaY + t);\n                }, 1);\n            }\n        };\n        self.pasteItem = function (clipData, x, y, mimeType) {\n            var l, s = self.getVisibleSchema(), yi = y - 1, sel = [];\n            function normalizeRowData(importingRow, existingRow, offsetX, schema, mimeType, rowIndex) {\n                var r = existingRow;\n                if (!Array.isArray(importingRow) && importingRow !== null && typeof importingRow === 'object') {\n                    importingRow = Object.keys(importingRow).map(function (colKey) {\n                        return importingRow[colKey];\n                    });\n                }\n                if (/^text\\/html/.test(mimeType)) {\n                    importingRow = importingRow.substring(4, importingRow.length - 5).split('</td><td>');\n                }\n                if (typeof importingRow === 'string') {\n                    importingRow = [importingRow];\n                }\n                sel[rowIndex] = [];\n                importingRow.forEach(function (cellData, colIndex) {\n                    var cName = schema[colIndex + offsetX].name;\n                    if (importingRow[colIndex] === undefined || importingRow[colIndex] === null) {\n                        r[cName] = existingRow[cName];\n                        return;\n                    }\n                    sel[rowIndex].push(colIndex + offsetX);\n                    r[cName] = importingRow[colIndex];\n                });\n                return r;\n            }\n            if (/^text\\/html/.test(mimeType)) {\n                if (!/^(<meta[^>]+>)?<table>/.test(clipData.substring(0, 29))) {\n                    console.warn('Unrecognized HTML format.  HTML must be a simple table, e.g.: <table><tr><td>data</td></tr></table>.  Data with the mime type text/html not in this format will not be imported as row data.');\n                    return;\n                }\n                // strip table beginning and ending off, then split at rows\n                clipData = clipData.substring(clipData.indexOf('<table><tr>') + 11, clipData.length - 13).split('</tr><tr>');\n            } else {\n                clipData = clipData.split('\\n');\n            }\n            l = clipData.length;\n            clipData.forEach(function (rowData) {\n                yi += 1;\n                self.data[yi] = normalizeRowData(rowData, self.data[yi], x, s, mimeType, yi);\n            });\n            self.selections = sel;\n            return l;\n        };\n        self.paste = function (e) {\n            var d;\n            function getItem(dti) {\n                var type = dti.type;\n                dti.getAsString(function (s) {\n                    self.pasteItem(s, self.activeCell.columnIndex, self.activeCell.rowIndex, type);\n                    self.draw();\n                });\n            }\n            d = Array.prototype.filter.call(e.clipboardData.items, function (dti) {\n                return dti.type === 'text/html';\n            })[0] || Array.prototype.filter(function (dti) {\n                return dti.type === 'text/csv';\n            })[0] || Array.prototype.filter(function (dti) {\n                return dti.type === 'text/plain';\n            })[0];\n            if (!d) {\n                console.warn('Cannot find supported clipboard data type.  Supported types are text/html, text/csv, text/plain.');\n                return;\n            }\n            getItem(d);\n        };\n        self.cut = function (e) {\n            self.copy(e);\n            self.forEachSelectedCell(function (data, index, colName) {\n                data[index][colName] = '';\n            });\n        };\n        self.copy = function (e) {\n            if (self.dispatchEvent('copy', {NativeEvent: e})) { return; }\n            if (!self.hasFocus || !e.clipboardData) { return; }\n            var t,\n                d,\n                rows = [],\n                trows = [],\n                sData = self.getSelectedData();\n            function fCopyCell(d) {\n                d = d === null || d === undefined ? '' : d;\n                return '<td>' + (typeof d === 'string' ? d.replace(/</g, '&lt;').replace(/>/g, '&gt;') : d) + '</td>';\n            }\n            if (sData.length > 0) {\n                sData.forEach(function (row) {\n                    if (row) {\n                        // r = array for HTML, rt = array for plain text\n                        var r = [],\n                            rt = [];\n                        Object.keys(row).forEach(function (key) {\n                            // escape strings\n                            if (row[key] !== null\n                                    && row[key] !== false\n                                    && row[key] !== undefined\n                                    && row[key].replace) {\n                                rt.push('\"' + row[key].replace(/\"/g, '\"\"') + '\"');\n                                r.push(fCopyCell(row[key]));\n                                return;\n                            }\n                            rt.push(row[key]);\n                            r.push(fCopyCell(row[key]));\n                        });\n                        rows.push(r.join(''));\n                        trows.push(rt.join(','));\n                    }\n                });\n                d = '<table><tr>' + rows.join('</tr><tr>') + '</tr></table>';\n                t = trows.join('\\n');\n                e.clipboardData.setData('text/html', d);\n                e.clipboardData.setData('text/plain', t);\n                e.clipboardData.setData('text/csv', t);\n                e.preventDefault();\n            }\n        };\n        return;\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true, plusplus: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        var touchTimerMs = 50,\n            touchScrollTimeout;\n        self.scrollAnimation = {};\n        self.touchDelta = {};\n        self.touchAnimateTo = {};\n        self.animationFrames = 0;\n        self.getTouchPos = function (e, touchIndex) {\n            var t = touchIndex ? e.touches[touchIndex] : e.touches[0],\n                rect = self.canvas.getBoundingClientRect(),\n                pos;\n            if (!t) { return; }\n            pos = {\n                x: t.clientX - rect.left,\n                y: t.clientY - rect.top\n            };\n            if (self.isChildGrid) {\n                pos.x -= self.canvasOffsetLeft;\n                pos.y -= self.canvasOffsetTop;\n            }\n            return {\n                x: pos.x,\n                y: pos.y,\n                rect: rect\n            };\n        };\n        // shamelessly stolen from from https://gist.github.com/gre/1650294\n        self.easingFunctions = {\n            linear: function (t) { return t; },\n            easeInQuad: function (t) { return t * t; },\n            easeOutQuad: function (t) { return t * (2 - t); },\n            easeInOutQuad: function (t) { return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t; },\n            easeInCubic: function (t) { return t * t * t; },\n            easeOutCubic: function (t) { return (--t) * t * t + 1; },\n            easeInOutCubic: function (t) { return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1; },\n            easeInQuart: function (t) { return t * t * t * t; },\n            easeOutQuart: function (t) { return 1 - (--t) * t * t * t; },\n            easeInOutQuart: function (t) { return t < 0.5 ? 8 * t  * t  * t * t : 1 - 8 * (--t) * t * t * t; },\n            easeInQuint: function (t) { return t * t * t * t * t; },\n            easeOutQuint: function (t) { return 1 + (--t) * t *  t * t * t; },\n            easeInOutQuint: function (t) { return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t; }\n        };\n        self.easing = function (t, b, c, d) {\n            return c * self.easingFunctions[self.attributes.touchEasingMethod](t / d) + b;\n        };\n        self.calculatePPSTimed = function () {\n            self.xPPST = -((self.touchDelta.x - self.touchSigmaTimed.x) / (self.touchDelta.t - self.touchSigmaTimed.t));\n            self.yPPST = -((self.touchDelta.y - self.touchSigmaTimed.y) / (self.touchDelta.t - self.touchSigmaTimed.t));\n            self.touchSigmaTimed = {\n                x: self.touchDelta.x,\n                y: self.touchDelta.y,\n                t: performance.now()\n            };\n        };\n        self.calculatePPS = function () {\n            self.xPPS = -((self.touchDelta.x - self.touchSigma.x) / (self.touchDelta.t - self.touchSigma.t));\n            self.yPPS = -((self.touchDelta.y - self.touchSigma.y) / (self.touchDelta.t - self.touchSigma.t));\n            self.touchSigma = {\n                x: self.touchDelta.x,\n                y: self.touchDelta.y,\n                t: performance.now()\n            };\n        };\n        self.touchEndAnimation = function () {\n            if (!self.canvas || !self.scrollBox.scrollTo) { return requestAnimationFrame(self.touchEndAnimation); }\n            var n = performance.now(),\n                d = self.attributes.touchReleaseAnimationDurationMs,\n                t;\n            t = n - self.touchDelta.t;\n            self.animationFrames += 1;\n            self.scrollAnimation.x = self.easing(t, self.touchDelta.scrollLeft, self.touchAnimateTo.x, d);\n            self.scrollAnimation.y = self.easing(t, self.touchDelta.scrollTop, self.touchAnimateTo.y, d);\n            if (t > d || (self.scrollAnimation.y === self.scrollBox.scrollTop\n                    && self.scrollAnimation.x === self.scrollBox.scrollLeft) || self.stopAnimation) {\n                return;\n            }\n            self.scrollBox.scrollTo(self.scrollAnimation.x, self.scrollAnimation.y);\n            requestAnimationFrame(self.touchEndAnimation);\n        };\n        self.touchEditCell = function (cell) {\n            self.beginEditAt(cell.columnIndex, cell.rowIndex);\n        };\n        self.touchCell = function (e) {\n            return function () {\n                clearInterval(self.calculatePPSTimer);\n                var i, pos = self.getTouchPos(e);\n                if (Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) < self.attributes.touchDeadZone) {\n                    i = self.getCellAt(pos.x, pos.y);\n                    if (!i) { return; }\n                    if (self.touchingCell && self.touchingCell.rowIndex === i.rowIndex\n                            && self.touchingCell.columnIndex === i.columnIndex) {\n                        self.touchEditCell(i);\n                        return;\n                    }\n                    if (self.input && self.input.editCell) {\n                        self.endEdit();\n                    }\n                    self.touchingCell = i;\n                    self.selectArea({\n                        top: i.rowIndex,\n                        bottom: i.rowIndex,\n                        left: i.columnIndex,\n                        right: i.columnIndex\n                    });\n                    self.draw(true);\n                }\n            };\n        };\n        self.touchstart = function (e) {\n            if (e.changedTouches[0]) {\n                self.touchStart = self.getTouchPos(e);\n                self.startingCell = self.getCellAt(self.touchStart.x, self.touchStart.y, true);\n            }\n            if (self.dispatchEvent('touchstart', {NativeEvent: e, cell: self.startingCell})) { return; }\n            self.disposeContextMenu();\n            clearInterval(self.calculatePPSTimer);\n            clearTimeout(self.touchContextTimeout);\n            self.touchStartEvent = e;\n            self.stopAnimation = true;\n            self.animationFrames = 0;\n            self.stopPropagation(e);\n            e.preventDefault();\n            if (e.touches.length === 1 && e.changedTouches[0] && !self.zoomAltered) {\n                self.touchLength = 1;\n                self.touchStart = self.touchStart || self.touchStart1;\n                self.touchScrollStart = {\n                    x: self.scrollBox.scrollLeft,\n                    y: self.scrollBox.scrollTop,\n                    t: performance.now()\n                };\n                self.touchDelta = {\n                    x: 0,\n                    y: 0,\n                    scrollLeft: self.scrollBox.scrollLeft,\n                    scrollTop: self.scrollBox.scrollTop,\n                    t: self.touchScrollStart.t\n                };\n                self.touchSigma = {\n                    x: self.touchDelta.x,\n                    y: self.touchDelta.y,\n                    t: self.touchDelta.t\n                };\n                self.touchSigmaTimed = {\n                    x: self.touchDelta.x,\n                    y: self.touchDelta.y,\n                    t: self.touchDelta.t\n                };\n                self.touchContextTimeout = setTimeout(function () {\n                    self.contextmenuEvent(e, self.touchStart);\n                }, self.attributes.touchContextMenuTimeMs);\n                self.calculatePPSTimer = setInterval(self.calculatePPSTimed, touchTimerMs);\n                if (self.startingCell && (self.startingCell.isGrid || ['tree', 'inherit'].indexOf(self.startingCell.context) !== -1)) {\n                    self.hasFocus = false;\n                    return;\n                }\n                self.hasFocus = true;\n                if (self.startingCell.isHeader) {\n                    if (self.startingCell.isRowHeader) {\n                        self.selectArea({\n                            top: self.startingCell.rowIndex,\n                            bottom: self.startingCell.rowIndex,\n                            left: 0,\n                            right: self.getVisibleSchema().length - 1,\n                        });\n                        self.draw(true);\n                    } else if (self.startingCell.isColumnHeader) {\n                        if (self.attributes.columnHeaderClickBehavior === 'sort') {\n                            if (self.orderBy === self.startingCell.header.name) {\n                                self.orderDirection = self.orderDirection === 'asc' ? 'desc' : 'asc';\n                            } else {\n                                self.orderDirection = 'asc';\n                            }\n                            self.order(self.startingCell.header.name, self.orderDirection);\n                        }\n                        if (self.attributes.columnHeaderClickBehavior === 'select') {\n                            self.selectArea({\n                                top: 0,\n                                bottom: self.data.length - 1,\n                                left: self.startingCell.columnIndex,\n                                right: self.startingCell.columnIndex,\n                            });\n                            self.draw(true);\n                        }\n                    }\n                    self.touchEndEvents(e);\n                    return;\n                }\n            }\n            if (self.zoomAltered) { return; }\n            document.body.addEventListener('touchmove', self.touchmove, {passive: false});\n            document.body.addEventListener('touchend', self.touchend, false);\n            document.body.addEventListener('touchcancel', self.touchcancel, false);\n            self.draw(true);\n        };\n        self.touchSelect = function (cell, handleType) {\n            if (cell.rowIndex === undefined || cell.columnIndex === undefined) { return; }\n            self.touchSelecting = true;\n            var bounds = self.getSelectionBounds();\n            if (handleType === 'selection-handle-bl'\n                    && cell.rowIndex >= bounds.top\n                    && cell.columnIndex <= bounds.right) {\n                bounds.bottom = cell.rowIndex;\n                bounds.left = cell.columnIndex;\n            } else if (handleType === 'selection-handle-tl'\n                    && cell.rowIndex <= bounds.bottom\n                    && cell.columnIndex <= bounds.right) {\n                bounds.top = cell.rowIndex;\n                bounds.left = cell.columnIndex;\n            } else if (handleType === 'selection-handle-tr'\n                    && cell.rowIndex <= bounds.bottom\n                    && cell.columnIndex >= bounds.left) {\n                bounds.top = cell.rowIndex;\n                bounds.right = cell.columnIndex;\n            } else if (handleType === 'selection-handle-br'\n                    && cell.rowIndex >= bounds.top\n                    && cell.columnIndex >= bounds.left) {\n                bounds.bottom = cell.rowIndex;\n                bounds.right = cell.columnIndex;\n            }\n            if (self.attributes.selectionMode === 'row' || cell.rowIndex === -1) {\n                bounds.left = 0;\n                bounds.right = self.getSchema().length - 1;\n            } else {\n                bounds.left = Math.max(0, bounds.left);\n            }\n            self.selectArea(bounds);\n            self.draw(true);\n        };\n        self.touchmove = function (e) {\n            var ch, rw, rScrollZone, lScrollZone, bScrollZone, tScrollZone, sbw, t1, t2;\n            if (self.dispatchEvent('beforetouchmove', {NativeEvent: e})) { return; }\n            clearTimeout(touchScrollTimeout);\n            if (e.changedTouches[0]) {\n                self.touchPosition = self.getTouchPos(e);\n            }\n            if (e.changedTouches[1]) {\n                self.touchPosition1 = self.getTouchPos(e, 1);\n            }\n            if (Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) > self.attributes.touchDeadZone) {\n                clearTimeout(self.touchContextTimeout);\n            }\n            if (e.touches.length === 2 && self.touchPosition && self.touchPosition1) {\n                t1 = self.touchPosition.y;\n                t2 = self.touchPosition1.y;\n                if (!self.zoomDeltaStart) {\n                    self.zoomDeltaStart = Math.abs(t1 - t2);\n                    self.startScale = self.scale;\n                }\n                self.touchLength = 2;\n                self.scaleDelta = self.zoomDeltaStart - Math.abs(t1 - t2);\n                self.scale = self.startScale - (self.scaleDelta * self.attributes.touchZoomSensitivity);\n                self.scale = Math.min(Math.max(self.scale, self.attributes.touchZoomMin), self.attributes.touchZoomMax);\n                self.zoomAltered = true;\n                self.resize(true);\n                self.resizeChildGrids();\n                return;\n            }\n            if (self.zoomAltered) { return; }\n            self.touchLength = 1;\n            self.touchPosition = self.touchPosition || self.touchPosition1;\n            ch = self.getColumnHeaderCellHeight();\n            rw = self.getRowHeaderCellWidth();\n            rScrollZone = self.width - self.style.scrollBarWidth - self.touchPosition.x < self.attributes.selectionScrollZone;\n            lScrollZone = self.touchPosition.x - rw < self.attributes.selectionScrollZone;\n            bScrollZone = self.height - self.style.scrollBarWidth - self.touchPosition.y < self.attributes.selectionScrollZone;\n            tScrollZone = self.touchPosition.y - ch < self.attributes.selectionScrollZone;\n            sbw = self.style.scrollBarWidth;\n            function touchScroll() {\n                var x = self.scrollBox.scrollLeft,\n                    y = self.scrollBox.scrollTop;\n                x += (rScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                y += (bScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                y -= (tScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                x -= (lScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                self.scrollBox.scrollTo(x, y);\n                touchScrollTimeout = setTimeout(touchScroll, self.attributes.scrollRepeatRate);\n            }\n            e.stopPropagation();\n            self.touchDelta = {\n                x: self.touchPosition.x - self.touchStart.x,\n                y: self.touchPosition.y - self.touchStart.y,\n                scrollLeft: self.scrollBox.scrollLeft,\n                scrollTop: self.scrollBox.scrollTop,\n                t: performance.now()\n            };\n            self.currentCell = self.getCellAt(self.touchPosition.x, self.touchPosition.y);\n            self.dispatchEvent('touchmove', {NativeEvent: e, cell: self.currentCell});\n            self.calculatePPS();\n            self.touchDuration = performance.now() - self.touchScrollStart.t;\n            self.stopAnimation = true;\n            self.animationFrames = 0;\n            if (self.touchSelecting && (rScrollZone || lScrollZone || tScrollZone || bScrollZone)) {\n                touchScroll();\n            }\n            if (/vertical-scroll-/.test(self.startingCell.style)) {\n                self.scrollBox.scrollTop = self.scrollBox.scrollHeight\n                    * ((self.touchPosition.y - ch - sbw) / (self.scrollBox.height - sbw - ch));\n                return;\n            }\n            if (/horizontal-scroll-/.test(self.startingCell.style)) {\n                self.scrollBox.scrollLeft = self.scrollBox.scrollWidth\n                    * ((self.touchPosition.x - rw - sbw) / (self.scrollBox.width - sbw - rw));\n                return;\n            }\n            if (/selection-handle-/.test(self.startingCell.style)) {\n                self.touchSelect(self.currentCell, self.startingCell.style);\n                return;\n            }\n            self.scrollBox.scrollTo(self.touchScrollStart.x - self.touchDelta.x,\n                self.touchScrollStart.y - self.touchDelta.y);\n            self.draw(true);\n        };\n        self.touchEndEvents = function (e) {\n            self.zoomDeltaStart = undefined;\n            self.touchSelecting = false;\n            clearInterval(self.touchScrollTimeout);\n            clearInterval(self.touchContextTimeout);\n            clearInterval(self.calculatePPSTimer);\n            e.stopPropagation();\n            document.body.removeEventListener('touchmove', self.touchmove, {passive: false});\n            document.body.removeEventListener('touchend', self.touchend, false);\n            document.body.removeEventListener('touchcancel', self.touchcancel, false);\n        };\n        self.touchend = function (e) {\n            if (self.dispatchEvent('touchend', {NativeEvent: e, cell: self.currentCell})) { return; }\n            self.zoomDeltaStart = undefined;\n            if (e.changedTouches[0]) {\n                self.touchPosition = undefined;\n            }\n            if (e.changedTouches[1]) {\n                self.touchPosition1 = undefined;\n            }\n            if (self.zoomAltered) {\n                if (e.touches.length === 0) {\n                    self.zoomAltered = false;\n                }\n                return;\n            }\n            var dz = Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) < self.attributes.touchDeadZone;\n            if (isNaN(self.xPPS)) {\n                self.xPPS = 0;\n            }\n            if (isNaN(self.yPPS)) {\n                self.yPPS = 0;\n            }\n            if (isNaN(self.xPPST)) {\n                self.xPPST = 0;\n            }\n            if (isNaN(self.yPPST)) {\n                self.yPPST = 0;\n            }\n            self.touchAnimateTo.x = self.xPPS * self.attributes.touchReleaseAcceleration;\n            self.touchAnimateTo.y = self.yPPS * self.attributes.touchReleaseAcceleration;\n            self.calculatePPSTimed();\n            if (dz && !self.contextMenu) {\n                self.touchCell(self.touchStartEvent)();\n            } else if (self.animationFrames === 0\n                    && (Math.abs(self.xPPST) > self.attributes.scrollAnimationPPSThreshold\n                        || Math.abs(self.yPPST) > self.attributes.scrollAnimationPPSThreshold)\n                    && !/-scroll-/.test(self.startingCell.style)\n                    && !dz) {\n                self.stopAnimation = false;\n                self.touchEndAnimation();\n            }\n            self.touchEndEvents(e);\n        };\n        self.touchcancel = function (e) {\n            if (self.dispatchEvent('touchcancel', {NativeEvent: e, cell: self.currentCell})) { return; }\n            self.touchEndEvents(e);\n        };\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals HTMLElement: false, Reflect: false, define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self, ctor) {\n        self.scale = 1;\n        self.orders = {\n            rows: [],\n            columns: []\n        };\n        self.visibleRowHeights = [];\n        self.hasFocus = false;\n        self.activeCell = {\n            columnIndex: 0,\n            rowIndex: 0\n        };\n        self.storageName = 'canvasDataGrid';\n        self.invalidSearchExpClass = 'canvas-datagrid-invalid-search-regExp';\n        self.localStyleLibraryStorageKey = 'canvas-datagrid-user-style-library';\n        self.uniqueId = '_canvasDataGridUniqueId';\n        self.orderBy = self.uniqueId;\n        self.orderDirection = 'asc';\n        self.columnFilters = {};\n        self.filters = {};\n        self.frozenRow = 0;\n        self.frozenColumn = 0;\n        self.ellipsisCache = {};\n        self.scrollBox = {};\n        self.visibleRows = [];\n        self.sizes = {\n            rows: {},\n            columns: {},\n            trees: {}\n        };\n        self.currentFilter = function () {\n            return true;\n        };\n        self.selections = [];\n        self.hovers = {};\n        self.attributes = {};\n        self.style = {};\n        self.formatters = {};\n        self.sorters = {};\n        self.schemaHashes = {};\n        self.events = {};\n        self.uId = 0;\n        self.changes = [];\n        self.scrollIndexTop = 0;\n        self.scrollPixelTop = 0;\n        self.scrollIndexLeft = 0;\n        self.scrollPixelLeft = 0;\n        self.childGrids = {};\n        self.openChildren = {};\n        self.scrollModes = [\n            'vertical-scroll-box',\n            'vertical-scroll-top',\n            'vertical-scroll-bottom',\n            'horizontal-scroll-box',\n            'horizontal-scroll-right',\n            'horizontal-scroll-left'\n        ];\n        self.componentL1Events = {};\n        self.eventNames = ['afterdraw', 'afterrendercell', 'attributechanged', 'beforebeginedit',\n            'beforecreatecellgrid', 'beforedraw', 'beforeendedit', 'beforerendercell', 'beforerendercellgrid',\n            'beginedit', 'cellmouseout', 'cellmouseover', 'click', 'collapsetree', 'contextmenu', 'copy',\n            'datachanged', 'dblclick', 'endedit', 'expandtree', 'formatcellvalue', 'keydown', 'keypress',\n            'keyup', 'mousedown', 'mousemove', 'mouseup', 'newrow', 'ordercolumn', 'rendercell', 'rendercellgrid',\n            'renderorderbyarrow', 'rendertext', 'rendertreearrow', 'reorder', 'reordering', 'resize',\n            'resizecolumn', 'resizerow', 'schemachanged', 'scroll', 'selectionchanged', 'stylechanged',\n            'touchcancel', 'touchend', 'touchmove', 'touchstart', 'wheel'];\n        self.mouse = { x: 0, y: 0};\n        self.getSelectedData = function (expandToRow) {\n            var d = [], s = expandToRow ? self.getSchema() : self.getVisibleSchema(), l = self.data.length;\n            if (l === 0) { return []; }\n            self.selections.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) {\n                    d[index] = null;\n                    return;\n                }\n                d[index] = {};\n                row.forEach(function (col) {\n                    if (col === -1 || !s[col]) { return; }\n                    d[index][s[col].name] = self.data[index][s[col].name];\n                });\n            });\n            return d;\n        };\n        self.fillArray = function (low, high, step, def) {\n            step = step || 1;\n            var i = [], x;\n            for (x = low; x <= high; x += step) {\n                i[x] = def === undefined ? x : (typeof def === 'function' ? def(x) : def);\n            }\n            return i;\n        };\n        self.getColumnHeaderCellHeight = function () {\n            if (!self.attributes.showColumnHeaders) { return 0; }\n            return ((self.sizes.rows[-1] || self.style.columnHeaderCellHeight) * self.scale);\n        };\n        self.getRowHeaderCellWidth = function () {\n            if (!self.attributes.showRowHeaders) { return 0; }\n            return (self.sizes.columns.cornerCell || self.style.rowHeaderCellWidth) * self.scale;\n        };\n        self.setStorageData = function () {\n            if (!self.attributes.saveAppearance || !self.attributes.name) { return; }\n            var visibility = {};\n            self.getSchema().forEach(function (column) {\n                visibility[column.name] = !column.hidden;\n            });\n            localStorage.setItem(self.storageName + '-' + self.attributes.name, JSON.stringify({\n                sizes: {\n                    rows: self.sizes.rows,\n                    columns: self.sizes.columns\n                },\n                orders: {\n                    rows: self.orders.rows,\n                    columns: self.orders.columns\n                },\n                orderBy: self.orderBy,\n                orderDirection: self.orderDirection,\n                visibility: visibility\n            }));\n        };\n        self.getSchema = function () {\n            return self.schema || self.tempSchema;\n        };\n        self.createColumnOrders = function () {\n            var s = self.getSchema();\n            self.orders.columns = self.fillArray(0, s.length - 1);\n        };\n        self.createRowOrders = function () {\n            self.orders.rows = self.fillArray(0, self.data.length - 1);\n        };\n        self.getVisibleSchema = function () {\n            return self.getSchema().filter(function (col) {\n                return !col.hidden && col.name !== self.uniqueId;\n            });\n        };\n        self.applyDefaultValue = function (row, header) {\n            var d = header.defaultValue || '';\n            if (typeof d === 'function') {\n                d = d.apply(self.intf, [header]);\n            }\n            row[header.name] = d;\n        };\n        self.createNewRowData = function () {\n            self.newRow = {};\n            self.newRow[self.uniqueId] = self.uId;\n            self.uId += 1;\n            self.getSchema().forEach(function forEachHeader(header) {\n                self.applyDefaultValue(self.newRow, header);\n            });\n        };\n        self.getSchemaNameHash = function (key) {\n            var n = 0;\n            while (self.schemaHashes[key]) {\n                n += 1;\n                key = key + n;\n            }\n            return key;\n        };\n        self.filter = function (type) {\n            var f = self.filters[type];\n            if (!f && type !== undefined) {\n                console.warn('Cannot find filter for type %s, falling back to substring match.', type);\n                f = self.filters.string;\n            }\n            return f;\n        };\n        self.getBestGuessDataType = function (columnName) {\n            var t, x, l = self.data.length;\n            for (x = 0; x < l; x += 1) {\n                if ([null, undefined].indexOf(self.data[x][columnName]) !== -1) {\n                    t = typeof self.data[x];\n                    return t === 'object' ? 'string' : t;\n                }\n            }\n            return 'string';\n        };\n        self.drawChildGrids = function () {\n            Object.keys(self.childGrids).forEach(function (gridKey) {\n                self.childGrids[gridKey].draw();\n            });\n        };\n        self.resizeChildGrids = function () {\n            Object.keys(self.childGrids).forEach(function (gridKey) {\n                self.childGrids[gridKey].resize();\n            });\n        };\n        self.autoScrollZone = function (e, x, y, ctrl) {\n            var setTimer,\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight();\n            if (x > self.width - self.attributes.selectionScrollZone && x < self.width) {\n                self.scrollBox.scrollLeft += self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (y > self.height - self.attributes.selectionScrollZone && y < self.height) {\n                self.scrollBox.scrollTop += self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (x - self.attributes.selectionScrollZone - rowHeaderCellWidth < 0) {\n                self.scrollBox.scrollLeft -= self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (y - self.attributes.selectionScrollZone - columnHeaderCellHeight < 0) {\n                self.scrollBox.scrollTop -= self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (setTimer && !ctrl && self.currentCell && self.currentCell.columnIndex !== -1) {\n                self.scrollTimer = setTimeout(self.mousemove, self.attributes.scrollRepeatRate, e);\n            }\n        };\n        self.refreshFromOrigialData = function () {\n            self.data = self.originalData.filter(function (row) {\n                return true;\n            });\n        };\n        self.validateColumn = function (c, s) {\n            if (!c.name) {\n                throw new Error('A column must contain at least a name.');\n            }\n            if (s.filter(function (i) { return i.name === c.name; }).length > 0) {\n                throw new Error('A column with the name '\n                    + c.name + ' already exists and cannot be added again.');\n            }\n            return true;\n        };\n        self.setDefaults = function (obj1, obj2, key, def) {\n            obj1[key] = obj2[key] === undefined ? def : obj2[key];\n        };\n        self.setAttributes = function () {\n            self.defaults.attributes.forEach(function eachAttribute(i) {\n                self.setDefaults(self.attributes, self.args, i[0], i[1]);\n            });\n        };\n        self.setStyle = function () {\n            self.defaults.styles.forEach(function eachStyle(i) {\n                self.setDefaults(self.style, self.args.style || {}, i[0], i[1]);\n            });\n        };\n        self.autosize = function (colName) {\n            self.getVisibleSchema().forEach(function (col) {\n                if (col.name === colName || colName === undefined) {\n                    self.fitColumnToValues(col.name);\n                }\n            });\n            self.fitColumnToValues('cornerCell');\n        };\n        self.dispose = function () {\n            if (!self.isChildGrid && self.canvas && self.canvas.parentNode) {\n                self.canvas.parentNode.removeChild(self.canvas);\n            }\n            self.eventParent.removeEventListener('mouseup', self.mouseup, false);\n            self.eventParent.removeEventListener('mousedown', self.mousedown, false);\n            self.eventParent.removeEventListener('dblclick', self.dblclick, false);\n            self.eventParent.removeEventListener('click', self.click, false);\n            self.eventParent.removeEventListener('mousemove', self.mousemove);\n            self.eventParent.removeEventListener('wheel', self.scrollWheel, false);\n            self.canvas.removeEventListener('contextmenu', self.contextmenu, false);\n            self.canvas.removeEventListener('copy', self.copy);\n            self.controlInput.removeEventListener('keypress', self.keypress, false);\n            self.controlInput.removeEventListener('keyup', self.keyup, false);\n            self.controlInput.removeEventListener('keydown', self.keydown, false);\n            window.removeEventListener('resize', self.resize);\n            if (self.observer && self.observer.disconnect) {\n                self.observer.disconnect();\n            }\n        };\n        self.tryLoadStoredOrders = function () {\n            var s;\n            if (self.storedSettings\n                    && typeof self.storedSettings.orders === 'object'\n                    && self.storedSettings.orders !== null) {\n                if (self.storedSettings.orders.rows.length >= self.data.length) {\n                    self.orders.rows = self.storedSettings.orders.rows;\n                }\n                s = self.getSchema();\n                if (self.storedSettings.orders.columns.length === s.length) {\n                    self.orders.columns = self.storedSettings.orders.columns;\n                }\n                self.orderBy = self.storedSettings.orderBy === undefined\n                    ? self.uniqueId : self.storedSettings.orderBy;\n                self.orderDirection = self.storedSettings.orderDirection === undefined\n                    ? self.uniqueId : self.storedSettings.orderDirection;\n                if (self.orderBy !== self.uniqueId && self.getHeaderByName(self.orderBy) && self.orderDirection) {\n                    self.order(self.orderBy, self.orderDirection);\n                }\n            }\n        };\n        self.getDomRoot = function () {\n            return self.shadowRoot ? self.shadowRoot.host : self.parentNode;\n        };\n        self.getFontName = function (fontStyle) {\n            return fontStyle.replace(/\\d+\\.?\\d*px/, '');\n        };\n        self.getFontHeight = function (fontStyle) {\n            return parseFloat(fontStyle, 10);\n        };\n        self.parseStyleValue = function (key) {\n            if (/Font/.test(key)) {\n                self.style[key + 'Height'] = self.getFontHeight(self.style[key]);\n                self.style[key + 'Name'] = self.getFontName(self.style[key]);\n                return;\n            }\n            // when inheriting styles from already instantiated grids, don't parse already parsed values.\n            if (key === 'moveOverlayBorderSegments' && typeof self.style[key] === 'string') {\n                self.style[key] = self.style[key].split(',')\n                    .map(function (i) { return parseInt(i, 10); });\n            }\n        };\n        self.initProp = function (propName) {\n            if (!self.args[propName]) { return; }\n            Object.keys(self.args[propName]).forEach(function (key) {\n                self[propName][key] = self.args[propName][key];\n            });\n        };\n        self.getStyleProperty = function (key) {\n            if (self.styleKeys.indexOf(key) === -1) {\n                return self.parentNodeStyle[key];\n            }\n            return self.style[key];\n        };\n        self.setStyleProperty = function (key, value, supressDrawAndEvent) {\n            if (self.styleKeys.indexOf(key) === -1) {\n                self.parentNodeStyle[key] = value;\n            } else {\n                self.style[key] = value;\n                self.parseStyleValue(key);\n            }\n            if (!supressDrawAndEvent) {\n                self.draw(true);\n                self.dispatchEvent('stylechanged', {name: 'style', value: value});\n            }\n        };\n        self.reloadStoredValues = function () {\n            if (self.attributes.name && self.attributes.saveAppearance) {\n                self.storedSettings = localStorage.getItem(self.storageName + '-' + self.attributes.name);\n                if (self.storedSettings) {\n                    try {\n                        self.storedSettings = JSON.parse(self.storedSettings);\n                    } catch (e) {\n                        console.warn('could not read settings from localStore', e);\n                        self.storedSettings = undefined;\n                    }\n                }\n                if (self.storedSettings) {\n                    if (typeof self.storedSettings.sizes === 'object'\n                            && self.storedSettings.sizes !== null) {\n                        self.sizes.rows = self.storedSettings.sizes.rows;\n                        self.sizes.columns = self.storedSettings.sizes.columns;\n                        ['trees', 'columns', 'rows'].forEach(function (i) {\n                            if (!self.sizes[i]) {\n                                self.sizes[i] = {};\n                            }\n                        });\n                    }\n                    if (typeof self.storedSettings.visibility === 'object') {\n                        self.getSchema().forEach(function (column) {\n                            if (self.storedSettings.visibility[column.name] !== undefined) {\n                                column.hidden = !self.storedSettings.visibility[column.name];\n                            }\n                        });\n                    }\n                }\n            }\n        };\n        self.init = function () {\n            if (self.initialized) { return; }\n            var publicStyleKeyIntf = {};\n            self.setAttributes();\n            self.setStyle();\n            self.initScrollBox();\n            self.setDom();\n            self.type = 'canvas-datagrid';\n            self.initialized = true;\n            self.ie = /Trident/.test(window.navigator.userAgent);\n            self.edge = /Edge/.test(window.navigator.userAgent);\n            self.webKit = /WebKit/.test(window.navigator.userAgent);\n            self.moz = /Gecko/.test(window.navigator.userAgent);\n            self.webKit = /WebKit/.test(window.navigator.userAgent);\n            self.mobile = /Mobile/i.test(window.navigator.userAgent);\n            self.cursorGrab = 'grab';\n            self.cursorGrabing = 'grabbing';\n            self.cursorGrab = self.webKit ? '-webkit-grab' : self.cursorGrab;\n            self.cursorGrabing = self.moz ? '-webkit-grabbing' : self.cursorGrabbing;\n            self.pointerLockPosition = {x: 0, y: 0};\n            Object.keys(self.style).forEach(self.parseStyleValue);\n            self.intf.moveSelection = self.moveSelection;\n            self.intf.moveTo = self.moveTo;\n            self.intf.type = self.type;\n            self.intf.addEventListener = self.addEventListener;\n            self.intf.removeEventListener = self.removeEventListener;\n            self.intf.dispatchEvent = self.dispatchEvent;\n            /**\n             * Releases grid resources and removes grid elements.\n             * @memberof canvasDatagrid\n             * @name dispose\n             * @method\n             */\n            self.intf.dispose = self.dispose;\n            /**\n             * Appends the grid to another element later.  Not implemented.\n             * @memberof canvasDatagrid\n             * @name appendTo\n             * @method\n             * @param {number} el The element to append the grid to.\n             */\n            self.intf.appendTo = self.appendTo;\n            self.intf.filters = self.filters;\n            self.intf.sorters = self.sorters;\n            self.intf.autosize = self.autosize;\n            self.intf.beginEditAt = self.beginEditAt;\n            self.intf.endEdit = self.endEdit;\n            self.intf.setActiveCell = self.setActiveCell;\n            self.intf.forEachSelectedCell = self.forEachSelectedCell;\n            self.intf.scrollIntoView = self.scrollIntoView;\n            self.intf.clearChangeLog = self.clearChangeLog;\n            self.intf.gotoCell = self.gotoCell;\n            self.intf.gotoRow = self.gotoRow;\n            self.intf.getHeaderByName = self.getHeaderByName;\n            self.intf.findColumnScrollLeft = self.findColumnScrollLeft;\n            self.intf.findRowScrollTop = self.findRowScrollTop;\n            self.intf.fitColumnToValues = self.fitColumnToValues;\n            self.intf.findColumnMaxTextLength = self.findColumnMaxTextLength;\n            self.intf.disposeContextMenu = self.disposeContextMenu;\n            self.intf.getCellAt = self.getCellAt;\n            self.intf.isCellVisible = self.isCellVisible;\n            self.intf.order = self.order;\n            self.intf.draw = self.draw;\n            self.intf.selectArea = self.selectArea;\n            self.intf.clipElement = self.clipElement;\n            self.intf.getSchemaFromData = self.getSchemaFromData;\n            self.intf.setFilter = self.setFilter;\n            self.intf.selectRow = self.selectRow;\n            self.intf.parentGrid = self.parentGrid;\n            self.intf.toggleTree = self.toggleTree;\n            self.intf.expandTree = self.expandTree;\n            self.intf.collapseTree = self.collapseTree;\n            self.intf.canvas = self.canvas;\n            self.intf.context = self.ctx;\n            self.intf.insertRow = self.insertRow;\n            self.intf.deleteRow = self.deleteRow;\n            self.intf.addRow = self.addRow;\n            self.intf.insertColumn = self.insertColumn;\n            self.intf.deleteColumn = self.deleteColumn;\n            self.intf.addColumn = self.addColumn;\n            self.intf.getClippingRect = self.getClippingRect;\n            self.intf.setRowHeight = self.setRowHeight;\n            self.intf.setColumnWidth = self.setColumnWidth;\n            self.intf.resetColumnWidths = self.resetColumnWidths;\n            self.intf.resetRowHeights = self.resetRowHeights;\n            self.intf.resize = self.resize;\n            self.intf.selectColumn = self.selectColumn;\n            self.intf.selectRow = self.selectRow;\n            self.intf.selectAll = self.selectAll;\n            self.intf.selectNone = self.selectNone;\n            self.intf.drawChildGrids = self.drawChildGrids;\n            self.intf.assertPxColor = self.assertPxColor;\n            self.intf.clearPxColorAssertions = self.clearPxColorAssertions;\n            self.intf.integerToAlpha = self.integerToAlpha;\n            self.intf.copy = self.copy;\n            self.intf.setStyleProperty = self.setStyleProperty;\n            Object.defineProperty(self.intf, 'defaults', {\n                get: function () {\n                    return {\n                        styles: self.defaults.styles.reduce(function (a, i) { a[i[0]] = i[1]; return a; }, {}),\n                        attributes: self.defaults.attributes.reduce(function (a, i) { a[i[0]] = i[1]; return a; }, {})\n                    };\n                }\n            });\n            self.styleKeys = Object.keys(self.intf.defaults.styles);\n            self.DOMStyles = window.getComputedStyle(document.body, null);\n            Object.keys(self.DOMStyles).concat(Object.keys(self.style)).forEach(function (key) {\n                // unless this line is here, Object.keys() will not work on <instance>.style\n                publicStyleKeyIntf[key] = undefined;\n                Object.defineProperty(publicStyleKeyIntf, key, {\n                    get: function () {\n                        return self.getStyleProperty(key);\n                    },\n                    set: function (value) {\n                        self.setStyleProperty(key, value);\n                    }\n                });\n            });\n            Object.defineProperty(self.intf, 'shadowRoot', {\n                get: function () {\n                    return self.shadowRoot;\n                }\n            });\n            Object.defineProperty(self.intf, 'activeCell', {\n                get: function () {\n                    return self.activeCell;\n                }\n            });\n            Object.defineProperty(self.intf, 'hasFocus', {\n                get: function () {\n                    return self.hasFocus;\n                }\n            });\n            Object.defineProperty(self.intf, 'style', {\n                get: function () {\n                    return publicStyleKeyIntf;\n                },\n                set: function (valueObject) {\n                    Object.keys(valueObject).forEach(function (key) {\n                        self.setStyleProperty(key, valueObject[key], true);\n                    });\n                    self.draw(true);\n                    self.dispatchEvent('stylechanged', {name: 'style', value: valueObject});\n                }\n            });\n            Object.defineProperty(self.intf, 'attributes', { value: {}});\n            Object.keys(self.attributes).forEach(function (key) {\n                Object.defineProperty(self.intf.attributes, key, {\n                    get: function () {\n                        return self.attributes[key];\n                    },\n                    set: function (value) {\n                        self.attributes[key] = value;\n                        if (key === 'name') {\n                            self.reloadStoredValues();\n                            self.tryLoadStoredOrders();\n                        }\n                        self.draw(true);\n                        self.dispatchEvent('attributechanged', {name: key, value: value[key]});\n                    }\n                });\n            });\n            self.filters.string = function (value, filterFor) {\n                value = String(value);\n                var filterRegExp,\n                    regEnd = /\\/(i|g|m)*$/,\n                    pattern = regEnd.exec(filterFor),\n                    flags = pattern ? pattern[0].substring(1) : '',\n                    flagLength = flags.length;\n                self.invalidFilterRegEx = undefined;\n                if (filterFor.substring(0, 1) === '/' && pattern) {\n                    try {\n                        filterRegExp = new RegExp(filterFor.substring(1, filterFor.length - (flagLength + 1)), flags);\n                    } catch (e) {\n                        self.invalidFilterRegEx = e;\n                        return;\n                    }\n                    return filterRegExp.test(value);\n                }\n                return value.toString ? value.toString().toLocaleUpperCase()\n                    .indexOf(filterFor.toLocaleUpperCase()) !== -1 : false;\n            };\n            self.filters.number = function (value, filterFor) {\n                if (!filterFor) { return true; }\n                return value === filterFor;\n            };\n            ['formatters', 'filters', 'sorters'].forEach(self.initProp);\n            self.reloadStoredValues();\n            if (self.args.data) {\n                self.intf.data = self.args.data;\n            }\n            if (!self.data) {\n                self.intf.data = [];\n            }\n            if (self.args.schema) {\n                self.intf.schema = self.args.schema;\n            }\n            if (self.isChildGrid) {\n                requestAnimationFrame(function () { self.resize(true); });\n            } else {\n                self.resize(true);\n            }\n            return self;\n        };\n        /**\n         * Removes focus from the grid.\n         * @memberof canvasDatagrid\n         * @name blur\n         * @method\n         */\n        self.intf.blur = function (e) {\n            self.hasFocus = false;\n        };\n        /**\n         * Focuses on the grid.\n         * @memberof canvasDatagrid\n         * @name focus\n         * @method\n         */\n        self.intf.focus = function () {\n            self.hasFocus = true;\n            self.controlInput.focus();\n        };\n        if (self.shadowRoot || self.isChildGrid) {\n            Object.defineProperty(self.intf, 'height', {\n                get: function () {\n                    if (self.shadowRoot) {\n                        return self.shadowRoot.height;\n                    }\n                    return self.parentNode.height;\n                },\n                set: function (value) {\n                    if (self.shadowRoot) {\n                        self.shadowRoot.height = value;\n                    } else {\n                        self.parentNode.height = value;\n                    }\n                    self.resize(true);\n                }\n            });\n            Object.defineProperty(self.intf, 'width', {\n                get: function () {\n                    if (self.shadowRoot) {\n                        return self.shadowRoot.width;\n                    }\n                    return self.parentNode.width;\n                },\n                set: function (value) {\n                    if (self.shadowRoot) {\n                        self.shadowRoot.width = value;\n                    } else {\n                        self.parentNode.width = value;\n                    }\n                    self.resize(true);\n                }\n            });\n            Object.defineProperty(self.intf, 'parentNode', {\n                get: function () {\n                    return self.parentNode;\n                },\n                set: function (value) {\n                    if (!self.isChildGrid) {\n                        throw new TypeError('Cannot set property parentNode which has only a getter');\n                    }\n                    self.parentNode = value;\n                }\n            });\n        }\n        Object.defineProperty(self.intf, 'visibleRowHeights', {\n            get: function () {\n                return self.visibleRowHeights;\n            }\n        });\n        Object.defineProperty(self.intf, 'openChildren', {\n            get: function () {\n                return self.openChildren;\n            }\n        });\n        Object.defineProperty(self.intf, 'childGrids', {\n            get: function () {\n                return Object.keys(self.childGrids).map(function (gridId) {\n                    return self.childGrids[gridId];\n                });\n            }\n        });\n        Object.defineProperty(self.intf, 'isChildGrid', {\n            get: function () {\n                return self.isChildGrid;\n            }\n        });\n        Object.defineProperty(self, 'cursor', {\n            get: function () {\n                return self.parentNodeStyle.cursor;\n            },\n            set: function (value) {\n                if (value === 'cell') { value = 'default'; }\n                if (self.currentCursor !== value) {\n                    self.parentNodeStyle.cursor = value;\n                    self.currentCursor = value;\n                }\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollHeight', {\n            get: function () {\n                return self.scrollBox.scrollHeight;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollWidth', {\n            get: function () {\n                return self.scrollBox.scrollWidth;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollTop', {\n            get: function () {\n                return self.scrollBox.scrollTop;\n            },\n            set: function (value) {\n                self.scrollBox.scrollTop = value;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollLeft', {\n            get: function () {\n                return self.scrollBox.scrollLeft;\n            },\n            set: function (value) {\n                self.scrollBox.scrollLeft = value;\n            }\n        });\n        Object.defineProperty(self.intf, 'sizes', {\n            get: function () {\n                return self.sizes;\n            }\n        });\n        Object.defineProperty(self.intf, 'input', {\n            get: function () {\n                return self.input;\n            }\n        });\n        Object.defineProperty(self.intf, 'controlInput', {\n            get: function () {\n                return self.controlInput;\n            }\n        });\n        Object.defineProperty(self.intf, 'currentCell', {\n            get: function () {\n                return self.currentCell;\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleCells', {\n            get: function () {\n                return self.visibleCells;\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleRows', {\n            get: function () {\n                return self.visibleRows;\n            }\n        });\n        Object.defineProperty(self.intf, 'selections', {\n            get: function () {\n                return self.selections;\n            }\n        });\n        Object.defineProperty(self.intf, 'dragMode', {\n            get: function () {\n                return self.dragMode;\n            }\n        });\n        Object.defineProperty(self.intf, 'changes', {\n            get: function () {\n                return self.changes;\n            }\n        });\n        self.intf.formatters = self.formatters;\n        self.normalizeDataset = function (data, callback) {\n            var i, d, max, syncFnInvoked;\n            if (data === null || data === '' || data === undefined) {\n                return callback([]);\n            }\n            if (typeof data === 'string'\n                    || typeof data === 'number'\n                    || typeof data === 'boolean') {\n                data = [{'0': data}];\n            }\n            if (!Array.isArray(data) && typeof data === 'object') {\n                data = [data];\n            }\n            if ((!Array.isArray(data[0]) && typeof data[0] === 'object' && data[0] !== null)\n                            || (Array.isArray(data) && data.length === 0)) {\n                return callback(data);\n            }\n            if (typeof data === 'function') {\n                i = data.apply(self.intf, [function (d) {\n                    if (syncFnInvoked) {\n                        console.warn('Detected a callback to the data setter function after the same function already returned a value synchronously.');\n                    }\n                    self.normalizeDataset(d, callback);\n                }]);\n                if (i) {\n                    syncFnInvoked = true;\n                    self.normalizeDataset(i, callback);\n                }\n                return;\n            }\n            if (!Array.isArray(data) && typeof data === 'object') {\n                data = [data];\n            }\n            if (Array.isArray(data)) {\n                if (!Array.isArray(data[0])) {\n                    //array of something?  throw it all into 1 row!\n                    data = [data];\n                }\n                // find the longest length\n                max = 0;\n                d = [];\n                data.forEach(function (row) {\n                    max = Math.max(max, row.length);\n                });\n                // map against length indexes\n                data.forEach(function (row, index) {\n                    var x;\n                    d[index] = {};\n                    for (x = 0; x < max; x += 1) {\n                        d[index][x] = row[x];\n                    }\n                });\n                return callback(d);\n            }\n            throw new Error('Unsupported data type.  Must be an array of arrays or an array of objects, function or string.');\n        };\n        self.eventNames.forEach(function (eventName) {\n            Object.defineProperty(self.intf, 'on' + eventName, {\n                get: function () {\n                    return self.componentL1Events[eventName];\n                },\n                set: function (value) {\n                    self.events[eventName] = [];\n                    self.componentL1Events[eventName] = value;\n                    if (!value) { return; }\n                    self.addEventListener(eventName, value);\n                }\n            });\n        });\n        Object.defineProperty(self.intf, 'frozenRow', {\n            get: function () {\n                return self.frozenRow;\n            },\n            set: function (val) {\n                if (isNaN(val)) {\n                    throw new TypeError('Expected value for frozenRow to be a number.');\n                }\n                if (self.visibleRows.length > val) {\n                    throw new RangeError('Cannot set a value larger than the number of visible rows.');\n                }\n                self.frozenRow = val;\n            }\n        });\n        Object.defineProperty(self.intf, 'frozenColumn', {\n            get: function () {\n                return self.frozenColumn;\n            },\n            set: function (val) {\n                if (isNaN(val)) {\n                    throw new TypeError('Expected value for frozenRow to be a number.');\n                }\n                if (self.getVisibleSchema().length > val) {\n                    throw new RangeError('Cannot set a value larger than the number of visible columns.');\n                }\n                self.frozenColumn = val;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollIndexRect', {\n            get: function () {\n                return {\n                    top: self.scrollIndexTop,\n                    right: self.scrollIndexRight,\n                    bottom: self.scrollIndexBottom,\n                    left: self.scrollIndexLeft\n                };\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollPixelRect', {\n            get: function () {\n                return {\n                    top: self.scrollPixelTop,\n                    right: self.scrollPixelRight,\n                    bottom: self.scrollPixelBottom,\n                    left: self.scrollPixelLeft\n                };\n            }\n        });\n        Object.defineProperty(self.intf, 'selectionBounds', {\n            get: function () {\n                return self.getSelectionBounds();\n            }\n        });\n        Object.defineProperty(self.intf, 'selectedRows', {\n            get: function () {\n                return self.getSelectedData(true);\n            }\n        });\n        Object.defineProperty(self.intf, 'selectedCells', {\n            get: function () {\n                return self.getSelectedData();\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleSchema', {\n            get: function () {\n                return self.getVisibleSchema().map(function eachDataRow(col) {\n                    return col;\n                });\n            }\n        });\n        Object.defineProperty(self.intf, 'ctx', {\n            get: function () {\n                return self.ctx;\n            }\n        });\n        Object.defineProperty(self.intf, 'schema', {\n            get: function schemaGetter() {\n                return self.getSchema();\n            },\n            set: function schemaSetter(value) {\n                if (!Array.isArray(value) || typeof value[0] !== 'object') {\n                    throw new Error('Schema must be an array of objects.');\n                }\n                if (value[0].name === undefined) {\n                    throw new Error('Expected schema to contain an object with at least a name property.');\n                }\n                self.schema = value.map(function eachSchemaColumn(column, index) {\n                    column.width = column.width || self.style.cellWidth;\n                    column[self.uniqueId] = self.getSchemaNameHash(column.name);\n                    column.filter = column.filter || self.filter(column.type);\n                    column.type = column.type || 'string';\n                    column.index = index;\n                    column.columnIndex = index;\n                    column.rowIndex = -1;\n                    if (self.storedSettings && self.storedSettings.visibility[column.name] !== undefined) {\n                        column.hidden = !self.storedSettings.visibility[column.name];\n                    }\n                    return column;\n                });\n                self.tempSchema = undefined;\n                self.createNewRowData();\n                self.createColumnOrders();\n                self.tryLoadStoredOrders();\n                self.resize(true);\n                self.dispatchEvent('schemachanged', {schema: self.schema});\n            }\n        });\n        Object.defineProperty(self.intf, 'data', {\n            get: function dataGetter() {\n                return self.data.map(function (row) {\n                    delete row[self.uniqueId];\n                    return row;\n                });\n            },\n            set: function dataSetter(value) {\n                self.normalizeDataset(value, function (d) {\n                    self.originalData = d.map(function eachDataRow(row) {\n                        row[self.uniqueId] = self.uId;\n                        self.uId += 1;\n                        return row;\n                    });\n                    self.changes = [];\n                    //TODO apply filter to incoming dataset\n                    self.data = self.originalData;\n                    if (!self.schema) {\n                        self.tempSchema = self.getSchemaFromData();\n                    }\n                    if (!self.schema && self.data.length === 0) {\n                        self.tempSchema = [{name: ''}];\n                        self.tempSchema[0][self.uniqueId] = self.getSchemaNameHash('');\n                    }\n                    if (self.tempSchema && !self.schema) {\n                        self.createColumnOrders();\n                        self.tryLoadStoredOrders();\n                        self.dispatchEvent('schemachanged', {schema: self.tempSchema});\n                    }\n                    self.createNewRowData();\n                    if (self.attributes.autoResizeColumns && self.data.length > 0\n                            && self.storedSettings === undefined) {\n                        self.autosize();\n                    }\n                    self.fitColumnToValues('cornerCell', true);\n                    self.resize(true);\n                    self.createRowOrders();\n                    self.tryLoadStoredOrders();\n                    self.dispatchEvent('datachanged', {data: self.data});\n                });\n            }\n        });\n        self.initScrollBox = function () {\n            var sHeight = 0,\n                sWidth = 0,\n                scrollTop = 0,\n                scrollLeft = 0,\n                scrollHeight = 0,\n                scrollWidth = 0,\n                scrollBoxHeight = 20,\n                scrollBoxWidth = 20;\n            function setScrollTop(value, preventScrollEvent) {\n                if (isNaN(value)) {\n                    throw new Error('ScrollTop value must be a number');\n                }\n                if (value < 0) {\n                    value = 0;\n                }\n                if (value > scrollHeight) {\n                    value = scrollHeight;\n                }\n                if (scrollHeight < 0) {\n                    value = 0;\n                }\n                scrollTop = value;\n                if (!preventScrollEvent) {\n                    self.scroll();\n                }\n            }\n            function setScrollLeft(value, preventScrollEvent) {\n                if (isNaN(value)) {\n                    throw new Error('ScrollLeft value must be a number');\n                }\n                if (value < 0) {\n                    value = 0;\n                }\n                if (value > scrollWidth) {\n                    value = scrollWidth;\n                }\n                if (scrollWidth < 0) {\n                    value = 0;\n                }\n                scrollLeft = value;\n                if (!preventScrollEvent) {\n                    self.scroll();\n                }\n            }\n            self.scrollBox.toString = function () {\n                return '{\"width\": ' + scrollWidth\n                    + ', \"height\": ' + scrollHeight\n                    + ', \"left\": ' + scrollLeft\n                    + ', \"top\": ' + scrollTop + '}';\n            };\n            self.scrollBox.scrollTo = function (x, y, supressDrawEvent) {\n                setScrollLeft(x, true);\n                setScrollTop(y, supressDrawEvent);\n            };\n            Object.defineProperty(self.scrollBox, 'scrollBoxHeight', {\n                get: function () {\n                    return scrollBoxHeight;\n                },\n                set: function (value) {\n                    scrollBoxHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollBoxWidth', {\n                get: function () {\n                    return scrollBoxWidth;\n                },\n                set: function (value) {\n                    scrollBoxWidth = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'height', {\n                get: function () {\n                    return sHeight;\n                },\n                set: function (value) {\n                    if (scrollHeight < value) {\n                        scrollTop = 0;\n                    }\n                    sHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'width', {\n                get: function () {\n                    return sWidth;\n                },\n                set: function (value) {\n                    sWidth = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollTop', {\n                get: function () {\n                    return scrollTop;\n                },\n                set: setScrollTop\n            });\n            Object.defineProperty(self.scrollBox, 'scrollLeft', {\n                get: function () {\n                    return scrollLeft;\n                },\n                set: setScrollLeft\n            });\n            Object.defineProperty(self.scrollBox, 'scrollHeight', {\n                get: function () {\n                    return scrollHeight;\n                },\n                set: function (value) {\n                    if (scrollTop > value) {\n                        scrollTop = Math.max(value, 0);\n                    }\n                    if (scrollHeight < sHeight) {\n                        scrollTop = 0;\n                    }\n                    scrollHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollWidth', {\n                get: function () {\n                    return scrollWidth;\n                },\n                set: function (value) {\n                    if (scrollLeft > value) {\n                        scrollLeft = Math.max(value, 0);\n                    }\n                    scrollWidth = value;\n                }\n            });\n        };\n        return;\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false, Event: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        var zIndexTop, hoverScrollTimeout, autoCompleteContext;\n        function applyContextItemStyle(contextItemContainer) {\n            self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item' + (self.mobile ? '-mobile' : ''));\n            contextItemContainer.addEventListener('mouseover', function () {\n                self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item:hover');\n            });\n            contextItemContainer.addEventListener('mouseout', function () {\n                self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item');\n            });\n        }\n        function createContextMenu(ev, pos, items, parentContextMenu) {\n            var container = document.createElement('div'),\n                upArrow = document.createElement('div'),\n                downArrow = document.createElement('div'),\n                children = [],\n                selectedIndex = -1,\n                intf = {},\n                rect;\n            if (!Array.isArray(items)) { throw new Error('createContextMenu expects an array.'); }\n            function createItems() {\n                items.forEach(function (item) {\n                    var contextItemContainer = document.createElement('div'),\n                        childMenuArrow;\n                    function removeChildContext(e) {\n                        if (e.relatedTarget === container\n                                || item.contextMenu.container === e.relatedTarget\n                                || childMenuArrow === e.relatedTarget\n                                || (contextItemContainer === e.relatedTarget)\n                                || item.contextMenu.container.contains(e.relatedTarget)\n                                ) { return; }\n                        item.contextMenu.dispose();\n                        children.splice(children.indexOf(item.contextMenu), 1);\n                        item.contextMenu = undefined;\n                        contextItemContainer.removeEventListener('mouseout', removeChildContext);\n                        container.removeEventListener('mouseout', removeChildContext);\n                        contextItemContainer.setAttribute('contextOpen', '0');\n                        contextItemContainer.setAttribute('opening', '0');\n                    }\n                    function contextAddCallback(items) {\n                        // check yet again if the user hasn't moved off\n                        if (contextItemContainer.getAttribute('opening') !== '1' ||\n                                contextItemContainer.getAttribute('contextOpen') === '1') {\n                            return;\n                        }\n                        var cPos = contextItemContainer.getBoundingClientRect();\n                        cPos = {\n                            left: cPos.left + self.style.childContextMenuMarginLeft + container.offsetWidth,\n                            top: cPos.top + self.style.childContextMenuMarginTop,\n                            bottom: cPos.bottom,\n                            right: cPos.right\n                        };\n                        item.contextMenu = createContextMenu(ev, cPos, items, intf);\n                        contextItemContainer.setAttribute('contextOpen', '1');\n                        contextItemContainer.addEventListener('mouseout', removeChildContext);\n                        container.addEventListener('mouseout', removeChildContext);\n                        children.push(item.contextMenu);\n                    }\n                    function createChildContext() {\n                        var i;\n                        if (contextItemContainer.getAttribute('contextOpen') === '1') {\n                            return;\n                        }\n                        contextItemContainer.setAttribute('opening', '1');\n                        if (typeof item.items === 'function') {\n                            i  = item.items.apply(intf, [function (items) {\n                                contextAddCallback(items);\n                            }]);\n                            if (i !== undefined && Array.isArray(i)) {\n                                contextAddCallback(i);\n                            }\n                            return;\n                        }\n                        contextAddCallback(item.items);\n                    }\n                    function addItem(item) {\n                        function addContent(content) {\n                            if (content === null) { return; }\n                            if (typeof content === 'function') {\n                                return addContent(content(ev));\n                            }\n                            if (typeof content === 'object') {\n                                contextItemContainer.appendChild(content);\n                                return;\n                            }\n                            applyContextItemStyle(contextItemContainer);\n                            contextItemContainer.innerHTML = content;\n                            return;\n                        }\n                        addContent(item.title);\n                        item.contextItemContainer = contextItemContainer;\n                        if ((item.items && item.items.length > 0) || typeof item.items === 'function') {\n                            childMenuArrow = document.createElement('div');\n                            self.createInlineStyle(childMenuArrow, 'canvas-datagrid-context-child-arrow');\n                            childMenuArrow.innerHTML = self.style.childContextMenuArrowHTML;\n                            contextItemContainer.appendChild(childMenuArrow);\n                            contextItemContainer.addEventListener('mouseover', createChildContext);\n                            contextItemContainer.addEventListener('mouseout', function () {\n                                contextItemContainer.setAttribute('opening', '0');\n                            });\n                        }\n                        if (item.click) {\n                            contextItemContainer.addEventListener('click', function (ev) {\n                                item.click.apply(self, [ev]);\n                            });\n                        }\n                    }\n                    addItem(item);\n                    container.appendChild(contextItemContainer);\n                });\n            }\n            function clickIndex(idx) {\n                items[idx].contextItemContainer.dispatchEvent(new Event('click'));\n            }\n            function checkArrowVisibility() {\n                if (container.scrollTop > 0) {\n                    self.parentDOMNode.appendChild(upArrow);\n                } else if (upArrow.parentNode) {\n                    upArrow.parentNode.removeChild(upArrow);\n                }\n                if (container.scrollTop >= container.scrollHeight - container.offsetHeight && downArrow.parentNode) {\n                    downArrow.parentNode.removeChild(downArrow);\n                } else if (container.scrollHeight - container.offsetHeight > 0\n                        && !(container.scrollTop >= container.scrollHeight - container.offsetHeight)) {\n                    self.parentDOMNode.appendChild(downArrow);\n                }\n            }\n            function startHoverScroll(type) {\n                return function t() {\n                    var a = self.attributes.contextHoverScrollAmount;\n                    if (type === 'up' && container.scrollTop === 0) { return; }\n                    if (type === 'down' && container.scrollTop === container.scrollHeight) { return; }\n                    container.scrollTop += (type === 'up' ? -a : a);\n                    hoverScrollTimeout = setTimeout(t, self.attributes.contextHoverScrollRateMs, type);\n                };\n            }\n            function endHoverScroll(type) {\n                return function () {\n                    clearTimeout(hoverScrollTimeout);\n                };\n            }\n            function init() {\n                var loc = {},\n                    s = self.scrollOffset(self.canvas);\n                if (zIndexTop === undefined) {\n                    zIndexTop = self.style.contextMenuZIndex;\n                }\n                createItems();\n                self.createInlineStyle(container, 'canvas-datagrid-context-menu' + (self.mobile ? '-mobile' : ''));\n                loc.x = pos.left - s.left;\n                loc.y = pos.top - s.top;\n                loc.height = 0;\n                zIndexTop += 1;\n                container.style.position = 'absolute';\n                upArrow.style.color = self.style.contextMenuArrowColor;\n                downArrow.style.color = self.style.contextMenuArrowColor;\n                [upArrow, downArrow].forEach(function (el) {\n                    el.style.textAlign = 'center';\n                    el.style.position = 'absolute';\n                    el.style.zIndex = zIndexTop + 1;\n                });\n                container.style.zIndex = zIndexTop;\n                if (parentContextMenu && parentContextMenu.inputDropdown) {\n                    container.style.maxHeight = window.innerHeight - loc.y - self.style.autocompleteBottomMargin + 'px';\n                    container.style.minWidth = pos.width + 'px';\n                    loc.y += pos.height;\n                }\n                if (self.mobile) {\n                    container.style.width = pos.width + 'px';\n                }\n                container.style.left = loc.x + 'px';\n                container.style.top = loc.y + 'px';\n                container.addEventListener('scroll', checkArrowVisibility);\n                container.addEventListener('wheel', function (e) {\n                    if (self.hasFocus) {\n                        container.scrollTop += e.deltaY;\n                        container.scrollLeft += e.deltaX;\n                    }\n                    checkArrowVisibility();\n                });\n                upArrow.innerHTML = self.style.contextMenuArrowUpHTML;\n                downArrow.innerHTML = self.style.contextMenuArrowDownHTML;\n                container.appendChild(upArrow);\n                document.body.appendChild(downArrow);\n                document.body.appendChild(container);\n                rect = container.getBoundingClientRect();\n                // TODO: fix !(parentContextMenu && parentContextMenu.inputDropdown) state (autocomplete)\n                if (rect.bottom > window.innerHeight) {\n                    if (!(parentContextMenu && parentContextMenu.inputDropdown)) {\n                        loc.y -= (rect.bottom + self.style.contextMenuWindowMargin) - window.innerHeight;\n                    }\n                    if (loc.y < 0) { loc.y = 0; }\n                    if (container.offsetHeight > window.innerHeight - self.style.contextMenuWindowMargin) {\n                        container.style.height = window.innerHeight - self.style.contextMenuWindowMargin + 'px';\n                        loc.y -= self.style.contextMenuWindowMargin;\n                    }\n                }\n                if (rect.right > window.innerWidth) {\n                    loc.x -= rect.right - window.innerWidth + self.style.contextMenuWindowMargin;\n                }\n                if (loc.x < 0) { loc.x = 0; }\n                if (loc.y < 0) { loc.y = 0; }\n                container.style.left = loc.x + 'px';\n                container.style.top = loc.y + 'px';\n                rect = container.getBoundingClientRect();\n                upArrow.style.top = rect.top + 'px';\n                downArrow.style.top = rect.top + rect.height - downArrow.offsetHeight + 'px';\n                upArrow.style.left = rect.left + 'px';\n                downArrow.style.left = rect.left + 'px';\n                downArrow.style.width = container.offsetWidth + 'px';\n                upArrow.style.width = container.offsetWidth + 'px';\n                downArrow.addEventListener('mouseover', startHoverScroll('down'));\n                downArrow.addEventListener('mouseout', endHoverScroll('down'));\n                upArrow.addEventListener('mouseover', startHoverScroll('up'));\n                upArrow.addEventListener('mouseout', endHoverScroll('up'));\n                checkArrowVisibility();\n            }\n            intf.parentGrid = self.intf;\n            intf.parentContextMenu = parentContextMenu;\n            intf.container = container;\n            init();\n            intf.clickIndex = clickIndex;\n            intf.rect = rect;\n            intf.items = items;\n            intf.upArrow = upArrow;\n            intf.downArrow = downArrow;\n            intf.dispose = function () {\n                clearTimeout(hoverScrollTimeout);\n                children.forEach(function (c) {\n                    c.dispose();\n                });\n                [downArrow, upArrow, container].forEach(function (el) {\n                    if (el.parentNode) { el.parentNode.removeChild(el); }\n                });\n            };\n            Object.defineProperty(intf, 'selectedIndex', {\n                get: function () {\n                    return selectedIndex;\n                },\n                set: function (value) {\n                    if (typeof value !== 'number' || isNaN(value || !isFinite(value))) {\n                        throw new Error('Context menu selected index must be a sane number.');\n                    }\n                    selectedIndex = value;\n                    if (selectedIndex > items.length - 1) {\n                        selectedIndex = items.length - 1;\n                    }\n                    if (selectedIndex < 0) {\n                        selectedIndex = 0;\n                    }\n                    items.forEach(function (item, index) {\n                        if (index === selectedIndex) {\n                            return self.createInlineStyle(item.contextItemContainer, 'canvas-datagrid-context-menu-item:hover');\n                        }\n                        self.createInlineStyle(item.contextItemContainer, 'canvas-datagrid-context-menu-item');\n                    });\n                }\n            });\n            return intf;\n        }\n        function createFilterContextMenuItems(e) {\n            var filterContainer = document.createElement('div'),\n                filterLabel = document.createElement('div'),\n                filterAutoCompleteButton = document.createElement('button'),\n                filterInput = document.createElement('input'),\n                n = e.cell && e.cell.header ? e.cell.header.title || e.cell.header.name : '',\n                autoCompleteItems,\n                iRect;\n            function checkRegExpErrorState() {\n                filterInput.style.background = self.style.contextFilterInputBackground;\n                filterInput.style.color = self.style.contextFilterInputColor;\n                if (self.invalidFilterRegEx) {\n                    filterInput.style.background = self.style.contextFilterInvalidRegExpBackground;\n                    filterInput.style.color = self.style.contextFilterInvalidRegExpColor;\n                }\n            }\n            function fillAutoComplete() {\n                var count = 0;\n                autoCompleteItems = {};\n                self.data.forEach(function (row) {\n                    var value = row[e.cell.header.name];\n                    if (autoCompleteItems[value] || count > self.attributes.maxAutoCompleteItems) { return; }\n                    count += 1;\n                    autoCompleteItems[value] = {\n                        title: self.formatters[e.cell.header.type || 'string']({ cell: { value: value }}),\n                        click: function (e) {\n                            filterInput.value = value;\n                            e.stopPropagation();\n                            filterInput.dispatchEvent(new Event('keyup'));\n                            self.disposeAutocomplete();\n                            return;\n                        }\n                    };\n                });\n                autoCompleteItems = Object.keys(autoCompleteItems).map(function (key) {\n                    return autoCompleteItems[key];\n                });\n            }\n            function createAutoCompleteContext(ev) {\n                if (ev && [40, 38, 13, 9].indexOf(ev.keyCode) !== -1) { return; }\n                fillAutoComplete();\n                iRect = filterInput.getBoundingClientRect();\n                if (autoCompleteContext) {\n                    autoCompleteContext.dispose();\n                    autoCompleteContext = undefined;\n                }\n                autoCompleteContext = createContextMenu(e, {\n                    left: iRect.left,\n                    top: iRect.top,\n                    right: iRect.right,\n                    bottom: iRect.bottom,\n                    height: iRect.height,\n                    width: iRect.width\n                }, autoCompleteItems, {inputDropdown: true});\n                autoCompleteContext.selectedIndex = 0;\n            }\n            self.createInlineStyle(filterLabel, 'canvas-datagrid-context-menu-label');\n            self.createInlineStyle(filterAutoCompleteButton, 'canvas-datagrid-context-menu-filter-button');\n            self.createInlineStyle(filterInput, 'canvas-datagrid-context-menu-filter-input');\n            checkRegExpErrorState();\n            filterInput.onclick = self.disposeAutocomplete;\n            filterInput.addEventListener('keydown', function (e) {\n                //down\n                if (e.keyCode === 40) {\n                    autoCompleteContext.selectedIndex += 1;\n                }\n                //up\n                if (e.keyCode === 38) {\n                    autoCompleteContext.selectedIndex -= 1;\n                }\n                //enter\n                if (e.keyCode === 13) {\n                    autoCompleteContext.clickIndex(autoCompleteContext.selectedIndex);\n                    self.disposeContextMenu();\n                }\n                //tab\n                if (e.keyCode === 9) {\n                    autoCompleteContext.clickIndex(autoCompleteContext.selectedIndex);\n                    e.preventDefault();\n                }\n                //esc\n                if (e.keyCode === 27) {\n                    self.disposeContextMenu();\n                }\n            });\n            filterInput.addEventListener('keyup', function () {\n                self.setFilter(e.cell.header.name, filterInput.value);\n            });\n            filterInput.addEventListener('keyup', createAutoCompleteContext);\n            ['focus', 'blur', 'keydown', 'keyup', 'change'].forEach(function (en) {\n                filterInput.addEventListener(en, checkRegExpErrorState);\n            });\n            filterInput.value = e.cell.header ? self.columnFilters[e.cell.header.name] || '' : '';\n            filterLabel.innerHTML = self.attributes.filterOptionText.replace(/%s/g, n);\n            filterAutoCompleteButton.onclick = function () {\n                if (autoCompleteContext) {\n                    return self.disposeAutocomplete();\n                }\n                createAutoCompleteContext();\n            };\n            filterAutoCompleteButton.innerHTML = self.style.contextFilterButtonHTML;\n            filterContainer.addEventListener('click', function (e) {\n                return e.stopPropagation();\n            });\n            filterContainer.appendChild(filterLabel);\n            filterContainer.appendChild(filterInput);\n            filterContainer.appendChild(filterAutoCompleteButton);\n            e.items.push({\n                title: filterContainer\n            });\n            if (Object.keys(self.columnFilters).length) {\n                Object.keys(self.columnFilters).forEach(function (cf) {\n                    var h = self.getHeaderByName(cf);\n                    e.items.push({\n                        title: self.attributes.removeFilterOptionText.replace(/%s/g, h.title || h.name),\n                        click: function removeFilterClick(e) {\n                            e.preventDefault();\n                            self.setFilter(cf, '');\n                            self.controlInput.focus();\n                        }\n                    });\n                });\n            }\n        }\n        function addDefaultContextMenuItem(e) {\n            var isNormalCell = !(e.cell.isBackground || e.cell.isHeaderCellCap\n                    || e.cell.isScrollBar || e.cell.isCorner || e.cell.isRowHeader)\n                    && e.cell.header;\n            if (self.attributes.showFilter && isNormalCell) {\n                createFilterContextMenuItems(e);\n            }\n            if (self.attributes.showCopy\n                    && self.selections.reduce(function (p, r) {\n                        return p + r.length;\n                    }, 0) > 0) {\n                e.items.push({\n                    title: self.attributes.copyText,\n                    click: function () {\n                        document.execCommand('copy');\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n            if (self.attributes.showPaste && self.clipBoardData) {\n                e.items.push({\n                    title: self.attributes.pasteText,\n                    click: function () {\n                        self.paste(self.clipBoardData, e.cell.columnIndex, e.cell.rowIndex);\n                        self.draw();\n                    }\n                });\n            }\n            if (self.attributes.showColumnSelector) {\n                e.items.push({\n                    title: self.attributes.columnSelectorText,\n                    items: function () {\n                        var d = [];\n                        self.getSchema().forEach(function (column) {\n                            if (column.name === self.uniqueId) { return; }\n                            function toggleColumnVisibility(e) {\n                                column.hidden = !column.hidden;\n                                e.preventDefault();\n                                self.stopPropagation(e);\n                                self.disposeContextMenu();\n                                self.resize(true);\n                                self.setStorageData();\n                            }\n                            var el = document.createElement('div');\n                            applyContextItemStyle(el);\n                            el.addEventListener('touchstart', toggleColumnVisibility);\n                            el.addEventListener('click', toggleColumnVisibility);\n                            el.innerHTML = (column.hidden ? self.attributes.columnSelectorHiddenText\n                                    : self.attributes.columnSelectorVisibleText)\n                                    + (column.title || column.name);\n                            d.push({\n                                title: el\n                            });\n                        });\n                        return d;\n                    }\n                });\n                if (e.cell && e.cell.header) {\n                    e.items.push({\n                        title: self.attributes.hideColumnText\n                            .replace(/%s/ig, e.cell.header.title || e.cell.header.name),\n                        click: function (ev) {\n                            e.cell.header.hidden = true;\n                            ev.preventDefault();\n                            self.stopPropagation(ev);\n                            self.disposeContextMenu();\n                            self.setStorageData();\n                            setTimeout(function () { self.resize(true); }, 10);\n                        }\n                    });\n                }\n            }\n            if (self.attributes.saveAppearance && self.attributes.showClearSettingsOption\n                    && (Object.keys(self.sizes.rows).length > 0\n                        || Object.keys(self.sizes.columns).length > 0)) {\n                e.items.push({\n                    title: self.attributes.clearSettingsOptionText,\n                    click: function (e) {\n                        e.preventDefault();\n                        self.sizes.rows = {};\n                        self.sizes.columns = {};\n                        self.createRowOrders();\n                        self.createColumnOrders();\n                        self.storedSettings = undefined;\n                        self.dispatchEvent('resizecolumn', {columnWidth: self.style.cellWidth});\n                        self.dispatchEvent('resizerow', {cellHeight: self.style.cellHeight});\n                        self.setStorageData();\n                        self.resize(true);\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n            if (self.attributes.allowSorting && self.attributes.showOrderByOption && isNormalCell) {\n                e.items.push({\n                    title: self.attributes.showOrderByOptionTextAsc.replace('%s', e.cell.header.title || e.cell.header.name),\n                    click: function (ev) {\n                        ev.preventDefault();\n                        self.order(e.cell.header.name, 'asc');\n                        self.controlInput.focus();\n                    }\n                });\n                e.items.push({\n                    title: self.attributes.showOrderByOptionTextDesc.replace('%s', e.cell.header.title || e.cell.header.name),\n                    click: function (ev) {\n                        ev.preventDefault();\n                        self.order(e.cell.header.name, 'desc');\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n        }\n        self.disposeAutocomplete = function () {\n            if (autoCompleteContext) {\n                autoCompleteContext.dispose();\n                autoCompleteContext = undefined;\n            }\n        };\n        self.disposeContextMenu = function () {\n            document.removeEventListener('click', self.disposeContextMenu);\n            zIndexTop = self.style.contextMenuZIndex;\n            self.disposeAutocomplete();\n            if (self.contextMenu) {\n                self.contextMenu.dispose();\n            }\n            self.contextMenu = undefined;\n        };\n        self.contextmenuEvent = function (e, overridePos) {\n            if (!self.hasFocus && e.target !== self.canvas) {\n                return;\n            }\n            function createDiposeEvent() {\n                requestAnimationFrame(function () {\n                    document.addEventListener('click', self.disposeContextMenu);\n                    document.removeEventListener('mouseup', createDiposeEvent);\n                });\n            }\n            var contextPosition,\n                items = [],\n                pos = overridePos || self.getLayerPos(e),\n                ev = {\n                    NativeEvent: e,\n                    cell: self.getCellAt(pos.x, pos.y),\n                    items: items\n                };\n            if (!ev.cell.isGrid) {\n                addDefaultContextMenuItem(ev);\n            }\n            if (self.dispatchEvent('contextmenu', ev)) {\n                return;\n            }\n            if (!ev.cell.isGrid) {\n                if (self.contextMenu) {\n                    self.disposeContextMenu();\n                }\n                contextPosition = {\n                    left: pos.x + pos.rect.left\n                        + self.style.contextMenuMarginLeft + self.canvasOffsetLeft,\n                    top: pos.y + pos.rect.top\n                        + self.style.contextMenuMarginTop + self.canvasOffsetTop,\n                    right: ev.cell.width + ev.cell.x + pos.rect.left,\n                    bottom: ev.cell.height + ev.cell.y + pos.rect.top,\n                    height: ev.cell.height,\n                    width: ev.cell.width\n                };\n                if (self.mobile) {\n                    contextPosition.left = self.style.mobileContextMenuMargin + 'px';\n                    contextPosition.width = self.width - (self.style.mobileContextMenuMargin * 2) + 'px';\n                }\n                self.contextMenu = createContextMenu(ev, contextPosition, items);\n                document.addEventListener('mouseup', createDiposeEvent);\n                e.preventDefault();\n            }\n        };\n        return;\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        self.getClippingRect = function (ele) {\n            var boundingRect = self.position(self.parentNode),\n                eleRect = self.position(ele),\n                s = self.scrollOffset(self.canvas),\n                clipRect = {\n                    x: 0,\n                    y: 0,\n                    h: 0,\n                    w: 0\n                },\n                parentRect = {\n                    x: -Infinity,\n                    y: -Infinity,\n                    h: Infinity,\n                    w: Infinity\n                },\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth();\n            boundingRect.top -= s.top;\n            boundingRect.left -= s.left;\n            eleRect.top -= s.top;\n            eleRect.left -= s.left;\n            clipRect.h = boundingRect.top + boundingRect.height - ele.offsetTop - self.style.scrollBarWidth;\n            clipRect.w = boundingRect.left + boundingRect.width - ele.offsetLeft - self.style.scrollBarWidth;\n            clipRect.x = boundingRect.left + (eleRect.left * -1) + rowHeaderCellWidth;\n            clipRect.y = boundingRect.top + (eleRect.top * -1) + columnHeaderCellHeight;\n            return {\n                x: clipRect.x > parentRect.x ? clipRect.x : parentRect.x,\n                y: clipRect.y > parentRect.y ? clipRect.y : parentRect.y,\n                h: clipRect.h < parentRect.h ? clipRect.h : parentRect.h,\n                w: clipRect.w < parentRect.w ? clipRect.w : parentRect.w\n            };\n        };\n        self.clipElement = function (ele) {\n            var clipRect = self.getClippingRect(ele);\n            if (clipRect.w < 0) { clipRect.w = 0; }\n            if (clipRect.h < 0) { clipRect.h = 0; }\n            ele.style.clip = 'rect('\n                + clipRect.y + 'px,'\n                + clipRect.w + 'px,'\n                + clipRect.h + 'px,'\n                + clipRect.x + 'px'\n                + ')';\n            // INFO https://developer.mozilla.org/en-US/docs/Web/CSS/clip\n            // clip has been \"deprecated\" for clipPath.  Of course nothing but chrome\n            // supports clip path, so we'll keep using clip until someday clipPath becomes\n            // more widely support.  The code below works correctly, but setting clipPath and clip\n            // at the same time has undesirable results.\n            // ele.style.clipPath = 'polygon('\n            //     + clipRect.x + 'px ' + clipRect.y + 'px,'\n            //     + clipRect.x + 'px ' + clipRect.h + 'px,'\n            //     + clipRect.w + 'px ' + clipRect.h + 'px,'\n            //     + clipRect.w + 'px ' + clipRect.y + 'px'\n            //     + ')';\n        };\n        self.scrollOffset = function (e) {\n            var x = 0, y = 0;\n            while (e.parentNode && e.nodeName !== 'CANVAS-DATAGRID' && e !== self.intf) {\n                if (e.nodeType !== 'canvas-datagrid-tree'\n                        && e.nodeType !== 'canvas-datagrid-cell') {\n                    x -= e.scrollLeft;\n                    y -= e.scrollTop;\n                }\n                e = e.parentNode;\n            }\n            return {\n                left: x - document.scrollingElement.scrollLeft,\n                top: y - document.scrollingElement.scrollTop\n            };\n        };\n        self.resizeEditInput = function () {\n            if (self.input && self.input.editCell) {\n                var pos = self.canvas.getBoundingClientRect(),\n                    s = self.scrollOffset(self.intf),\n                    bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                    borderWidth = (self.style.cellBorderWidth * bm),\n                    cell = self.getVisibleCellByIndex(self.input.editCell.columnIndex, self.input.editCell.rowIndex)\n                        || {x: -100, y: -100, height: 0, width: 0};\n                if (self.mobile) {\n                    self.input.style.left = '0';\n                    self.input.style.top = (self.height - self.style.mobileEditInputHeight) - borderWidth - 1 + 'px';\n                    self.input.style.height = self.style.mobileEditInputHeight + 'px';\n                    self.input.style.width = self.width - borderWidth - 1 + 'px';\n                    return;\n                }\n                self.input.style.left = pos.left + cell.x + self.canvasOffsetLeft - s.left + 'px';\n                self.input.style.top = pos.top + cell.y - self.style.cellBorderWidth + self.canvasOffsetTop - s.top + 'px';\n                self.input.style.height = cell.height - borderWidth + 'px';\n                self.input.style.width = cell.width - self.style.cellPaddingLeft + 'px';\n                self.clipElement(self.input);\n            }\n        };\n        self.position = function (e, ignoreScrollOffset) {\n            var x = 0, y = 0, s = e, h, w;\n            while (e.offsetParent && e.nodeName !== 'CANVAS-DATAGRID') {\n                x += e.offsetLeft;\n                y += e.offsetTop;\n                h = e.offsetHeight;\n                w = e.offsetWidth;\n                e = e.offsetParent;\n            }\n            if (ignoreScrollOffset) {\n                return {left: x, top: y, height: h, width: w};\n            }\n            e = s;\n            s = self.scrollOffset(e);\n            return { left: x + s.left, top: y + s.top, height: h, width: w };\n        };\n        self.getLayerPos = function (e) {\n            var rect = self.canvas.getBoundingClientRect(),\n                pos = {\n                    x: e.clientX - rect.left,\n                    y: e.clientY - rect.top\n                };\n            if (self.isChildGrid) {\n                pos.x -= self.canvasOffsetLeft;\n                pos.y -= self.canvasOffsetTop;\n            }\n            return {\n                x: pos.x,\n                y: pos.y,\n                rect: rect\n            };\n        };\n        /**\n         * Ends editing, optionally aborting the edit.\n         * @memberof canvasDatagrid\n         * @name endEdit\n         * @method\n         * @param {boolean} abort When true, abort the edit.\n         */\n        self.endEdit = function (abort) {\n            var cell = self.input.editCell,\n                y = cell.rowIndex;\n            function abortEdit() {\n                abort = true;\n            }\n            if (self.dispatchEvent('beforeendedit', {\n                    cell: cell,\n                    newValue: self.input.value,\n                    oldValue: cell.value,\n                    abort: abortEdit,\n                    input: self.input\n                })) { return false; }\n            if (self.input.value !== cell.value && !abort) {\n                self.changes[y] = self.changes[y] || {};\n                self.changes[y][cell.header.name] = self.input.value;\n                cell.data[cell.header.name] = self.input.value;\n                if (y === self.data.length) {\n                    if (self.dispatchEvent('newrow', {\n                            value: self.input.value,\n                            defaultValue: cell.value,\n                            aborted: abort,\n                            cell: cell,\n                            input: self.input\n                        })) { return false; }\n                    self.uId += 1;\n                    self.addRow(cell.data);\n                    self.createNewRowData();\n                }\n                self.draw(true);\n            }\n            document.body.removeChild(self.input);\n            self.intf.focus();\n            self.dispatchEvent('endedit', {\n                cell: cell,\n                value: self.input.value,\n                aborted: abort,\n                input: self.input\n            });\n            self.input = undefined;\n            return true;\n        };\n        /**\n         * Begins editing at cell x, row y.\n         * @memberof canvasDatagrid\n         * @name beginEditAt\n         * @method\n         * @param {number} x The column index of the cell to edit.\n         * @param {number} y The row index of the cell to edit.\n         */\n        self.beginEditAt = function (x, y) {\n            if (!self.attributes.editable) { return; }\n            if (self.input) {\n                self.endEdit();\n            }\n            var cell = self.getVisibleCellByIndex(x, y),\n                s = self.getVisibleSchema(),\n                enumItems,\n                enu,\n                option,\n                valueInEnum;\n            if (!(cell && cell.header)) { return; }\n            //HACK for IE10, does not like literal enum\n            enu = cell.header['enum'];\n            if (self.dispatchEvent('beforebeginedit', {cell: cell})) { return false; }\n            self.scrollIntoView(x, y);\n            self.setActiveCell(x, y);\n            if (enu) {\n                self.input = document.createElement('select');\n            } else {\n                self.input = document.createElement(self.attributes.multiLine\n                    ? 'textarea' : 'input');\n            }\n            cell = self.getVisibleCellByIndex(x, y);\n            //HACK on mobile devices sometimes edit can begin without the cell being in view, I don't know how.\n            if (!cell) { return; }\n            if (enu) {\n                // add enums\n                if (typeof enu === 'function') {\n                    enumItems = enu.apply(self.intf, [{cell: cell}]);\n                } else if (Array.isArray(enu)) {\n                    enumItems = enu;\n                }\n                enumItems.forEach(function (e) {\n                    var i = document.createElement('option'),\n                        val,\n                        title;\n                    if (Array.isArray(e)) {\n                        val = e[0];\n                        title = e[1];\n                    } else {\n                        val = e;\n                        title = e;\n                    }\n                    if (val === cell.value) { valueInEnum = true; }\n                    i.value = val;\n                    i.innerHTML = title;\n                    self.input.appendChild(i);\n                });\n                if (!valueInEnum) {\n                    option = document.createElement('option');\n                    option.value = cell.value;\n                    option.innerHTML = cell.value;\n                    self.input.appendChild(option);\n                }\n                self.input.addEventListener('change', function () {\n                    self.endEdit();\n                    self.draw(true);\n                });\n            }\n            document.body.appendChild(self.input);\n            self.createInlineStyle(self.input, self.mobile ? 'canvas-datagrid-edit-mobile-input' : 'canvas-datagrid-edit-input');\n            self.input.style.position = 'absolute';\n            self.input.editCell = cell;\n            self.resizeEditInput();\n            self.input.style.zIndex = self.style.editCellZIndex;\n            self.input.style.fontSize = (parseInt(self.style.editCellFontSize, 10) * self.scale) + 'px';\n            self.input.value = cell.value;\n            self.input.focus();\n            self.input.addEventListener('click', self.stopPropagation);\n            self.input.addEventListener('dblclick', self.stopPropagation);\n            self.input.addEventListener('mouseup', self.stopPropagation);\n            self.input.addEventListener('mousedown', self.stopPropagation);\n            self.input.addEventListener('keydown', function (e) {\n                var nx = cell.columnIndex,\n                    ny = cell.rowIndex;\n                // esc\n                if (e.keyCode === 27) {\n                    self.endEdit(true);\n                    self.draw(true);\n                // enter\n                } else if (e.keyCode === 13\n                        && (!self.attributes.multiLine\n                            || (self.attributes.multiLine && e.shiftKey))) {\n                    self.endEdit();\n                    self.draw(true);\n                } else if (e.keyCode === 9) {\n                    e.preventDefault();\n                    if (!self.endEdit()) {\n                        return;\n                    }\n                    if (e.shiftKey) {\n                        nx -= 1;\n                    } else {\n                        nx += 1;\n                    }\n                    if (nx < 0) {\n                        nx = s.length - 1;\n                        ny -= 1;\n                    }\n                    if (nx > s.length - 1) {\n                        nx = 0;\n                        ny += 1;\n                    }\n                    if (ny < 0) {\n                        ny = self.data.length - 1;\n                    }\n                    if (ny > self.data.length - 1) {\n                        ny = 0;\n                    }\n                    self.scrollIntoView(nx, ny);\n                    self.beginEditAt(nx, ny);\n                }\n            });\n            self.dispatchEvent('beginedit', {cell: cell, input: self.input});\n        };\n        self.createInlineStyle = function (el, className) {\n            var css = {\n                'canvas-datagrid-context-menu-filter-input': {\n                    height: '19px',\n                    verticalAlign: 'bottom',\n                    marginLeft: '2px',\n                    padding: '0',\n                    background: self.style.contextFilterInputBackground,\n                    color: self.style.contextFilterInputColor,\n                    border: self.style.contextFilterInputBorder,\n                    borderRadius: self.style.contextFilterInputBorderRadius,\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextFilterInputFontFamily,\n                    fontSize: self.style.contextFilterInputFontSize\n                },\n                'canvas-datagrid-context-menu-filter-button': {\n                    height: '19px',\n                    verticalAlign: 'bottom',\n                    marginLeft: '2px',\n                    padding: '0',\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextFilterButtonBorder,\n                    borderRadius: self.style.contextFilterButtonBorderRadius,\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFilterButtonFontFamily,\n                    fontSize: self.style.contextMenuFilterButtonFontSize\n                },\n                'canvas-datagrid-context-child-arrow': {\n                    cssFloat: 'right',\n                    color: self.style.childContextMenuArrowColor,\n                    fontSize: self.style.contextMenuChildArrowFontSize,\n                    fontFamily: self.style.contextMenuFontFamily,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-autocomplete': {\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    position: 'absolute',\n                    zIndex: 9999,\n                    overflow: 'hidden'\n                },\n                'canvas-datagrid-autocomplete-item': {\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor\n                },\n                'canvas-datagrid-autocomplete-item:hover': {\n                    background: self.style.contextMenuHoverBackground,\n                    color: self.style.contextMenuHoverColor\n                },\n                'canvas-datagrid-canvas': {\n                    position: 'absolute',\n                    zIndex: '-1'\n                },\n                'canvas-datagrid': {\n                    display: 'block'\n                },\n                'canvas-datagrid-control-input': {\n                    position: 'fixed',\n                    top: '-5px',\n                    left: '-5px',\n                    border: 'none',\n                    opacity: '0',\n                    cursor: 'pointer',\n                    width: '1px',\n                    height: '1px',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize\n                },\n                'canvas-datagrid-edit-mobile-input': {\n                    boxSizing: 'content-box',\n                    outline: 'none',\n                    margin: '0',\n                    padding: '0 0 0 0',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.mobileEditFontFamily,\n                    fontSize: self.style.mobileEditFontSize,\n                    border: self.style.editCellBorder,\n                    color: self.style.editCellColor,\n                    background: self.style.editCellBackgroundColor,\n                    appearance: 'none',\n                    webkitAppearance: 'none',\n                    mozAppearance: 'none',\n                    borderRadius: '0'\n                },\n                'canvas-datagrid-edit-input': {\n                    boxSizing: 'content-box',\n                    outline: 'none',\n                    margin: '0',\n                    padding: '0 0 0 ' + self.style.editCellPaddingLeft + 'px',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.editCellFontFamily,\n                    fontSize: self.style.editCellFontSize,\n                    boxShadow: self.style.editCellBoxShadow,\n                    border: self.style.editCellBorder,\n                    color: self.style.editCellColor,\n                    background: self.style.editCellBackgroundColor,\n                    appearance: 'none',\n                    webkitAppearance: 'none',\n                    mozAppearance: 'none',\n                    borderRadius: '0'\n                },\n                'canvas-datagrid-context-menu-item-mobile': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    color: 'inherit',\n                    background: 'inherit',\n                    margin: self.style.contextMenuItemMargin,\n                    borderRadius: self.style.contextMenuItemBorderRadius,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-context-menu-item': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    color: 'inherit',\n                    background: 'inherit',\n                    margin: self.style.contextMenuItemMargin,\n                    borderRadius: self.style.contextMenuItemBorderRadius,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-context-menu-item:hover': {\n                    background: self.style.contextMenuHoverBackground,\n                    color: self.style.contextMenuHoverColor\n                },\n                'canvas-datagrid-context-menu-label': {\n                    margin: self.style.contextMenuLabelMargin,\n                    display: self.style.contextMenuLabelDisplay,\n                    minWidth: self.style.contextMenuLabelMinWidth,\n                    maxWidth: self.style.contextMenuLabelMaxWidth\n                },\n                'canvas-datagrid-context-menu-mobile': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    overflow: 'hidden',\n                    whiteSpace: 'nowrap'\n                },\n                'canvas-datagrid-context-menu': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    overflow: 'hidden',\n                    whiteSpace: 'nowrap'\n                },\n                'canvas-datagrid-invalid-search-regExp': {\n                    background: self.style.contextMenuFilterInvalidExpresion\n                }\n            };\n            if (css[className]) {\n                Object.keys(css[className]).map(function (prop) {\n                    el.style[prop] = css[className][prop];\n                });\n            }\n            return;\n        };\n        self.appendTo = function (e) {\n            self.parentNode = e;\n            self.setDom();\n        };\n        self.setDom = function () {\n            if (self.isChildGrid) {\n                self.parentGrid = self.parentNode.parentGrid;\n                self.ctx = self.parentGrid.context;\n                self.canvas = self.parentGrid.canvas;\n                self.controlInput = self.parentGrid.controlInput;\n                self.eventParent = self.canvas;\n            } else {\n                self.controlInput = self.controlInput || document.createElement('input');\n                self.controlInput.onblur = self.intf.blur;\n                self.createInlineStyle(self.controlInput, 'canvas-datagrid-control-input');\n                self.isChildGrid = false;\n                self.parentDOMNode = self.parentNode;\n                self.parentIsCanvas = /^canvas$/i.test(self.parentDOMNode.tagName);\n                if (self.parentIsCanvas) {\n                    self.canvas = self.parentDOMNode;\n                    self.parentDOMNode.appendChild(self.controlInput);\n                } else {\n                    self.canvas = document.createElement('canvas');\n                    self.parentDOMNode.appendChild(self.canvas);\n                    self.parentDOMNode.appendChild(self.controlInput);\n                }\n                self.createInlineStyle(self.canvas, 'canvas-datagrid');\n                self.ctx = self.canvas.getContext('2d');\n                self.ctx.textBaseline = 'alphabetic';\n                self.eventParent = self.canvas;\n            }\n            self.parentNodeStyle = self.canvas.style;\n            // simulate a block element\n            if (self.intf.tagName === 'SECTION') {\n                // required for non custom tag browsers\n                self.intf.style.height = '100%';\n                self.intf.style.width = '100%';\n            }\n            self.parentNodeStyle.width = '100%';\n            self.parentNodeStyle.height = '100%';\n            self.controlInput.setAttribute('readonly', true);\n            self.controlInput.addEventListener('blur', function (e) {\n                if (e.target !== self.canvas) {\n                    self.hasFocus = false;\n                }\n            });\n            self.eventParent.addEventListener('scroll', self.resize, false);\n            self.eventParent.addEventListener('touchstart', self.touchstart, false);\n            self.eventParent.addEventListener('mouseup', self.mouseup, false);\n            self.eventParent.addEventListener('mousedown', self.mousedown, false);\n            self.eventParent.addEventListener('dblclick', self.dblclick, false);\n            self.eventParent.addEventListener('click', self.click, false);\n            self.eventParent.addEventListener('mousemove', self.mousemove);\n            self.eventParent.addEventListener('wheel', self.scrollWheel, false);\n            self.canvas.addEventListener('contextmenu', self.contextmenuEvent, false);\n            self.controlInput.addEventListener('copy', self.copy);\n            self.controlInput.addEventListener('cut', self.cut);\n            self.controlInput.addEventListener('paste', self.paste);\n            self.controlInput.addEventListener('keypress', self.keypress, false);\n            self.controlInput.addEventListener('keyup', self.keyup, false);\n            self.controlInput.addEventListener('keydown', self.keydown, false);\n            window.addEventListener('resize', self.resize);\n        };\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\n!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n    'use strict';\n    return function (self) {\n        // all methods here are exposed by intf\n        // to users\n        /**\n         * Converts a integer into a letter A - ZZZZZ...\n         * @memberof canvasDatagrid\n         * @name integerToAlpha\n         * @method\n         * @param {column} n The number to convert.\n         */\n        self.integerToAlpha = function (n) {\n            var ordA = 'a'.charCodeAt(0),\n                ordZ = 'z'.charCodeAt(0),\n                len = ordZ - ordA + 1,\n                s = '';\n            while (n >= 0) {\n                s = String.fromCharCode(n % len + ordA) + s;\n                n = Math.floor(n / len) - 1;\n            }\n            return s;\n        };\n        /**\n         * Inserts a new column before the specified index into the schema.\n         * @tutorial schema\n         * @memberof canvasDatagrid\n         * @name insertColumn\n         * @method\n         * @param {column} c The column to insert into the schema.\n         * @param {number} index The index of the column to insert before.\n         */\n        self.insertColumn = function (c, index) {\n            var s = self.getSchema();\n            if (s.length < index) {\n                throw new Error('Index is beyond the length of the schema.');\n            }\n            self.validateColumn(c, s);\n            s.splice(index, 0, c);\n            self.data.forEach(function (row) {\n                self.applyDefaultValue(row, c);\n            });\n            self.intf.schema = s;\n        };\n        /**\n         * Deletes a column from the schema at the specified index.\n         * @memberof canvasDatagrid\n         * @name deleteColumn\n         * @tutorial schema\n         * @method\n         * @param {number} index The index of the column to delete.\n         */\n        self.deleteColumn = function (index) {\n            var s = self.getSchema();\n            // remove data matching this column name from data\n            self.data.forEach(function (row) {\n                delete row[s[index].name];\n            });\n            s.splice(index, 1);\n            self.intf.schema = s;\n        };\n        /**\n         * Adds a new column into the schema.\n         * @tutorial schema\n         * @memberof canvasDatagrid\n         * @name addColumn\n         * @method\n         * @param {column} c The column to add to the schema.\n         */\n        self.addColumn = function (c) {\n            var s = self.getSchema();\n            self.validateColumn(c, s);\n            s.push(c);\n            self.data.forEach(function (row) {\n                self.applyDefaultValue(row, c);\n            });\n            self.intf.schema = s;\n        };\n        /**\n         * Deletes a row from the dataset at the specified index.\n         * @memberof canvasDatagrid\n         * @name deleteRow\n         * @method\n         * @param {number} index The index of the row to delete.\n         */\n        self.deleteRow = function (index) {\n            self.originalData.splice(index, 1);\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Inserts a new row into the dataset before the specified index.\n         * @memberof canvasDatagrid\n         * @name insertRow\n         * @method\n         * @param {object} d data.\n         * @param {number} index The index of the row to insert before.\n         */\n        self.insertRow = function (d, index) {\n            if (self.originalData.length < index) {\n                throw new Error('Index is beyond the length of the dataset.');\n            }\n            self.originalData.splice(index, 0, d);\n            self.getSchema().forEach(function (c) {\n                if (d[c.name] === undefined) {\n                    self.applyDefaultValue(self.originalData[index], c);\n                }\n            });\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Adds a new row into the dataset.\n         * @memberof canvasDatagrid\n         * @name addRow\n         * @method\n         * @param {object} d data.\n         */\n        self.addRow = function (d) {\n            self.originalData.push(d);\n            self.getSchema().forEach(function (c) {\n                if (d[c.name] === undefined) {\n                    self.applyDefaultValue(self.originalData[self.originalData.length - 1], c);\n                }\n            });\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Sets the height of a given row by index number.\n         * @memberof canvasDatagrid\n         * @name setRowHeight\n         * @method\n         * @param {number} rowIndex The index of the row to set.\n         * @param {number} height Height to set the row to.\n         */\n        self.setRowHeight = function (rowIndex, height) {\n            self.sizes.rows[self.data[rowIndex][self.uniqueId]] = height;\n            self.draw(true);\n        };\n        /**\n         * Sets the width of a given column by index number.\n         * @memberof canvasDatagrid\n         * @name setColumnWidth\n         * @method\n         * @param {number} colIndex The index of the column to set.\n         * @param {number} width Width to set the column to.\n         */\n        self.setColumnWidth = function (colIndex, width) {\n            var s = self.getSchema();\n            self.sizes.columns[s[colIndex][self.uniqueId]] = width;\n            self.draw(true);\n        };\n        /**\n         * Removes any changes to the width of the columns due to user or api interaction, setting them back to the schema or style default.\n         * @memberof canvasDatagrid\n         * @name resetColumnWidths\n         * @tutorial schema\n         * @method\n         */\n        self.resetColumnWidths = function () {\n            self.sizes.columns = {};\n            self.draw(true);\n        };\n        /**\n         * Removes any changes to the height of the rows due to user or api interaction, setting them back to the schema or style default.\n         * @memberof canvasDatagrid\n         * @name resetRowHeights\n         * @tutorial schema\n         * @method\n         */\n        self.resetRowHeights = function () {\n            self.sizes.rows = {};\n            self.draw(true);\n        };\n        /**\n         * Sets the value of the filter.\n         * @memberof canvasDatagrid\n         * @name setFilter\n         * @method\n         * @param {string} column Name of the column to filter.\n         * @param {string} value The value to filter for.\n         */\n        self.setFilter = function (column, value) {\n            function applyFilter() {\n                self.refreshFromOrigialData();\n                Object.keys(self.columnFilters).forEach(function (filter) {\n                    var header = self.getHeaderByName(column);\n                    if (!header) {\n                        return;\n                    }\n                    self.currentFilter = header.filter || self.filter(column.type || 'string');\n                    self.data = self.data.filter(function (row) {\n                        return self.currentFilter(row[filter], self.columnFilters[filter]);\n                    });\n                });\n                self.resize();\n                self.draw(true);\n            }\n            if (column === undefined && value === undefined) {\n                self.columnFilters = {};\n                return applyFilter();\n            }\n            if (column && (value === '' || value === undefined)) {\n                delete self.columnFilters[column];\n            } else {\n                self.columnFilters[column] = value;\n            }\n            applyFilter();\n        };\n        /**\n         * Returns the number of pixels to scroll down to line up with row rowIndex.\n         * @memberof canvasDatagrid\n         * @name findRowScrollTop\n         * @method\n         * @param {number} rowIndex The row index of the row to scroll find.\n         */\n        self.findRowScrollTop = function (rowIndex) {\n            var top = 0, x = 0, l = self.data.length,\n                bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                cellBorder = self.style.cellBorderWidth * bm;\n            if (!self.attributes.showNewRow) {\n                l -= 1;\n            }\n            if (rowIndex > l) {\n                throw new Error('Impossible row index');\n            }\n            while (x < rowIndex) {\n                top += (self.sizes.rows[self.data[x][self.uniqueId]] || self.style.cellHeight) + cellBorder;\n                x += 1;\n            }\n            //TODO: This is not super accurate, causes pageUp/Dn to not move around right\n            return top - (self.sizes.rows[self.data[rowIndex][self.uniqueId]] || self.style.cellHeight);\n        };\n        /**\n         * Returns the number of pixels to scroll to the left to line up with column columnIndex.\n         * @memberof canvasDatagrid\n         * @name findColumnScrollLeft\n         * @method\n         * @param {number} columnIndex The column index of the column to find.\n         */\n        self.findColumnScrollLeft = function (columnIndex) {\n            var left = 0, y = 0, s = self.getSchema(), l = s.length - 1;\n            if (columnIndex > l) {\n                throw new Error('Impossible column index');\n            }\n            while (y < columnIndex) {\n                left += self.sizes.columns[s[y][self.uniqueId]] || s[y].width || self.style.cellWidth;\n                y += 1;\n            }\n            return left;\n        };\n        /**\n         * Scrolls the cell at cell x, row y.\n         * @memberof canvasDatagrid\n         * @name gotoCell\n         * @method\n         * @param {number} x The column index of the cell to scroll to.\n         * @param {number} y The row index of the cell to scroll to.\n         */\n        self.gotoCell = function (x, y) {\n            if (x !== undefined) {\n                self.scrollBox.scrollLeft = self.findColumnScrollLeft(x);\n            }\n            if (y !== undefined) {\n                self.scrollBox.scrollTop = self.findRowScrollTop(y);\n            }\n        };\n        /**\n         * Scrolls the row y.\n         * @memberof canvasDatagrid\n         * @name gotoRow\n         * @method\n         * @param {number} y The row index of the cell to scroll to.\n         */\n        self.gotoRow = function (y) {\n            self.gotoCell(0, y);\n        };\n        /**\n         * Scrolls the cell at cell x, row y into view if it is not already.\n         * @memberof canvasDatagrid\n         * @name scrollIntoView\n         * @method\n         * @param {number} x The column index of the cell to scroll into view.\n         * @param {number} y The row index of the cell to scroll into view.\n         */\n        self.scrollIntoView = function (x, y) {\n            if (self.visibleCells.filter(function (cell) {\n                    return (cell.rowIndex === y || y === undefined)\n                        && (cell.columnIndex === x || x === undefined)\n                        && cell.x > 0\n                        && cell.y > 0\n                        && cell.x + cell.width < self.width\n                        && cell.y + cell.height < self.height;\n                }).length === 0) {\n                self.gotoCell(x, y);\n            }\n        };\n        /**\n         * Sets the active cell. Requires redrawing.\n         * @memberof canvasDatagrid\n         * @name setActiveCell\n         * @method\n         * @param {number} x The column index of the cell to set active.\n         * @param {number} y The row index of the cell to set active.\n         */\n        self.setActiveCell = function (x, y) {\n            self.activeCell = {\n                rowIndex: y,\n                columnIndex: x\n            };\n        };\n        /**\n         * Removes the selection.\n         * @memberof canvasDatagrid\n         * @name selectNone\n         * @param {boolean} dontDraw Suppress the draw method after the selection change.\n         * @method\n         */\n        self.selectNone = function (dontDraw) {\n            self.selections = [];\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n            if (dontDraw) { return; }\n            self.draw();\n        };\n        /**\n         * Selects every visible cell.\n         * @memberof canvasDatagrid\n         * @name selectAll\n         * @param {boolean} dontDraw Suppress the draw method after the selection change.\n         * @method\n         */\n        self.selectAll = function (dontDraw) {\n            self.selectArea({\n                top: 0,\n                left: 0,\n                right: self.getVisibleSchema().length - 1,\n                bottom: self.data.length - 1\n            });\n            if (dontDraw) { return; }\n            self.draw();\n        };\n        /**\n         * Returns true if the selected columnIndex is selected on every row.\n         * @memberof canvasDatagrid\n         * @name isColumnSelected\n         * @method\n         * @param {number} columnIndex The column index to check.\n         */\n        self.isColumnSelected = function (columnIndex) {\n            var colIsSelected = true;\n            self.data.forEach(function (row, rowIndex) {\n                if (!self.selections[rowIndex] || self.selections[rowIndex].indexOf(self.orders.columns[columnIndex]) === -1) {\n                    colIsSelected = false;\n                }\n            });\n            return colIsSelected;\n        };\n        /**\n         * Runs the defined method on each selected cell.\n         * @memberof canvasDatagrid\n         * @name forEachSelectedCell\n         * @method\n         * @param {number} fn The function to execute.  The signature of the function is: (data, rowIndex, columnName).\n         * @param {number} expandToRow When true the data in the array is expanded to the entire row.\n         */\n        self.forEachSelectedCell = function (fn, expandToRow) {\n            var d = [], s = expandToRow ? self.getSchema() : self.getVisibleSchema(), l = self.data.length;\n            self.selections.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) {\n                    d[index] = null;\n                    return;\n                }\n                d[index] = {};\n                row.forEach(function (col) {\n                    if (col === -1 || !s[col]) { return; }\n                    fn(self.data, index, s[col].name);\n                });\n            });\n        };\n        /**\n         * Selects a column.\n         * @memberof canvasDatagrid\n         * @name selectColumn\n         * @method\n         * @param {number} columnIndex The column index to select.\n         * @param {boolean} toggleSelectMode When true, behaves as if you were holding control/command when you clicked the column.\n         * @param {boolean} shift When true, behaves as if you were holding shift when you clicked the column.\n         * @param {boolean} supressSelectionchangedEvent When true, prevents the selectionchanged event from firing.\n         */\n        self.selectColumn = function (columnIndex, ctrl, shift, supressEvent) {\n            var s, e, x;\n            function addCol(i) {\n                self.data.forEach(function (row, rowIndex) {\n                    self.selections[rowIndex] = self.selections[rowIndex] || [];\n                    if (self.selections[rowIndex].indexOf(i) === -1) {\n                        self.selections[rowIndex].push(i);\n                    }\n                });\n            }\n            function removeCol(i) {\n                self.data.forEach(function (row, rowIndex) {\n                    self.selections[rowIndex] = self.selections[rowIndex] || [];\n                    if (self.selections[rowIndex].indexOf(i) !== -1) {\n                        self.selections[rowIndex].splice(self.selections[rowIndex].indexOf(i), 1);\n                    }\n                });\n            }\n            if (shift) {\n                if (!self.activeCell) { return; }\n                s = Math.min(self.activeCell.columnIndex, columnIndex);\n                e = Math.max(self.activeCell.columnIndex, columnIndex);\n                for (x = s; e > x; x += 1) {\n                    addCol(x);\n                }\n            }\n            if (!ctrl && !shift) {\n                self.selections = [];\n                self.activeCell.columnIndex = columnIndex;\n                self.activeCell.rowIndex = self.scrollIndexTop;\n            }\n            if (ctrl && self.isColumnSelected(columnIndex)) {\n                removeCol(columnIndex);\n            } else {\n                addCol(columnIndex);\n            }\n            if (supressEvent) { return; }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.getSelectionBounds()\n            });\n        };\n        /**\n         * Selects a row.\n         * @memberof canvasDatagrid\n         * @name selectRow\n         * @method\n         * @param {number} rowIndex The row index to select.\n         * @param {boolean} ctrl When true, behaves as if you were holding control/command when you clicked the row.\n         * @param {boolean} shift When true, behaves as if you were holding shift when you clicked the row.\n         * @param {boolean} supressSelectionchangedEvent When true, prevents the selectionchanged event from firing.\n         */\n        self.selectRow = function (rowIndex, ctrl, shift, supressEvent) {\n            var x, st, en, s = self.getVisibleSchema();\n            function addRow(ri) {\n                self.selections[ri] = [];\n                self.selections[ri].push(-1);\n                s.forEach(function (col, index) {\n                    self.selections[ri].push(index);\n                });\n            }\n            if (self.dragAddToSelection === false || self.dragObject === undefined) {\n                if (self.selections[rowIndex] && self.selections[rowIndex].length - 1 === s.length) {\n                    if (ctrl) {\n                        self.selections[rowIndex] = [];\n                        return;\n                    }\n                }\n            }\n            if (self.dragAddToSelection === true || self.dragObject === undefined) {\n                if (shift && self.dragObject === undefined) {\n                    if (!self.activeCell) { return; }\n                    st = Math.min(self.activeCell.rowIndex, rowIndex);\n                    en = Math.max(self.activeCell.rowIndex, rowIndex);\n                    for (x = st; en >= x; x += 1) {\n                        addRow(x);\n                    }\n                } else {\n                    addRow(rowIndex);\n                }\n            }\n            if (supressEvent) { return; }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n        };\n        /**\n         * Collapse a tree grid by row index.\n         * @memberof canvasDatagrid\n         * @name collapseTree\n         * @method\n         * @param {number} index The index of the row to collapse.\n         */\n        self.collapseTree = function (rowIndex) {\n            var rowId = self.data[rowIndex][self.uniqueId];\n            self.dispatchEvent('collapsetree', {\n                childGrid: self.childGrids[rowId],\n                data: self.data[rowIndex],\n                rowIndex: rowIndex\n            });\n            self.openChildren[rowId].blur();\n            self.openChildren[rowId].dispose();\n            delete self.openChildren[rowId];\n            delete self.sizes.trees[rowId];\n            delete self.childGrids[rowId];\n            self.dispatchEvent('resizerow', {\n                cellHeight: self.style.cellHeight\n            });\n            self.resize(true);\n            self.draw(true);\n        };\n        /**\n         * Expands a tree grid by row index.\n         * @memberof canvasDatagrid\n         * @name expandTree\n         * @method\n         * @param {number} index The index of the row to expand.\n         */\n        self.expandTree = function (rowIndex) {\n            var trArgs = self.args.treeGridAttributes || {},\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.sizes.columns.cornerCell || self.style.rowHeaderCellWidth,\n                rowId = self.data[rowIndex][self.uniqueId],\n                h = self.sizes.trees[rowId] || self.style.treeGridHeight,\n                treeGrid;\n            if (!self.childGrids[rowId]) {\n                trArgs.debug = self.attributes.debug;\n                trArgs.name = self.attributes.saveAppearance ? self.attributes.name + 'tree' + rowId : undefined;\n                trArgs.style = trArgs.style || self.style;\n                trArgs.parentNode = {\n                    parentGrid: self.intf,\n                    nodeType: 'canvas-datagrid-tree',\n                    offsetHeight: h,\n                    offsetWidth: self.width - rowHeaderCellWidth,\n                    header: { width: self.width - rowHeaderCellWidth },\n                    offsetLeft: rowHeaderCellWidth,\n                    offsetTop: columnHeaderCellHeight,\n                    offsetParent: self.intf.parentNode,\n                    parentNode: self.intf.parentNode,\n                    style: 'tree',\n                    data: self.data[rowIndex]\n                };\n                treeGrid = self.createGrid(trArgs);\n                self.childGrids[rowId] = treeGrid;\n            }\n            treeGrid = self.childGrids[rowId];\n            treeGrid.visible = true;\n            self.dispatchEvent('expandtree', {\n                treeGrid: treeGrid,\n                data: self.data[rowIndex],\n                rowIndex: rowIndex\n            });\n            self.openChildren[rowId] = treeGrid;\n            self.sizes.trees[rowId] = h;\n            self.dispatchEvent('resizerow', {height: self.style.cellHeight});\n            self.resize(true);\n        };\n        /**\n         * Toggles tree grid open and close by row index.\n         * @memberof canvasDatagrid\n         * @name toggleTree\n         * @method\n         * @param {number} index The index of the row to toggle.\n         */\n        self.toggleTree = function (rowIndex) {\n            var i = self.openChildren[self.data[rowIndex][self.uniqueId]];\n            if (i) {\n                return self.collapseTree(rowIndex);\n            }\n            self.expandTree(rowIndex);\n        };\n        /**\n         * Returns a header from the schema by name.\n         * @memberof canvasDatagrid\n         * @name getHeaderByName\n         * @tutorial schema\n         * @method\n         * @returns {header} header with the selected name, or undefined.\n         * @param {string} name The name of the column to resize.\n         */\n        self.getHeaderByName = function (name) {\n            var x, i = self.getSchema();\n            for (x = 0; x < i.length; x += 1) {\n                if (i[x].name === name) {\n                    return i[x];\n                }\n            }\n        };\n        /**\n         * Resizes a column to fit the longest value in the column. Call without a value to resize all columns.\n         * Warning, can be slow on very large record sets (1m records ~3-5 seconds on an i7).\n         * @memberof canvasDatagrid\n         * @name fitColumnToValues\n         * @method\n         * @param {string} name The name of the column to resize.\n         */\n        self.fitColumnToValues = function (name, internal) {\n            if (!self.canvas) { return; }\n            self.sizes.columns[name === 'cornerCell' ? name : self.getHeaderByName(name)[self.uniqueId]]\n                = self.findColumnMaxTextLength(name);\n            if (!internal) {\n                self.resize();\n                self.draw(true);\n            }\n        };\n        /**\n         * Checks if a cell is currently visible.\n         * @memberof canvasDatagrid\n         * @name isCellVisible\n         * @overload\n         * @method\n         * @returns {boolean} when true, the cell is visible, when false the cell is not currently drawn.\n         * @param {number} columnIndex The column index of the cell to check.\n         * @param {number} rowIndex The row index of the cell to check.\n         */\n        /**\n         * Checks if a cell is currently visible.\n         * @memberof canvasDatagrid\n         * @name isCellVisible\n         * @method\n         * @returns {boolean} when true, the cell is visible, when false the cell is not currently drawn.\n         * @param {cell} cell The cell to check for.  Alternatively you can pass an object { x: <x-pixel-value>, y: <y-pixel-value> }.\n         */\n        self.isCellVisible = function (cell, rowIndex) {\n            // overload\n            if (rowIndex !== undefined) {\n                return self.visibleCells.filter(function (c) {\n                    return c.columnIndex === cell && c.rowIndex === rowIndex;\n                }).length > 0;\n            }\n            var x, l = self.visibleCells.length;\n            for (x = 0; x < l; x += 1) {\n                if (cell.x === self.visibleCells[x].x && cell.y === self.visibleCells[x].y) {\n                    return true;\n                }\n            }\n            return false;\n        };\n        /**\n         * Sets the order of the data.\n         * @memberof canvasDatagrid\n         * @name order\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} columnName Name of the column to be sorted.\n         * @param {string} direction `asc` for ascending or `desc` for descending.\n         * @param {function} [sortFunction] When defined, override the default sorting method defined in the column's schema and use this one.\n         * @param {bool} [dontSetStorageData] Don't store this setting for future use.\n         */\n        self.order = function (columnName, direction, sortFunction, dontSetStorageData) {\n            var f,\n                c = self.getSchema().filter(function (col) {\n                    return col.name === columnName;\n                });\n            self.orderBy = columnName;\n            if (c.length === 0) {\n                throw new Error('Cannot sort.  No such column name');\n            }\n            f = sortFunction || self.sorters[c[0].type];\n            if (!f && c[0].type !== undefined) {\n                console.warn('Cannot sort type \"%s\" falling back to string sort.', c[0].type);\n            }\n            self.data = self.data.sort(typeof f === 'function' ? f(columnName, direction) : self.sorters.string);\n            self.dispatchEvent('ordercolumn', {name: columnName, direction: direction});\n            self.draw(true);\n            if (dontSetStorageData) { return; }\n            self.setStorageData();\n        };\n        self.isInGrid = function (e) {\n            if (e.x < 0\n                    || e.x > self.width\n                    || e.y < 0\n                    || e.y > self.height) {\n                return false;\n            }\n            return true;\n        };\n        /**\n         * Moves the current selection relative to the its current position.  Note: this method does not move the selected data, just the selection itself.\n         * @memberof canvasDatagrid\n         * @name moveSelection\n         * @method\n         * @param {number} offsetX The number of columns to offset the selection.\n         * @param {number} offsetY The number of rows to offset the selection.\n         */\n        self.moveSelection = function (offsetX, offsetY) {\n            var sel = [];\n            self.selections.forEach(function (row, rowIndex) {\n                sel[rowIndex + offsetY] = [];\n                row.forEach(function (colIndex) {\n                    sel[rowIndex + offsetY].push(colIndex + offsetX);\n                });\n            });\n            self.selections = sel;\n        };\n        /**\n         * Moves data in the provided selection to another position in the grid.  Moving data off the edge of the schema (columns/x) will truncate data.\n         * @memberof canvasDatagrid\n         * @name moveTo\n         * @method\n         * @param {array} sel 2D array representing selected rows and columns.  `canvasDatagrid.selections` is in this format and can be used here.\n         * @param {number} x The column index to start inserting the selection at.\n         * @param {number} y The row index to start inserting the selection at.\n         */\n        self.moveTo = function (sel, x, y) {\n            var d = self.getSelectedData(),\n                s = self.getVisibleSchema(),\n                l = sel.length,\n                xi,\n                yi = y - 1;\n            sel.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) { return; }\n                row.forEach(function (col) {\n                    if (!s[col]) { return; }\n                    self.data[index][s[col].name] = null;\n                });\n            });\n            sel.forEach(function (row, index) {\n                yi += 1;\n                xi = x - 1;\n                row.forEach(function (col, cidx) {\n                    xi += 1;\n                    if (col === -1\n                            || !s[xi]\n                            || !s[col]\n                            || self.data.length - 1 < yi\n                            || yi < 0) { return; }\n                    self.data[yi][s[xi].name] = d[index][s[col].name];\n                });\n            });\n        };\n        /**\n         * Checks if a given column is visible.\n         * @memberof canvasDatagrid\n         * @name isColumnVisible\n         * @method\n         * @returns {boolean} When true, the column is visible.\n         * @param {number} columnIndex Column index.\n         */\n        self.isColumnVisible = function (columnIndex) {\n            return self.visibleCells.filter(function (c) {\n                return c.columnIndex === columnIndex;\n            }).length > 0;\n        };\n        /**\n         * Checks if a given row is visible.\n         * @memberof canvasDatagrid\n         * @name isRowVisible\n         * @method\n         * @returns {boolean} When true, the row is visible.\n         * @param {number} rowIndex Row index.\n         */\n        self.isRowVisible = function (rowIndex) {\n            return self.visibleCells.filter(function (c) {\n                return c.rowIndex === rowIndex;\n            }).length > 0;\n        };\n        /**\n         * Gets the cell at columnIndex and rowIndex.\n         * @memberof canvasDatagrid\n         * @name getVisibleCellByIndex\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} x Column index.\n         * @param {number} y Row index.\n         */\n        self.getVisibleCellByIndex = function (x, y) {\n            return self.visibleCells.filter(function (c) {\n                return c.columnIndex === x && c.rowIndex === y;\n            })[0];\n        };\n        /**\n         * Gets the cell at grid pixel coordinate x and y.  Author's note.  This function ties drawing and events together.  This is a very complex function and is core to the component.\n         * @memberof canvasDatagrid\n         * @name getCellAt\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} x Number of pixels from the left.\n         * @param {number} y Number of pixels from the top.\n         */\n        self.getCellAt = function (x, y, useTouchScrollZones) {\n            function getBorder(cell) {\n                if (cell.x + cell.width - (self.attributes.borderResizeZone * 0.4) < x && cell.x + cell.width + (self.attributes.borderResizeZone * 0.6) > x) {\n                    return 'r';\n                }\n                if (cell.x - (self.attributes.borderResizeZone * 0.4) < x && cell.x + (self.attributes.borderResizeZone * 0.6) > x) {\n                    return 'l';\n                }\n                if (cell.y + cell.height - (self.attributes.borderResizeZone * 0.4) < y && cell.y + cell.height + (self.attributes.borderResizeZone * 0.6) > y) {\n                    return 'b';\n                }\n                if (cell.y - (self.attributes.borderResizeZone * 0.4) < y && cell.y + (self.attributes.borderResizeZone * 0.6) > y) {\n                    return 't';\n                }\n            }\n            if (!self.visibleCells) { return; }\n            var border,\n                tsz = useTouchScrollZones ? self.attributes.touchScrollZone : 0,\n                moveMode = self.attributes.borderDragBehavior === 'move',\n                i,\n                l = self.visibleCells.length,\n                moveBorder,\n                xBorderBehavior = moveMode ? self.cursorGrab : 'ew-resize',\n                yBorderBehavior = moveMode ? self.cursorGrab : 'ns-resize',\n                cell;\n            if (!self.visibleCells || !self.visibleCells.length) { return; }\n            self.hasFocus = true;\n            if (!(y < self.height\n                && y > 0\n                && x < self.width\n                && x > 0)) {\n                self.hasFocus = false;\n                return {\n                    dragContext: 'inherit',\n                    context: 'inherit'\n                };\n            }\n            for (i = 0; i < l; i += 1) {\n                cell = self.visibleCells[i];\n                if (useTouchScrollZones && /(vertical|horizontal)-scroll-/.test(cell.style)) {\n                    cell.x -= tsz;\n                    cell.y -= tsz;\n                    cell.height += tsz;\n                    cell.width += tsz;\n                }\n                if (cell.x - self.style.cellBorderWidth < x\n                        && cell.x + cell.width + self.style.cellBorderWidth > x\n                        && cell.y - self.style.cellBorderWidth < y\n                        && cell.y + cell.height + self.style.cellBorderWidth > y) {\n                    if (/frozen-row-marker/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'row-resize';\n                        return cell;\n                    }\n                    if (/frozen-column-marker/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'col-resize';\n                        return cell;\n                    }\n                    if (/selection-handle-/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'crosshair';\n                        return cell;\n                    }\n                    if (/vertical-scroll-(bar|box)/.test(cell.style)) {\n                        cell.dragContext = 'vertical-scroll-box';\n                        cell.context = 'vertical-scroll-box';\n                        cell.isScrollBar = true;\n                        cell.isVerticalScrollBar = true;\n                        if (y > self.scrollBox.box.v.y + self.scrollBox.scrollBoxHeight) {\n                            cell.dragContext = 'vertical-scroll-bottom';\n                            cell.context = 'vertical-scroll-bottom';\n                        } else if (y < self.scrollBox.box.v.y) {\n                            cell.dragContext = 'vertical-scroll-top';\n                            cell.context = 'vertical-scroll-top';\n                        }\n                        self.cursor = 'default';\n                        return cell;\n                    }\n                    if (/horizontal-scroll-(bar|box)/.test(cell.style)) {\n                        cell.dragContext = 'horizontal-scroll-box';\n                        cell.context = 'horizontal-scroll-box';\n                        cell.isScrollBar = true;\n                        cell.isHorizontalScrollBar = true;\n                        if (x > self.scrollBox.box.h.x + self.scrollBox.scrollBoxWidth) {\n                            cell.dragContext = 'horizontal-scroll-right';\n                            cell.context = 'horizontal-scroll-right';\n                        } else if (x < self.scrollBox.box.h.x) {\n                            cell.dragContext = 'horizontal-scroll-left';\n                            cell.context = 'horizontal-scroll-left';\n                        }\n                        self.cursor = 'default';\n                        return cell;\n                    }\n                    border = getBorder(cell);\n                    // check if the border of this cell is the border of the selection and if so show move cursor in move mode\n                    moveBorder = moveMode && cell.selectionBorder && cell.selectionBorder.indexOf(border) !== -1;\n                    if (['l', 'r'].indexOf(border) !== -1\n                            && (self.attributes.allowColumnResize || moveBorder)\n                            && ((self.attributes.allowColumnResizeFromCell && cell.isNormal) || !cell.isNormal || moveBorder)\n                            && ((self.attributes.allowRowHeaderResize && (cell.isRowHeader || cell.isCorner)) || !(cell.isRowHeader && cell.isCorner))) {\n                        if (((cell.isColumnHeader || cell.isCorner) || (self.attributes.allowColumnResizeFromCell && cell.isNormal)) && border === 'r') {\n                            cell.context = 'ew-resize';\n                            cell.dragContext = 'ew-resize';\n                            return cell;\n                        }\n                        if (!(cell.isColumnHeader || cell.isCorner) && moveBorder) {\n                            cell.context = xBorderBehavior;\n                            cell.dragContext = border + '-move';\n                            return cell;\n                        }\n                    }\n                    if (['t', 'b'].indexOf(border) !== -1\n                            && cell.rowIndex > -1\n                            && (self.attributes.allowRowResize || moveBorder)\n                            && ((self.attributes.allowRowResizeFromCell && cell.isNormal) || !cell.isNormal || moveBorder)\n                            && !cell.isColumnHeader) {\n                        if (((cell.isRowHeader || cell.isCorner) || (self.attributes.allowRowResizeFromCell && cell.isNormal)) && border === 'b') {\n                            cell.context = 'ns-resize';\n                            cell.dragContext = 'ns-resize';\n                            return cell;\n                        }\n                        if (!(cell.isRowHeader || cell.isCorner) && moveBorder) {\n                            cell.context = yBorderBehavior;\n                            cell.dragContext = border + '-move';\n                            return cell;\n                        }\n                    }\n                    if (cell.style === 'columnHeaderCell') {\n                        cell.context = 'cell';\n                        cell.dragContext = 'column-reorder';\n                        return cell;\n                    }\n                    if (cell.style === 'rowHeaderCell') {\n                        if ((self.attributes.rowGrabZoneSize + (cell.y - self.style.cellBorderWidth) < y)\n                                || !self.attributes.allowRowReordering) {\n                            cell.dragContext = 'cell';\n                            cell.context = 'cell';\n                        } else {\n                            cell.context = self.cursorGrab;\n                            cell.dragContext = 'row-reorder';\n                        }\n                        return cell;\n                    }\n                    if (cell.isGrid) {\n                        self.hasFocus = false;\n                        cell.dragContext = 'cell-grid';\n                        cell.context = 'cell-grid';\n                        return cell;\n                    }\n                    if (cell.style === 'tree-grid') {\n                        self.hasFocus = false;\n                        cell.dragContext = 'tree';\n                        cell.context = 'tree';\n                        return cell;\n                    }\n                    cell.dragContext = 'cell';\n                    cell.context = 'cell';\n                    return cell;\n                }\n            }\n            self.hasFocus = true;\n            self.cursor = 'default';\n            return {\n                dragContext: 'background',\n                context: 'background',\n                style: 'background',\n                isBackground: true\n            };\n        };\n        /**\n         * Gets the bounds of current selection. \n         * @returns {rect} selection.\n         * @memberof canvasDatagrid\n         * @name getSelectionBounds\n         * @method\n         */\n        self.getSelectionBounds = function () {\n            var low = {x: Infinity, y: Infinity},\n                high = {x: -Infinity, y: -Infinity};\n            self.data.forEach(function (row, rowIndex) {\n                var maxCol, minCol;\n                if (self.selections[rowIndex] && self.selections[rowIndex].length) {\n                    low.y = rowIndex < low.y ? rowIndex : low.y;\n                    high.y = rowIndex > high.y ? rowIndex : high.y;\n                    maxCol = Math.max.apply(null, self.selections[rowIndex]);\n                    minCol = Math.min.apply(null, self.selections[rowIndex]);\n                    low.x = minCol < low.x ? minCol : low.x;\n                    high.x = maxCol > high.x ? maxCol : high.x;\n                }\n            });\n            return {\n                top: low.y,\n                left: low.x,\n                bottom: high.y,\n                right: high.x\n            };\n        };\n        /**\n         * Returns an auto generated schema based on data structure.\n         * @memberof canvasDatagrid\n         * @name getSchemaFromData\n         * @method\n         * @tutorial schema\n         * @returns {schema} schema A schema based on the first item in the data array.\n         */\n        self.getSchemaFromData = function () {\n            return Object.keys(self.data[0] || {' ': ''}).map(function mapEachSchemaColumn(key, index) {\n                var type = self.getBestGuessDataType(key),\n                    i = {\n                        name: key,\n                        title: isNaN(parseInt(key, 10)) ? key : self.integerToAlpha(key).toUpperCase(),\n                        index: index,\n                        type: type,\n                        filter: self.filter(type)\n                    };\n                if (key === self.uniqueId) {\n                    i.hidden = true;\n                }\n                if (self.storedSettings && self.storedSettings.visibility[i.name] !== undefined) {\n                    i.hidden = !self.storedSettings.visibility[i.name];\n                }\n                i[self.uniqueId] = self.getSchemaNameHash(key);\n                return i;\n            });\n        };\n        /**\n         * Clears the change log grid.changes that keeps track of changes to the data set.\n         * This does not undo changes or alter data it is simply a convince array to keep\n         * track of changes made to the data since last this method was called.\n         * @memberof canvasDatagrid\n         * @name clearChangeLog\n         * @method\n         */\n        self.clearChangeLog = function () {\n            self.changes = [];\n        };\n        /**\n         * Selects an area of the grid.\n         * @memberof canvasDatagrid\n         * @name selectArea\n         * @method\n         * @param {rect} bounds A rect object representing the selected values.\n         */\n        self.selectArea = function (bounds, ctrl) {\n            self.selectionBounds = bounds || self.selectionBounds;\n            var x, y, s = self.getSchema();\n            if (!ctrl) {\n                self.selections = [];\n            }\n            if (self.selectionBounds.top < -1\n                    || self.selectionBounds.bottom > self.data.length\n                    || self.selectionBounds.left < -1\n                    || self.selectionBounds.right > s.length) {\n                throw new Error('Impossible selection area');\n            }\n            for (x = self.selectionBounds.top; x <= self.selectionBounds.bottom; x += 1) {\n                self.selections[x] = [];\n                for (y = self.selectionBounds.left; y <= self.selectionBounds.right; y += 1) {\n                    if (self.selections[x].indexOf(y) === -1) {\n                        self.selections[x].push(y);\n                    }\n                }\n            }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n        };\n        /**\n         * Returns the maximum text width for a given column by column name.\n         * @memberof canvasDatagrid\n         * @name findColumnMaxTextLength\n         * @method\n         * @returns {number} The number of pixels wide the maximum width value in the selected column.\n         * @param {string} name The name of the column to calculate the value's width of.\n         */\n        self.findColumnMaxTextLength = function (name) {\n            var m = -Infinity;\n            if (name === 'cornerCell') {\n                self.ctx.font = self.style.rowHeaderCellFont;\n                return self.ctx.measureText((self.data.length + (self.attributes.showNewRow ? 1 : 0)).toString()).width\n                    + self.style.autosizePadding + self.style.autosizeHeaderCellPadding\n                    + self.style.rowHeaderCellPaddingRight\n                    + self.style.rowHeaderCellPaddingLeft\n                    + (self.attributes.tree ? self.style.treeArrowWidth\n                        + self.style.treeArrowMarginLeft + self.style.treeArrowMarginRight : 0);\n            }\n            self.getSchema().forEach(function (col) {\n                if (col.name !== name) { return; }\n                self.ctx.font = self.style.columnHeaderCellFont;\n                var t = self.ctx.measureText(col.title || col.name).width\n                    + self.style.headerCellPaddingRight\n                    + self.style.headerCellPaddingLeft;\n                m = t > m ? t : m;\n            });\n            self.data.forEach(function (row) {\n                self.ctx.font = self.style.cellFont;\n                var t = self.ctx.measureText(row[name]).width\n                    + self.style.cellPaddingRight\n                    + self.style.cellPaddingLeft + self.style.cellAutoResizePadding;\n                m = t > m ? t : m;\n            });\n            return m;\n        };\n        /**\n         * Gets the total width of all header columns.\n         * @memberof canvasDatagrid\n         * @name getHeaderWidth\n         * @method\n         */\n        self.getHeaderWidth = function () {\n            return self.getVisibleSchema().reduce(function (total, header) {\n                return total + (header.width || self.style.cellWidth);\n            }, 0);\n        };\n        self.formatters.string = function cellFormatterString(e) {\n            return e.cell.value !== undefined ? e.cell.value : '';\n        };\n        self.formatters.rowHeaderCell = self.formatters.string;\n        self.formatters.headerCell = self.formatters.string;\n        self.formatters.number = self.formatters.string;\n        self.formatters.int = self.formatters.string;\n        self.formatters.html = self.formatters.string;\n        self.sorters.string = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (a[columnName] === undefined || a[columnName] === null) {\n                    return 1;\n                }\n                if (b[columnName] === undefined || b[columnName] === null) {\n                    return 0;\n                }\n                if (asc) {\n                    if (!a[columnName].localeCompare) { return 1; }\n                    return a[columnName].localeCompare(b[columnName]);\n                }\n                if (!b[columnName].localeCompare) { return 1; }\n                return b[columnName].localeCompare(a[columnName]);\n            };\n        };\n        self.sorters.number = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (asc) {\n                    return a[columnName] - b[columnName];\n                }\n                return b[columnName] - a[columnName];\n            };\n        };\n        self.sorters.date = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (asc) {\n                    return new Date(a[columnName]).getTime()\n                        - new Date(b[columnName]).getTime();\n                }\n                return new Date(b[columnName]).getTime()\n                        - new Date(a[columnName]).getTime();\n            };\n        };\n    };\n}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n\n/***/ })\n/******/ ]);\n});\n\n\n// WEBPACK FOOTER //\n// canvas-datagrid.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap ef48c86715f3e382e77c","/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        self.defaults = {\n            attributes: [\n                ['allowColumnReordering', true],\n                ['allowColumnResize', true],\n                ['allowColumnResizeFromCell', false],\n                ['allowFreezingRows', false],\n                ['allowFreezingColumns', false],\n                ['allowMovingSelection', true],\n                ['allowRowHeaderResize', true],\n                ['allowRowReordering', false],\n                ['allowRowResize', true],\n                ['allowRowResizeFromCell', false],\n                ['allowSorting', true],\n                ['autoResizeColumns', false],\n                ['borderDragBehavior', 'none'],\n                ['borderResizeZone', 10],\n                ['clearSettingsOptionText', 'Clear saved settings'],\n                ['columnHeaderClickBehavior', 'sort'],\n                ['columnSelectorHiddenText', '&nbsp;&nbsp;&nbsp;'],\n                ['columnSelectorText', 'Add/Remove columns'],\n                ['columnSelectorVisibleText', '\\u2713'],\n                ['contextHoverScrollAmount', 2],\n                ['contextHoverScrollRateMs', 5],\n                ['copyText', 'Copy'],\n                ['debug', false],\n                ['editable', true],\n                ['filterOptionText', 'Filter %s'],\n                ['filterTextPrefix', '(filtered) '],\n                ['globalRowResize', false],\n                ['hideColumnText', 'Hide %s'],\n                ['maxAutoCompleteItems', 200],\n                ['multiLine', false],\n                ['name', ''],\n                ['pageUpDownOverlap', 1],\n                ['pasteText', 'Paste'],\n                ['persistantSelectionMode', false],\n                ['removeFilterOptionText', 'Remove filter on %s'],\n                ['reorderDeadZone', 3],\n                ['resizeScrollZone', 20],\n                ['rowGrabZoneSize', 5],\n                ['saveAppearance', true],\n                ['scrollAnimationPPSThreshold', 0.75],\n                ['scrollPointerLock', false],\n                ['scrollRepeatRate', 75],\n                ['selectionFollowsActiveCell', false],\n                ['selectionHandleBehavior', 'none'],\n                ['selectionMode', 'cell'],\n                ['selectionScrollIncrement', 20],\n                ['selectionScrollZone', 20],\n                ['showClearSettingsOption', true],\n                ['showColumnHeaders', true],\n                ['showColumnSelector', true],\n                ['showCopy', true],\n                ['showFilter', true],\n                ['showNewRow', false],\n                ['showOrderByOption', true],\n                ['showOrderByOptionTextAsc', 'Order by %s ascending'],\n                ['showOrderByOptionTextDesc', 'Order by %s descending'],\n                ['showPaste', false],\n                ['showPerformance', false],\n                ['showRowHeaders', true],\n                ['showRowNumbers', true],\n                ['snapToRow', false],\n                ['touchContextMenuTimeMs', 800],\n                ['touchDeadZone', 3],\n                ['touchEasingMethod', 'easeOutQuad'],\n                ['touchReleaseAcceleration', 1000],\n                ['touchReleaseAnimationDurationMs', 2000],\n                ['touchScrollZone', 20],\n                ['touchSelectHandleZone', 20],\n                ['touchZoomSensitivity', 0.005],\n                ['touchZoomMin', 0.5],\n                ['touchZoomMax', 1.75],\n                ['maxPixelRatio', 1],\n                ['tree', false],\n                ['treeHorizontalScroll', false]\n            ],\n            styles: [\n                ['activeCellBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['activeCellBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['activeCellBorderWidth', 1],\n                ['activeCellColor', 'rgba(0, 0, 0, 1)'],\n                ['activeCellFont', '16px sans-serif'],\n                ['activeCellHoverBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['activeCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['activeCellOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['activeCellOverlayBorderWidth', 1],\n                ['activeCellPaddingBottom', 5],\n                ['activeCellPaddingLeft', 5],\n                ['activeCellPaddingRight', 7],\n                ['activeCellPaddingTop', 5],\n                ['activeCellSelectedBackgroundColor', 'rgba(236, 243, 255, 1)'],\n                ['activeCellSelectedColor', 'rgba(0, 0, 0, 1)'],\n                ['activeColumnHeaderCellBackgroundColor', 'rgba(225, 225, 225, 1)'],\n                ['activeColumnHeaderCellColor', 'rgba(0, 0, 0, 1)'],\n                ['activeRowHeaderCellBackgroundColor', 'rgba(225, 225, 225, 1)'],\n                ['activeRowHeaderCellColor', 'rgba(0, 0, 0, 1)'],\n                ['autocompleteBottomMargin', 60],\n                ['autosizeHeaderCellPadding', 8],\n                ['autosizePadding', 5],\n                ['cellAutoResizePadding', 13],\n                ['cellBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['cellBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['cellBorderWidth', 1],\n                ['cellColor', 'rgba(0, 0, 0, 1)'],\n                ['cellFont', '16px sans-serif'],\n                ['cellGridHeight', 250],\n                ['cellHeight', 24],\n                ['cellHeightWithChildGrid', 150],\n                ['cellHorizontalAlignment', 'left'],\n                ['cellHoverBackgroundColor', 'rgba(255, 255, 255, 1)'],\n                ['cellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['cellPaddingBottom', 5],\n                ['cellPaddingLeft', 5],\n                ['cellPaddingRight', 7],\n                ['cellPaddingTop', 5],\n                ['cellSelectedBackgroundColor', 'rgba(236, 243, 255, 1)'],\n                ['cellSelectedColor', 'rgba(0, 0, 0, 1)'],\n                ['cellVerticalAlignment', 'center'],\n                ['cellWidth', 250],\n                ['cellWidthWithChildGrid', 250],\n                ['childContextMenuArrowColor', 'rgba(43, 48, 43, 1)'],\n                ['childContextMenuArrowHTML', '&#x25BA;'],\n                ['childContextMenuMarginLeft', -11],\n                ['childContextMenuMarginTop', -6],\n                ['columnHeaderCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['columnHeaderCellBorderColor', 'rgba(172, 172, 172, 1)'],\n                ['columnHeaderCellBorderWidth', 1],\n                ['columnHeaderCellColor', 'rgba(50, 50, 50, 1)'],\n                ['columnHeaderCellFont', '16px sans-serif'],\n                ['columnHeaderCellHeight', 25],\n                ['columnHeaderCellHorizontalAlignment', 'left'],\n                ['columnHeaderCellHoverBackgroundColor', 'rgba(235, 235, 235, 1)'],\n                ['columnHeaderCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['columnHeaderCellPaddingBottom', 5],\n                ['columnHeaderCellPaddingLeft', 5],\n                ['columnHeaderCellPaddingRight', 7],\n                ['columnHeaderCellPaddingTop', 5],\n                ['columnHeaderCellVerticalAlignment', 'center'],\n                ['columnHeaderOrderByArrowBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['columnHeaderOrderByArrowBorderWidth', 1],\n                ['columnHeaderOrderByArrowColor', 'rgba(155, 155, 155, 1)'],\n                ['columnHeaderOrderByArrowHeight', 8],\n                ['columnHeaderOrderByArrowMarginLeft', 0],\n                ['columnHeaderOrderByArrowMarginRight', 5],\n                ['columnHeaderOrderByArrowMarginTop', 6],\n                ['columnHeaderOrderByArrowWidth', 13],\n                ['contextFilterButtonBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextFilterButtonBorderRadius', '3px'],\n                ['contextFilterButtonHTML', '&#x25BC;'],\n                ['contextFilterInputBackground', 'rgba(255,255,255,1)'],\n                ['contextFilterInputBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextFilterInputBorderRadius', '0'],\n                ['contextFilterInputColor', 'rgba(0,0,0,1)'],\n                ['contextFilterInputFontFamily', 'sans-serif'],\n                ['contextFilterInputFontSize', '14px'],\n                ['contextFilterInvalidRegExpBackground', 'rgba(180, 6, 1, 1)'],\n                ['contextFilterInvalidRegExpColor', 'rgba(255, 255, 255, 1)'],\n                ['contextMenuArrowColor', 'rgba(43, 48, 43, 1)'],\n                ['contextMenuArrowDownHTML', '&#x25BC;'],\n                ['contextMenuArrowUpHTML', '&#x25B2;'],\n                ['contextMenuBackground', 'rgba(240, 240, 240, 1)'],\n                ['contextMenuBorder', 'solid 1px rgba(158, 163, 169, 1)'],\n                ['contextMenuBorderRadius', '3px'],\n                ['contextMenuChildArrowFontSize', '12px'],\n                ['contextMenuColor', 'rgba(43, 48, 43, 1)'],\n                ['contextMenuFilterButtonFontFamily', 'sans-serif'],\n                ['contextMenuFilterButtonFontSize', '10px'],\n                ['contextMenuFilterInvalidExpresion', 'rgba(237, 155, 156, 1)'],\n                ['contextMenuFontFamily', 'sans-serif'],\n                ['contextMenuFontSize', '16px'],\n                ['contextMenuHoverBackground', 'rgba(182, 205, 250, 1)'],\n                ['contextMenuHoverColor', 'rgba(43, 48, 153, 1)'],\n                ['contextMenuItemBorderRadius', '3px'],\n                ['contextMenuItemMargin', '2px'],\n                ['contextMenuLabelDisplay', 'inline-block'],\n                ['contextMenuLabelMargin', '0 3px 0 0'],\n                ['contextMenuLabelMaxWidth', '700px'],\n                ['contextMenuLabelMinWidth', '75px'],\n                ['contextMenuMarginLeft', 3],\n                ['contextMenuMarginTop', -3],\n                ['contextMenuOpacity', '0.98'],\n                ['contextMenuPadding', '2px'],\n                ['contextMenuWindowMargin', 100],\n                ['contextMenuZIndex', 10000],\n                ['cornerCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['cornerCellBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['editCellBackgroundColor', 'white'],\n                ['editCellBorder', 'solid 1px rgba(110, 168, 255, 1)'],\n                ['editCellBoxShadow', '0 2px 5px rgba(0,0,0,0.4)'],\n                ['editCellColor', 'black'],\n                ['editCellFontFamily', 'sans-serif'],\n                ['editCellFontSize', '16px'],\n                ['editCellPaddingLeft', 4],\n                ['editCellZIndex', 10000],\n                ['frozenMarkerHoverColor', 'rgba(236, 243, 255, 1)'],\n                ['frozenMarkerHoverBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['frozenMarkerActiveColor', 'rgba(236, 243, 255, 1)'],\n                ['frozenMarkerActiveBorderColor', 'rgba(110, 168, 255, 1)'],\n                ['frozenMarkerColor', 'rgba(222, 222, 222, 1)'],\n                ['frozenMarkerBorderColor', 'rgba(168, 168, 168, 1)'],\n                ['frozenMarkerBorderWidth', 1],\n                ['frozenMarkerWidth', 2],\n                ['gridBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['gridBorderCollapse', 'collapse'],\n                ['gridBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['gridBorderWidth', 1],\n                ['minColumnWidth', 45],\n                ['minRowHeight', 24],\n                ['mobileContextMenuMargin', 10],\n                ['mobileEditInputHeight', 30],\n                ['mobileEditFontFamily', 'sans-serif'],\n                ['mobileEditFontSize', '16px'],\n                ['moveOverlayBorderWidth', 1],\n                ['moveOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['moveOverlayBorderSegments', '12, 7'],\n                ['name', 'default'],\n                ['reorderMarkerBackgroundColor', 'rgba(0, 0, 0, 0.1)'],\n                ['reorderMarkerBorderColor', 'rgba(0, 0, 0, 0.2)'],\n                ['reorderMarkerBorderWidth', 1.25],\n                ['reorderMarkerIndexBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['reorderMarkerIndexBorderWidth', 2.75],\n                ['rowHeaderCellBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['rowHeaderCellBorderColor', 'rgba(200, 200, 200, 1)'],\n                ['rowHeaderCellBorderWidth', 1],\n                ['rowHeaderCellColor', 'rgba(50, 50, 50, 1)'],\n                ['rowHeaderCellFont', '16px sans-serif'],\n                ['rowHeaderCellHeight', 25],\n                ['rowHeaderCellHorizontalAlignment', 'left'],\n                ['rowHeaderCellHoverBackgroundColor', 'rgba(235, 235, 235, 1)'],\n                ['rowHeaderCellHoverColor', 'rgba(0, 0, 0, 1)'],\n                ['rowHeaderCellPaddingBottom', 5],\n                ['rowHeaderCellPaddingLeft', 5],\n                ['rowHeaderCellPaddingRight', 5],\n                ['rowHeaderCellPaddingTop', 5],\n                ['rowHeaderCellSelectedBackgroundColor', 'rgba(217, 217, 217, 1)'],\n                ['rowHeaderCellSelectedColor', 'rgba(50, 50, 50, 1)'],\n                ['rowHeaderCellVerticalAlignment', 'center'],\n                ['rowHeaderCellWidth', 57],\n                ['scrollBarActiveColor', 'rgba(125, 125, 125, 1)'],\n                ['scrollBarBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['scrollBarBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['scrollBarBorderWidth', 0.5],\n                ['scrollBarBoxBorderRadius', 4.125],\n                ['scrollBarBoxColor', 'rgba(192, 192, 192, 1)'],\n                ['scrollBarBoxMargin', 2],\n                ['scrollBarBoxMinSize', 15],\n                ['scrollBarBoxWidth', 8],\n                ['scrollBarCornerBackgroundColor', 'rgba(240, 240, 240, 1)'],\n                ['scrollBarCornerBorderColor', 'rgba(202, 202, 202, 1)'],\n                ['scrollBarWidth', 11],\n                ['selectionHandleBorderColor', 'rgba(255, 255, 255, 1)'],\n                ['selectionHandleBorderWidth', 1.5],\n                ['selectionHandleColor', 'rgba(66, 133, 244, 1)'],\n                ['selectionHandleSize', 8],\n                ['selectionHandleType', 'square'],\n                ['selectionOverlayBorderColor', 'rgba(66, 133, 244, 1)'],\n                ['selectionOverlayBorderWidth', 1],\n                ['treeArrowBorderColor', 'rgba(195, 199, 202, 1)'],\n                ['treeArrowBorderWidth', 1],\n                ['treeArrowClickRadius', 5],\n                ['treeArrowColor', 'rgba(155, 155, 155, 1)'],\n                ['treeArrowHeight', 8],\n                ['treeArrowMarginLeft', 0],\n                ['treeArrowMarginRight', 5],\n                ['treeArrowMarginTop', 6],\n                ['treeArrowWidth', 13],\n                ['treeGridHeight', 250]\n            ]\n        };\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/defaults.js\n// module id = 0\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true, evil: true*/\n/*globals Reflect: false, HTMLElement: true, define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([\n    './component',\n    './defaults',\n    './draw',\n    './events',\n    './touch',\n    './intf',\n    './contextMenu',\n    './dom',\n    './publicMethods'\n], function context(component) {\n    'use strict';\n    component = component();\n    var modules = Array.prototype.slice.call(arguments);\n    function Grid(args) {\n        args = args || {};\n        var self = {};\n        self.isComponent = args.component === undefined;\n        self.isChildGrid = args.parentNode && /canvas-datagrid-(cell|tree)/.test(args.parentNode.nodeType);\n        if (self.isChildGrid) {\n            self.intf = {};\n        } else {\n            self.intf = self.isComponent ? eval('Reflect.construct(HTMLElement, [], new.target)')\n                : document.createElement('section');\n        }\n        self.args = args;\n        self.createGrid = function grid(args) {\n            args.component = false;\n            return new Grid(args);\n        };\n        modules.forEach(function (module) {\n            module(self);\n        });\n        if (self.isChildGrid) {\n            self.shadowRoot = args.parentNode.shadowRoot;\n            self.parentNode = args.parentNode;\n        } else if (self.intf.createShadowRoot) {\n            self.shadowRoot = self.intf.attachShadow({mode: self.args.debug ? 'open' : 'closed'});\n            self.parentNode = self.shadowRoot;\n        } else {\n            self.parentNode = self.intf;\n        }\n        self.init();\n        return self.intf;\n    }\n    if (window.HTMLElement) {\n        Grid.prototype = Object.create(window.HTMLElement.prototype);\n    }\n    // export web component\n    if (window.customElements) {\n        Grid.observedAttributes = component.getObservableAttributes();\n        Grid.prototype.disconnectedCallback = component.disconnectedCallback;\n        Grid.prototype.attributeChangedCallback = component.attributeChangedCallback;\n        Grid.prototype.connectedCallback = component.connectedCallback;\n        Grid.prototype.adoptedCallback = component.adoptedCallback;\n        window.customElements.define('canvas-datagrid', Grid);\n    }\n    // export global\n    if (window && !window.canvasDatagrid && !window.require) {\n        window.canvasDatagrid = function (args) { return new Grid(args); };\n    }\n    // export amd loader\n    module.exports = function grid(args) {\n        args = args || {};\n        var i, tKeys = ['style', 'schema', 'data', 'formatters',\n                    'sorters', 'filters'];\n        if (window.customElements && document.body.createShadowRoot) {\n            i = document.createElement('canvas-datagrid');\n            // create \"block\" element effect\n            i.style.width = '100%';\n            i.style.height = '100%';\n            Object.keys(args).forEach(function (argKey) {\n                if (argKey === 'parentNode') {\n                    args.parentNode.appendChild(i);\n                    return;\n                }\n                // top level keys in args\n                if (tKeys.indexOf(argKey) !== -1) {\n                    tKeys.forEach(function (tKey) {\n                        if (args[tKey] === undefined || tKey !== argKey) { return; }\n                        if (['formatters', 'sorters', 'filters'].indexOf(argKey) !== -1) {\n                            if (typeof args[tKey] === 'object' && args[tKey] !== null) {\n                                Object.keys(args[tKey]).forEach(function (sKey) {\n                                    i[tKey][sKey] = args[tKey][sKey];\n                                });\n                            }\n                        } else {\n                            i[tKey] = args[tKey];\n                        }\n                    });\n                    return;\n                }\n                // all others are attribute level keys\n                i.attributes[argKey] = args[argKey];\n            });\n            return i;\n        }\n        args.component = false;\n        i = new Grid(args);\n        if (args.parentNode && args.parentNode.appendChild) {\n            args.parentNode.appendChild(i);\n        }\n        // create \"block\" element effect\n        i.style.width = '100%';\n        i.style.height = '100%';\n        return i;\n    };\n    return module.exports;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/main.js\n// module id = 1\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine(['./defaults'], function (defaults) {\n    'use strict';\n    return function () {\n        var typeMap, component = {};\n        function hyphenateProperty(prop, cust) {\n            var p = '';\n            Array.prototype.forEach.call(prop, function (char) {\n                if (char === char.toUpperCase()) {\n                    p += '-' + char.toLowerCase();\n                    return;\n                }\n                p += char;\n            });\n            return (cust ? '--cdg-' : '') + p;\n        }\n        function getDefaultItem(base, item) {\n            var i = {},\n                r;\n            defaults(i);\n            r = i.defaults[base].filter(function (i) {\n                return i[0].toLowerCase() === item.toLowerCase()\n                    || hyphenateProperty(i[0]) === item.toLowerCase()\n                    || hyphenateProperty(i[0], true) === item.toLowerCase();\n            })[0];\n            return r;\n        }\n        function applyComponentStyle(supressChangeAndDrawEvents, intf) {\n            var cStyle = window.getComputedStyle(intf, null),\n                defs = {};\n            intf.computedStyle = cStyle;\n            defaults(defs);\n            defs = defs.defaults.styles;\n            defs.forEach(function (def) {\n                var val = cStyle.getPropertyValue(hyphenateProperty(def[0], true));\n                if (val === \"\") {\n                    val = cStyle.getPropertyValue(hyphenateProperty(def[0], false));\n                }\n                if (val !== \"\") {\n                    intf.setStyleProperty(def[0], typeMap[typeof def[1]](val, def[1]));\n                }\n            });\n            requestAnimationFrame(function () { intf.resize(true); });\n            if (!supressChangeAndDrawEvents && intf.dispatchEvent) {\n                intf.dispatchEvent('stylechanged', intf.style);\n            }\n        }\n        typeMap = {\n            data: function (strData) {\n                try {\n                    return JSON.parse(strData);\n                } catch (e) {\n                    throw new Error('Cannot read JSON data in canvas-datagrid data.');\n                }\n            },\n            schema: function (strSchema) {\n                try {\n                    return JSON.parse(strSchema);\n                } catch (e) {\n                    throw new Error('Cannot read JSON data in canvas-datagrid schema attribute.');\n                }\n            },\n            number: function (strNum, def) {\n                var n = parseInt(strNum, 10);\n                return isNaN(n) ? def : n;\n            },\n            boolean: function (strBool) {\n                return (/true/i).test(strBool);\n            },\n            string: function (str) {\n                return str;\n            }\n        };\n        component.getObservableAttributes = function () {\n            var i = {}, attrs = ['data', 'schema', 'style', 'className', 'name'];\n            defaults(i);\n            i.defaults.attributes.forEach(function (attr) {\n                attrs.push(attr[0].toLowerCase());\n            });\n            return attrs;\n        };\n        component.disconnectedCallback = function () {\n            this.connected = false;\n        };\n        component.connectedCallback = function () {\n            var intf = this;\n            intf.connected = true;\n            component.observe(intf);\n            applyComponentStyle(true, intf);\n            intf.resize(true);\n        };\n        component.adoptedCallback = function () {\n            this.resize();\n        };\n        component.attributeChangedCallback = function (attrName, oldVal, newVal) {\n            var tfn, intf = this, def;\n            if (attrName === 'style') {\n                requestAnimationFrame(function () { applyComponentStyle(false, intf); });\n                return;\n            }\n            if (attrName === 'data') {\n                intf.args.data = typeMap.data(newVal);\n                return;\n            }\n            if (attrName === 'schema') {\n                intf.args.schema = typeMap.schema(newVal);\n                return;\n            }\n            if (attrName === 'name') {\n                intf.name = newVal;\n                return;\n            }\n            if (attrName === 'class' || attrName === 'className') {\n                return;\n            }\n            def = getDefaultItem('attributes', attrName);\n            if (def) {\n                tfn = typeMap[typeof def[1]];\n                intf.attributes[def[0]] = tfn(newVal);\n                return;\n            }\n            if (/^on/.test(attrName)) {\n                intf.addEventListener('on' + attrName, function (e) {\n                    eval(newVal);\n                });\n            }\n            return;\n        };\n        component.observe = function (intf) {\n            var observer;\n            if (!window.MutationObserver) { return; }\n            intf.applyComponentStyle = function () { applyComponentStyle(false, intf); intf.resize(); };\n            /**\n             * Applies the computed css styles to the grid.  In some browsers, changing directives in attached style sheets does not automatically update the styles in this component.  It is necessary to call this method to update in these cases.\n             * @memberof canvasDatagrid\n             * @name applyComponentStyle\n             * @method\n             */\n            observer = new window.MutationObserver(function (mutations) {\n                var checkInnerHTML, checkStyle;\n                Array.prototype.forEach.call(mutations, function (mutation) {\n                    if (mutation.attributeName === 'class'\n                            || mutation.attributeName === 'style') {\n                        intf.applyComponentStyle(false, intf);\n                        return;\n                    }\n                    if (mutation.target.parentNode\n                            && mutation.target.parentNode.nodeName === 'STYLE') {\n                        checkStyle = true;\n                        return;\n                    }\n                    if (mutation.addedNodes.length > 0 || mutation.type === 'characterData') {\n                        checkInnerHTML = true;\n                    }\n                });\n                if (checkStyle) {\n                    intf.applyComponentStyle(false, intf);\n                }\n                if (checkInnerHTML) {\n                    intf.data = typeMap.data(intf.innerHTML);\n                }\n            });\n            observer.observe(intf, { characterData: true, childList: true, attributes: true, subtree: true });\n            observer.observe(intf.canvas, { attributes: true });\n            Array.prototype.forEach.call(document.querySelectorAll('style'), function (el) {\n                observer.observe(el, { characterData: true, childList: true, attributes: true, subtree: true });\n            });\n        };\n        return component;\n    };\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/component.js\n// module id = 2\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals XMLSerializer: false, define: true, Blob: false, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        var perfCounters = [],\n            drawCount = 0,\n            perfWindowSize = 300,\n            entityCount = [],\n            scrollDebugCounters = [],\n            touchPPSCounters = [];\n        self.htmlImageCache = {};\n        function drawPerfLine(w, h, x, y, perfArr, arrIndex, max, color, useAbs) {\n            var i = w / perfArr.length,\n                r = h / max;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.moveTo(x, y + h);\n            perfArr.forEach(function (n) {\n                var val = (arrIndex === undefined ? n : n[arrIndex]),\n                    cx,\n                    cy;\n                if (useAbs) {\n                    val = Math.abs(val);\n                }\n                cx = x + i;\n                cy = y + h - (val * r);\n                self.ctx.lineTo(cx, cy);\n                x += i;\n            });\n            self.ctx.moveTo(x + w, y + h);\n            self.ctx.strokeStyle = color;\n            self.ctx.stroke();\n        }\n        function drawOnAllImagesLoaded() {\n            var loaded = true;\n            Object.keys(self.htmlImageCache).forEach(function (html) {\n                if (!self.htmlImageCache[html].complete) {\n                    loaded = false;\n                }\n            });\n            if (loaded) {\n                self.draw();\n            }\n        }\n        function drawHtml(cell) {\n            var img,\n                v = cell.innerHTML || cell.formattedValue,\n                x = cell.x + self.canvasOffsetLeft,\n                y = cell.y + self.canvasOffsetTop;\n            if (self.htmlImageCache[v]) {\n                img = self.htmlImageCache[v];\n                if (img.height !== cell.height || img.width !== cell.width) {\n                    // height and width of the cell has changed, invalidate cache\n                    self.htmlImageCache[v] = undefined;\n                } else {\n                    if (!img.complete) {\n                        return;\n                    }\n                    return self.ctx.drawImage(img, x, y);\n                }\n            }\n            img = new Image(cell.width, cell.height);\n            self.htmlImageCache[v] = img;\n            img.onload = function () {\n                self.ctx.drawImage(img, x, y);\n                drawOnAllImagesLoaded();\n            };\n            img.src = 'data:image/svg+xml;base64,' + btoa(\n                '<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"' + cell.width + '\" height=\"' + cell.height + '\">\\n' +\n                    '<foreignObject class=\"node\" x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\\n' +\n                    '<body xmlns=\"http://www.w3.org/1999/xhtml\" style=\"margin:0;padding:0;\">\\n' +\n                    v + '\\n' +\n                    '</body>' +\n                    '</foreignObject>\\n' +\n                    '</svg>\\n'\n            );\n        }\n        function drawOrderByArrow(x, y) {\n            var mt = self.style.columnHeaderOrderByArrowMarginTop * self.scale,\n                ml = self.style.columnHeaderOrderByArrowMarginLeft * self.scale,\n                mr = self.style.columnHeaderOrderByArrowMarginRight * self.scale,\n                aw = self.style.columnHeaderOrderByArrowWidth * self.scale,\n                ah = self.style.columnHeaderOrderByArrowHeight * self.scale;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillStyle = self.style.columnHeaderOrderByArrowColor;\n            self.ctx.strokeStyle = self.style.columnHeaderOrderByArrowBorderColor;\n            self.ctx.beginPath();\n            x = x + ml;\n            y = y + mt;\n            if (self.orderDirection === 'asc') {\n                self.ctx.moveTo(x, y);\n                self.ctx.lineTo(x + aw, y);\n                self.ctx.lineTo(x + (aw * 0.5), y + ah);\n                self.ctx.moveTo(x, y);\n            } else {\n                self.ctx.lineTo(x, y + ah);\n                self.ctx.lineTo(x + aw, y + ah);\n                self.ctx.lineTo(x + (aw * 0.5), y);\n                self.ctx.lineTo(x, y + ah);\n            }\n            self.ctx.stroke();\n            self.ctx.fill();\n            return ml + aw + mr;\n        }\n        function drawTreeArrow(cell, x, y) {\n            var mt = self.style.treeArrowMarginTop * self.scale,\n                mr = self.style.treeArrowMarginRight * self.scale,\n                ml = self.style.treeArrowMarginLeft * self.scale,\n                aw = self.style.treeArrowWidth * self.scale,\n                ah = self.style.treeArrowHeight * self.scale;\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillStyle = self.style.treeArrowColor;\n            self.ctx.strokeStyle = self.style.treeArrowBorderColor;\n            self.ctx.beginPath();\n            x = x + ml;\n            y = y + mt;\n            if (self.openChildren[cell.data[self.uniqueId]]) {\n                self.ctx.moveTo(x, y);\n                self.ctx.lineTo(x + aw, y);\n                self.ctx.lineTo(x + (aw * 0.5), y + ah);\n                self.ctx.moveTo(x, y);\n            } else {\n                self.ctx.lineTo(x, y);\n                self.ctx.lineTo(x + ah, y + (aw * 0.5));\n                self.ctx.lineTo(x, y + aw);\n                self.ctx.lineTo(x, y);\n            }\n            self.ctx.stroke();\n            self.ctx.fill();\n            return ml + aw + mr;\n        }\n        function radiusRect(x, y, w, h, radius) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            var r = x + w, b = y + h;\n            self.ctx.beginPath();\n            self.ctx.moveTo(x + radius, y);\n            self.ctx.lineTo(r - radius, y);\n            self.ctx.quadraticCurveTo(r, y, r, y + radius);\n            self.ctx.lineTo(r, y + h - radius);\n            self.ctx.quadraticCurveTo(r, b, r - radius, b);\n            self.ctx.lineTo(x + radius, b);\n            self.ctx.quadraticCurveTo(x, b, x, b - radius);\n            self.ctx.lineTo(x, y + radius);\n            self.ctx.quadraticCurveTo(x, y, x + radius, y);\n        }\n        function fillRect(x, y, w, h) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillRect(x, y, w, h);\n        }\n        function strokeRect(x, y, w, h) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.strokeRect(x, y, w, h);\n        }\n        function fillText(text, x, y) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.fillText(text, x, y);\n        }\n        function fillCircle(x, y, r) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.arc(x, y, r, 0, 2 * Math.PI);\n            self.ctx.fill();\n        }\n        function strokeCircle(x, y, r) {\n            x += self.canvasOffsetLeft;\n            y += self.canvasOffsetTop;\n            self.ctx.beginPath();\n            self.ctx.arc(x, y, r, 0, 2 * Math.PI);\n            self.ctx.stroke();\n        }\n        function clipFrozenArea(mode) {\n            // 0 both, 1 rows, 2 cols\n            // self.lastFrozenColumnPixel;\n            // self.lastFrozenRowPixel;\n            self.ctx.beginPath();\n            if (mode === 0) {\n                self.ctx.moveTo(self.lastFrozenColumnPixel, self.lastFrozenRowPixel);\n                self.ctx.lineTo(self.lastFrozenColumnPixel, self.height);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.width, self.lastFrozenRowPixel);\n            }\n            if (mode === 1) {\n                self.ctx.moveTo(0, self.lastFrozenRowPixel);\n                self.ctx.lineTo(0, self.height);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.width, self.lastFrozenRowPixel);\n            }\n            if (mode === 2) {\n                self.ctx.moveTo(self.lastFrozenColumnPixel, 0);\n                self.ctx.lineTo(self.width, 0);\n                self.ctx.lineTo(self.width, self.height);\n                self.ctx.lineTo(self.lastFrozenColumnPixel, self.height);\n            }\n            self.ctx.clip();\n        }\n        function fillHandle(x, y, r) {\n            if (self.style.selectionHandleType === 'circle') {\n                return fillCircle(x, y, r * 0.5);\n            }\n            fillRect(x - r * 0.5, y - r * 0.5, r, r);\n        }\n        function strokeHandle(x, y, r) {\n            if (self.style.selectionHandleType === 'circle') {\n                return strokeCircle(x, y, r * 0.5);\n            }\n            strokeRect(x - r * 0.5, y - r * 0.5, r, r);\n        }\n        function addselectionHandle(c, pos) {\n            var hw = self.style.selectionHandleSize,\n                p = {\n                    tr: function () {\n                        fillHandle(c.x + c.width, c.y, hw);\n                        strokeHandle(c.x + c.width, c.y, hw);\n                    },\n                    br: function () {\n                        fillHandle(c.x + c.width, c.y + c.height, hw);\n                        strokeHandle(c.x + c.width, c.y + c.height, hw);\n                    },\n                    tl: function () {\n                        fillHandle(c.x, c.y, hw);\n                        strokeHandle(c.x, c.y, hw);\n                    },\n                    bl: function () {\n                        fillHandle(c.x, c.y + c.height, hw);\n                        strokeHandle(c.x, c.y + c.height, hw);\n                    }\n                };\n            p[pos]();\n        }\n        function addBorderLine(c, pos) {\n            self.ctx.beginPath();\n            var p = {\n                t: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop);\n                },\n                r: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop + c.height);\n                },\n                b: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop + c.height);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft + c.width, c.y + self.canvasOffsetTop + c.height);\n                },\n                l: function () {\n                    self.ctx.moveTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop);\n                    self.ctx.lineTo(c.x + self.canvasOffsetLeft, c.y + self.canvasOffsetTop + c.height);\n                }\n            };\n            p[pos]();\n            self.ctx.stroke();\n        }\n        function addEllipsis(text, width) {\n            var c, w = 0;\n            if (self.ellipsisCache[text] && self.ellipsisCache[text][width]) {\n                return self.ellipsisCache[text][width];\n            }\n            //TODO Add ellipsis back when there is a fast way to do it\n            w = self.ctx.measureText(text).width;\n            self.ellipsisCache[text] = self.ellipsisCache[text] || {};\n            c = {value: text, width: w};\n            self.ellipsisCache[text][width] = c;\n            return c;\n        }\n        function drawText(cell) {\n            var paddingLeft = self.style[cell.style + 'PaddingLeft'] * self.scale,\n                paddingTop = self.style[cell.style + 'PaddingTop'] * self.scale,\n                paddingRight = self.style[cell.style + 'PaddingRight'] * self.scale,\n                paddingBottom = self.style[cell.style + 'PaddingBottom'] * self.scale,\n                vPos = paddingTop + cell.height - (cell.height * 0.5),\n                hPos = paddingLeft + cell.treeArrowWidth + cell.orderByArrowWidth;\n            cell.text = addEllipsis(cell.formattedValue, cell.width - paddingRight - paddingLeft);\n            cell.text.height = cell.fontHeight;\n            if (cell.horizontalAlignment === 'right') {\n                hPos = cell.width - cell.text.width - paddingRight;\n            } else if (cell.horizontalAlignment === 'center') {\n                hPos = (cell.width / 2) - (cell.text.width / 2);\n            }\n            if (cell.verticalAlignment === 'top') {\n                vPos = paddingTop + cell.text.height;\n            } else if (cell.verticalAlignment === 'bottom') {\n                vPos = cell.height - paddingBottom - cell.text.height;\n            }\n            cell.text.x = cell.x + hPos;\n            cell.text.y = cell.y + vPos;\n            fillText(cell.text.value, cell.text.x, cell.text.y);\n        }\n        function getFrozenColumnsWidth() {\n            var w = 0,\n                s = self.getVisibleSchema(),\n                x = 0,\n                n = Math.min(self.frozenColumn, s.length),\n                column;\n            while (x < n) {\n                column = s[self.orders.columns[x]];\n                w += ((self.sizes.columns[column[self.uniqueId]] || column.width || self.style.cellWidth) * self.scale);\n                x += 1;\n            }\n            return w;\n        }\n        /**\n         * Redraws the grid. No matter what the change, this is the only method required to refresh everything.\n         * @memberof canvasDatagrid\n         * @name draw\n         * @method\n         */\n         // r = literal row index\n         // rd = row data array\n         // i = user order index\n         // o = literal data index\n         // y = y drawing cursor\n         // x = x drawing cursor\n         // s = visible schema array\n         // cx = current x drawing cursor sub calculation var\n         // cy = current y drawing cursor sub calculation var\n         // a = static cell (like corner cell)\n         // p = perf counter\n         // l = data length\n         // u = current cell\n         // h = current height\n         // w = current width\n        self.draw = function (internal) {\n            if (self.dispatchEvent('beforedraw', {})) { return; }\n            if (!self.isChildGrid && (!self.height || !self.width)) {\n                return;\n            }\n            if (self.isChildGrid && internal) {\n                requestAnimationFrame(self.parentGrid.draw);\n                return;\n            }\n            if (self.intf.visible === false) {\n                return;\n            }\n            // initial values\n            var checkScrollHeight, rowHeaderCell, p, cx, cy, treeGrid, rowOpen,\n                rowHeight, cornerCell, y, x, c, h, w, s, r, rd, aCell,\n                bc = self.style.gridBorderCollapse === 'collapse',\n                selectionBorders = [],\n                moveBorders = [],\n                selectionHandles = [],\n                rowHeaders = [],\n                frozenColumnWidths = getFrozenColumnsWidth(),\n                l = self.data.length,\n                u = self.currentCell || {},\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                cellHeight = self.style.cellHeight;\n            drawCount += 1;\n            p = performance.now();\n            self.visibleRowHeights = [];\n            // if data length has changed, there is no way to know\n            if (self.data.length > self.orders.rows.length) {\n                self.createRowOrders();\n            }\n            function drawScrollBars() {\n                var v = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'vertical-scroll-bar'\n                    },\n                    n = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'horizontal-scroll-bar'\n                    },\n                    vb = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'vertical-scroll-box'\n                    },\n                    nb = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        style: 'horizontal-scroll-box'\n                    },\n                    co = {\n                        x: 0,\n                        y: 0,\n                        height: 0,\n                        width: 0,\n                        isCorner: true,\n                        isScrollBoxCorner: true,\n                        style: 'scroll-box-corner'\n                    },\n                    m = (self.style.scrollBarBoxMargin * 2),\n                    d = self.style.scrollBarBoxMargin * 0.5;\n                self.ctx.strokeStyle = self.style.scrollBarBorderColor;\n                self.ctx.lineWidth = self.style.scrollBarBorderWidth;\n                // vertical\n                v.x += w - self.style.scrollBarWidth - self.style.scrollBarBorderWidth - d;\n                v.y += columnHeaderCellHeight;\n                v.width = self.style.scrollBarWidth + self.style.scrollBarBorderWidth + d;\n                v.height = h - columnHeaderCellHeight - self.style.scrollBarWidth - d - m;\n                self.ctx.fillStyle = self.style.scrollBarBackgroundColor;\n                fillRect(v.x, v.y, v.width, v.height + m);\n                strokeRect(v.x, v.y, v.width, v.height + m);\n                // vertical box\n                vb.x = v.x + self.style.scrollBarBoxMargin;\n                vb.y = columnHeaderCellHeight + self.style.scrollBarBoxMargin\n                    + ((v.height - self.scrollBox.scrollBoxHeight)\n                        * (self.scrollBox.scrollTop / self.scrollBox.scrollHeight));\n                vb.width = self.style.scrollBarBoxWidth;\n                vb.height = self.scrollBox.scrollBoxHeight;\n                self.ctx.fillStyle = self.style.scrollBarBoxColor;\n                if (/vertical/.test(u.context)) {\n                    self.ctx.fillStyle = self.style.scrollBarActiveColor;\n                }\n                if (vb.height < v.height) {\n                    radiusRect(vb.x, vb.y, vb.width, vb.height, self.style.scrollBarBoxBorderRadius);\n                    self.ctx.stroke();\n                    self.ctx.fill();\n                }\n                // horizontal\n                n.x += rowHeaderCellWidth;\n                n.y += h - self.style.scrollBarWidth - d;\n                n.width = w - self.style.scrollBarWidth - rowHeaderCellWidth - d - m;\n                n.height = self.style.scrollBarWidth + self.style.scrollBarBorderWidth + d;\n                self.ctx.fillStyle = self.style.scrollBarBackgroundColor;\n                fillRect(n.x, n.y, n.width + m, n.height);\n                strokeRect(n.x, n.y, n.width + m, n.height);\n                // horizontal box\n                nb.y = n.y + self.style.scrollBarBoxMargin;\n                nb.x = rowHeaderCellWidth + self.style.scrollBarBoxMargin\n                    + ((n.width - self.scrollBox.scrollBoxWidth)\n                        * (self.scrollBox.scrollLeft / self.scrollBox.scrollWidth));\n                nb.width = self.scrollBox.scrollBoxWidth;\n                nb.height = self.style.scrollBarBoxWidth;\n                self.ctx.fillStyle = self.style.scrollBarBoxColor;\n                if (/horizontal/.test(u.context)) {\n                    self.ctx.fillStyle = self.style.scrollBarActiveColor;\n                }\n                if (nb.width < n.width) {\n                    radiusRect(nb.x, nb.y, nb.width, nb.height, self.style.scrollBarBoxBorderRadius);\n                    self.ctx.stroke();\n                    self.ctx.fill();\n                }\n                //corner\n                self.ctx.strokeStyle = self.style.scrollBarCornerBorderColor;\n                self.ctx.fillStyle = self.style.scrollBarCornerBackgroundColor;\n                co.x = n.x + n.width + m;\n                co.y = v.y + v.height + m;\n                co.width = self.style.scrollBarWidth + self.style.scrollBarBorderWidth;\n                co.height = self.style.scrollBarWidth + self.style.scrollBarBorderWidth;\n                radiusRect(co.x, co.y, co.width, co.height, 0);\n                self.ctx.stroke();\n                self.ctx.fill();\n                self.visibleCells.unshift(v);\n                self.visibleCells.unshift(vb);\n                self.visibleCells.unshift(n);\n                self.visibleCells.unshift(nb);\n                self.visibleCells.unshift(co);\n                self.scrollBox.bar = {\n                    v: v,\n                    h: n\n                };\n                self.scrollBox.box = {\n                    v: vb,\n                    h: nb\n                };\n            }\n            function createHandlesOverlayArray(cell) {\n                if (self.attributes.allowMovingSelection || self.mobile) {\n                    if (cell.selectionBorderTop && cell.selectionBorderRight && self.mobile) {\n                        selectionHandles.push([cell, 'tr']);\n                        cell.selectionHandle = 'tr';\n                    }\n                    if (cell.selectionBorderTop && cell.selectionBorderLeft && self.mobile) {\n                        selectionHandles.push([cell, 'tl']);\n                        cell.selectionHandle = 'tl';\n                    }\n                    if (cell.selectionBorderBottom && cell.selectionBorderLeft && self.mobile) {\n                        selectionHandles.push([cell, 'bl']);\n                        cell.selectionHandle = 'bl';\n                    }\n                    if (cell.selectionBorderBottom && cell.selectionBorderRight\n                            && (self.attributes.selectionHandleBehavior !== 'none' || self.mobile)) {\n                        selectionHandles.push([cell, 'br']);\n                        cell.selectionHandle = 'br';\n                    }\n                }\n            }\n            function createBorderOverlayArray(cell, drawArray, propPrefix, offsetPoint) {\n                offsetPoint = offsetPoint || {x: 0, y: 0};\n                cell.selectionBorder = '';\n                if (!cell.isRowHeader\n                        && self.selections[cell.rowIndex + -offsetPoint.y]\n                        && self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) !== -1) {\n                    if ((!self.selections[cell.rowIndex - 1 + -offsetPoint.y]\n                            || self.selections[cell.rowIndex - 1 + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) === -1\n                            || cell.rowIndex === 0)\n                            && !cell.isHeader) {\n                        drawArray.push([cell, 't']);\n                        cell[propPrefix + 'BorderTop'] = true;\n                        cell[propPrefix + 'Border'] += 't';\n                    }\n                    if (!self.selections[cell.rowIndex + 1 + -offsetPoint.y]\n                            || self.selections[cell.rowIndex + 1 + -offsetPoint.y].indexOf(cell.columnIndex + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'b']);\n                        cell[propPrefix + 'BorderBottom'] = true;\n                        cell[propPrefix + 'Border'] += 'b';\n                    }\n                    if (!self.selections[cell.rowIndex + -offsetPoint.y] || cell.columnIndex === 0\n                            || self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex - 1 + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'l']);\n                        cell[propPrefix + 'BorderLeft'] = true;\n                        cell[propPrefix + 'Border'] += 'l';\n                    }\n                    if (!self.selections[cell.rowIndex + -offsetPoint.y] || cell.columnIndex === s.length\n                            || self.selections[cell.rowIndex + -offsetPoint.y].indexOf(cell.columnIndex + 1 + -offsetPoint.x) === -1) {\n                        drawArray.push([cell, 'r']);\n                        cell[propPrefix + 'BorderRight'] = true;\n                        cell[propPrefix + 'Border'] += 'r';\n                    }\n                }\n            }\n            function drawCell(d, rowOrderIndex, rowIndex) {\n                return function drawEach(header, headerIndex, columnOrderIndex) {\n                    var cellStyle = header.style || 'cell',\n                        cellGridAttributes,\n                        cell,\n                        isHeader = /HeaderCell/.test(cellStyle),\n                        isCorner = /cornerCell/.test(cellStyle),\n                        isRowHeader = 'rowHeaderCell' === cellStyle,\n                        isColumnHeader = 'columnHeaderCell' === cellStyle,\n                        selected = self.selections[rowOrderIndex] && self.selections[rowOrderIndex].indexOf(columnOrderIndex) !== -1,\n                        hovered = self.hovers[d[self.uniqueId]] && self.hovers[d[self.uniqueId]].indexOf(columnOrderIndex) !== -1,\n                        active = self.activeCell.rowIndex === rowOrderIndex && self.activeCell.columnIndex === columnOrderIndex,\n                        isGrid = typeof d[header.name] === 'object' && d[header.name] !== null && d[header.name] !== undefined,\n                        activeHeader = (self.orders.rows[self.activeCell.rowIndex] === rowOrderIndex\n                                || self.orders.columns[self.activeCell.columnIndex] === columnOrderIndex)\n                            && (columnOrderIndex === -1 || rowOrderIndex === -1)\n                            ? (isRowHeader ? 'activeRowHeaderCell' : 'activeColumnHeaderCell') : false,\n                        val,\n                        f = self.formatters[header.type || 'string'],\n                        orderByArrowSize = 0,\n                        treeArrowSize = 0,\n                        cellWidth = self.sizes.columns[isRowHeader ? 'cornerCell' : header[self.uniqueId]] || header.width,\n                        ev = {\n                            value: d[header.name],\n                            row: d,\n                            header: header\n                        };\n                    if (cellStyle === 'headerCellCap') {\n                        cellWidth = w - x;\n                    }\n                    // if no data or schema are defined, a width is provided to the stub column\n                    if (cellWidth === undefined) {\n                        cellWidth = self.style.cellWidth;\n                    }\n                    cellWidth = cellWidth * self.scale;\n                    if (x + cellWidth + self.style.cellBorderWidth < 0) {\n                        x += cellWidth + self.style.cellBorderWidth;\n                    }\n                    if (active && cellStyle !== 'cornerCell') {\n                        cellStyle = 'activeCell';\n                    }\n                    if (self.visibleRows.indexOf(rowIndex) === -1 && !isHeader) {\n                        self.visibleRows.push(rowIndex);\n                    }\n                    val = self.dispatchEvent('formatcellvalue', ev);\n                    cx = x;\n                    cy = y;\n                    if (cellStyle === 'cornerCell') {\n                        cx = 0;\n                        cy = 0;\n                    } else if (isRowHeader) {\n                        cx = 0;\n                    } else if (isHeader) {\n                        cy = 0;\n                    }\n                    cell = {\n                        type: isGrid ? 'canvas-datagrid-cell' : header.type,\n                        style: cellStyle,\n                        nodeType: 'canvas-datagrid-cell',\n                        x: cx,\n                        y: cy,\n                        horizontalAlignment: self.style[cellStyle + 'HorizontalAlignment'],\n                        verticalAlignment: self.style[cellStyle + 'VerticalAlignment'],\n                        offsetTop: self.canvasOffsetTop + cy,\n                        offsetLeft: self.canvasOffsetLeft + cx,\n                        scrollTop: self.scrollBox.scrollTop,\n                        scrollLeft: self.scrollBox.scrollLeft,\n                        active: active || activeHeader,\n                        hovered: hovered,\n                        selected: selected,\n                        width: cellWidth,\n                        height: cellHeight,\n                        offsetWidth: cellWidth,\n                        offsetHeight: cellHeight,\n                        parentNode: self.intf.parentNode,\n                        offsetParent: self.intf.parentNode,\n                        data: d,\n                        isCorner: isCorner,\n                        isHeader: isHeader,\n                        isColumnHeader: isColumnHeader,\n                        isHeaderCellCap: !!header.isHeaderCellCap,\n                        isRowHeader: isRowHeader,\n                        rowOpen: rowOpen,\n                        header: header,\n                        columnIndex: columnOrderIndex,\n                        rowIndex: rowOrderIndex,\n                        sortColumnIndex: headerIndex,\n                        sortRowIndex: rowIndex,\n                        isGrid: isGrid,\n                        isNormal: !isGrid && !isCorner && !isHeader,\n                        gridId: (self.attributes.name || '') + d[self.uniqueId] + ':' + header[self.uniqueId],\n                        parentGrid: self.intf,\n                        innerHTML: '',\n                        activeHeader: activeHeader,\n                        value: isHeader && !isRowHeader ? (header.title || header.name) : d[header.name]\n                    };\n                    ev.cell = cell;\n                    cell.userHeight = cell.isHeader ? self.sizes.rows[-1] : rowHeight;\n                    cell.userWidth = cell.isHeader ? self.sizes.columns.cornerCell : self.sizes.columns[header[self.uniqueId]];\n                    cell[self.uniqueId] = d[self.uniqueId];\n                    self.visibleCells.unshift(cell);\n                    if (self.dispatchEvent('beforerendercell', ev)) { return; }\n                    self.ctx.fillStyle = self.style[cellStyle + 'BackgroundColor'];\n                    self.ctx.strokeStyle = self.style[cellStyle + 'BorderColor'];\n                    self.ctx.lineWidth = self.style[cellStyle + 'BorderWidth'];\n                    if (hovered) {\n                        self.ctx.fillStyle = self.style[cellStyle + 'HoverBackgroundColor'];\n                        self.ctx.strokeStyle = self.style[cellStyle + 'HoverBorderColor'];\n                    }\n                    if (selected) {\n                        self.ctx.fillStyle = self.style[cellStyle + 'SelectedBackgroundColor'];\n                        self.ctx.strokeStyle = self.style[cellStyle + 'SelectedBorderColor'];\n                    }\n                    if (activeHeader) {\n                        self.ctx.fillStyle = self.style[activeHeader + 'BackgroundColor'];\n                    }\n                    self.dispatchEvent('rendercell', ev);\n                    if (cell.isGrid) {\n                        if (cell.height !== rowHeight) {\n                            cell.height = rowHeight || self.style.cellHeightWithChildGrid;\n                            checkScrollHeight = true;\n                        }\n                        cell.width = self.sizes.columns[header[self.uniqueId]] || self.style.cellWidthWithChildGrid;\n                    }\n                    if (rowOpen && !cell.isRowHeader) {\n                        cell.height = self.sizes.rows[rd[self.uniqueId]] || self.style.cellHeight;\n                    }\n                    if (!cell.isGrid) {\n                        fillRect(cx, cy, cell.width, cell.height);\n                        strokeRect(cx, cy, cell.width, cell.height);\n                    }\n                    self.ctx.save();\n                    radiusRect(cell.x, cell.y, cell.width, cell.height, 0);\n                    self.ctx.clip();\n                    self.dispatchEvent('afterrendercell', ev);\n                    if (cell.height !== cellHeight && !(rowOpen && !cell.isRowHeader)) {\n                        self.sizes.rows[isHeader ? -1 : d[self.uniqueId]] = cell.height;\n                        checkScrollHeight = true;\n                    }\n                    if (cell.width !== cellWidth) {\n                        self.sizes.columns[header[self.uniqueId]] = cell.width;\n                        checkScrollHeight = true;\n                    }\n                    if (isRowHeader && self.attributes.tree) {\n                        if (!self.dispatchEvent('rendertreearrow', ev)) {\n                            treeArrowSize = drawTreeArrow(cell, self.style[cellStyle + 'PaddingLeft'], cy, 0);\n                        }\n                    }\n                    if ((self.attributes.showRowNumbers && isRowHeader)\n                            || !isRowHeader) {\n                        if (cell.isGrid && !self.dispatchEvent('beforerendercellgrid', ev)) {\n                            if (!self.childGrids[cell.gridId]) {\n                                cellGridAttributes = self.args.cellGridAttributes || self.args;\n                                cellGridAttributes.name = self.attributes.saveAppearance ? cell.gridId : undefined;\n                                cellGridAttributes.component = false;\n                                cellGridAttributes.parentNode = cell;\n                                cellGridAttributes.data = d[header.name];\n                                cellGridAttributes.style = cellGridAttributes.style || self.style;\n                                ev.cellGridAttributes = cellGridAttributes;\n                                if (self.dispatchEvent('beforecreatecellgrid', ev)) { return; }\n                                self.childGrids[cell.gridId] = self.createGrid(cellGridAttributes);\n                                self.sizes.rows[rd[self.uniqueId]]\n                                    = self.sizes.rows[rd[self.uniqueId]] || self.style.cellGridHeight;\n                                checkScrollHeight = true;\n                            }\n                            cell.grid = self.childGrids[cell.gridId];\n                            cell.grid.parentNode = cell;\n                            cell.grid.visible = true;\n                            cell.grid.draw();\n                            self.dispatchEvent('rendercellgrid', ev);\n                        } else if (!cell.isGrid) {\n                            if (self.childGrids[cell.gridId]) {\n                                self.childGrids[cell.gridId].parentNode.offsetHeight = 0;\n                            }\n                            if (isHeader && self.orderBy === header.name) {\n                                if (!self.dispatchEvent('renderorderbyarrow', ev)) {\n                                    orderByArrowSize = drawOrderByArrow(cx + self.style[cellStyle + 'PaddingLeft'], 0);\n                                }\n                            }\n                            self.ctx.fillStyle = self.style[cellStyle + 'Color'];\n                            if (hovered) {\n                                self.ctx.fillStyle = self.style[cellStyle + 'HoverColor'];\n                            }\n                            if (selected) {\n                                self.ctx.fillStyle = self.style[cellStyle + 'SelectedColor'];\n                            }\n                            if (activeHeader) {\n                                self.ctx.fillStyle = self.style[activeHeader + 'Color'];\n                            }\n                            self.ctx.font = (self.style[cellStyle + 'FontHeight'] * self.scale) + 'px ' + self.style[cellStyle + 'FontName'];\n                            cell.fontHeight = (self.style[cellStyle + 'FontHeight'] * self.scale);\n                            cell.treeArrowWidth = treeArrowSize;\n                            cell.orderByArrowWidth = orderByArrowSize;\n                            val = val !== undefined ? val : f\n                                ? f(ev) : '';\n                            if (val === undefined && !f) {\n                                val = '';\n                                console.warn('canvas-datagrid: Unknown format '\n                                    + header.type + ' add a cellFormater');\n                            }\n                            cell.formattedValue = ((val !== undefined && val !== null) ? val : '').toString();\n                            if (self.columnFilters && self.columnFilters[val] !== undefined && isHeader) {\n                                cell.formattedValue = self.attributes.filterTextPrefix + val;\n                            }\n                            if (!self.dispatchEvent('rendertext', ev)) {\n                                if (cell.innerHTML || header.type === 'html') {\n                                    drawHtml(cell);\n                                } else {\n                                    drawText(cell);\n                                }\n                            }\n                        }\n                    }\n                    if (active) {\n                        aCell = cell;\n                    }\n                    createBorderOverlayArray(cell, selectionBorders, 'selection');\n                    // createBorderOverlayArray calculates data for createHandlesOverlayArray so it must go 2nd\n                    createHandlesOverlayArray(cell);\n                    if (self.movingSelection) {\n                        createBorderOverlayArray(cell, moveBorders, 'move', self.moveOffset);\n                    }\n                    self.ctx.restore();\n                    x += cell.width + (bc ? 0 : self.style.cellBorderWidth);\n                    return cell.width;\n                };\n            }\n            function drawRowHeader(rowData, index, rowOrderIndex) {\n                var a;\n                if (self.attributes.showRowHeaders) {\n                    x = 0;\n                    rowHeaderCell = {'rowHeaderCell': index + 1 };\n                    rowHeaderCell[self.uniqueId] = rowData[self.uniqueId];\n                    a = {\n                        name: 'rowHeaderCell',\n                        width: self.style.rowHeaderCellWidth,\n                        style: 'rowHeaderCell',\n                        type: 'string',\n                        data: rowData[self.uniqueId],\n                        index: -1\n                    };\n                    a[self.uniqueId] = rowData[self.uniqueId];\n                    rowOpen = self.openChildren[rowData[self.uniqueId]];\n                    drawCell(rowHeaderCell, index, rowOrderIndex)(a, -1, -1);\n                }\n            }\n            function drawHeaders() {\n                var d, g = s.length, i, o, columnHeaderCell, header, nonFrozenHeaderWidth;\n                function drawHeaderColumnRange(start, end) {\n                    end = Math.min(end, g);\n                    for (o = start; o < end; o += 1) {\n                        i = self.orders.columns[o];\n                        header = s[i];\n                        d = {\n                            title: header.title,\n                            name: header.name,\n                            width: header.width || self.style.cellWidth,\n                            style: 'columnHeaderCell',\n                            type: 'string',\n                            index: o,\n                            order: i\n                        };\n                        columnHeaderCell = {'columnHeaderCell': header.title || header.name};\n                        columnHeaderCell[self.uniqueId] = 'h' + header[self.uniqueId];\n                        d[self.uniqueId] = header[self.uniqueId];\n                        x += drawCell(columnHeaderCell, -1, -1)(d, o, i);\n                        if (x > self.width + self.scrollBox.scrollLeft) {\n                            break;\n                        }\n                    }\n                }\n                rowHeaders.forEach(function (rArgs, rhIndex) {\n                    y = rArgs[3];\n                    cellHeight = rArgs[4];\n                    if (rhIndex === self.frozenRow) {\n                        self.ctx.save();\n                        radiusRect(0, self.lastFrozenRowPixel, self.width, self.height - self.lastFrozenRowPixel, 0);\n                        self.ctx.clip();\n                    }\n                    drawRowHeader(rArgs[0], rArgs[1], rArgs[2]);\n                });\n                self.ctx.restore();\n                if (self.attributes.showColumnHeaders) {\n                    x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.columnHeaderCellBorderWidth;\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    x += frozenColumnWidths;\n                    y = 0;\n                    // cell height might have changed during drawing\n                    cellHeight = self.getColumnHeaderCellHeight();\n                    drawHeaderColumnRange(self.scrollIndexLeft + self.frozenColumn, g);\n                    nonFrozenHeaderWidth = x;\n                    x = self.style.columnHeaderCellBorderWidth;\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    drawHeaderColumnRange(0, self.frozenColumn);\n                    // fill in the space right of the headers\n                    x = nonFrozenHeaderWidth;\n                    if (x < w) {\n                        c = {\n                            name: '',\n                            width: self.style.scrollBarWidth,\n                            style: 'headerCellCap',\n                            isHeaderCell: true,\n                            isHeaderCellCap: true,\n                            type: 'string',\n                            index: s.length\n                        };\n                        c[self.uniqueId] = 'columnHeaderCell';\n                        drawCell({endCap: ''}, -1, -1)(c, -1, -1);\n                    }\n                    // fill in the space right of the headers\n                    if (self.attributes.showRowHeaders) {\n                        cornerCell = {'cornerCell': '' };\n                        cornerCell[self.uniqueId] = 'cornerCell';\n                        x = 0;\n                        c = {\n                            name: 'cornerCell',\n                            width: self.style.rowHeaderCellWidth,\n                            style: 'cornerCell',\n                            type: 'string',\n                            index: -1\n                        };\n                        c[self.uniqueId] = 'cornerCell';\n                        drawCell(cornerCell, -1, -1)(c, -1, -1);\n                    }\n                }\n            }\n            function drawRow(r, d) {\n                var i, treeHeight, rowSansTreeHeight, o, g = s.length;\n                if (y - (cellHeight * 2) > h) {\n                    return false;\n                }\n                rd = self.data[r];\n                rowOpen = self.openChildren[rd[self.uniqueId]];\n                rowSansTreeHeight = (self.sizes.rows[rd[self.uniqueId]] || self.style.cellHeight) * self.scale;\n                treeHeight = (rowOpen ? self.sizes.trees[rd[self.uniqueId]] : 0) * self.scale;\n                rowHeight = (rowSansTreeHeight + treeHeight);\n                if (y < -rowHeight) {\n                    return false;\n                }\n                if (self.attributes.showRowHeaders) {\n                    x += rowHeaderCellWidth;\n                }\n                cellHeight = rowHeight;\n                if (self.attributes.allowFreezingColumns) {\n                    x += frozenColumnWidths;\n                }\n                //draw normal columns\n                for (o = (self.scrollIndexLeft + self.frozenColumn); o < g; o += 1) {\n                    i = self.orders.columns[o];\n                    x += drawCell(rd, r, d)(s[i], i, o);\n                    if (x > self.width) {\n                        self.scrollIndexRight = o;\n                        self.scrollPixelRight = x;\n                        break;\n                    }\n                }\n                //draw frozen columns\n                x = 0;\n                if (self.attributes.showRowHeaders) {\n                    x += rowHeaderCellWidth;\n                }\n                for (o = 0; o < self.frozenColumn; o += 1) {\n                    i = self.orders.columns[o];\n                    x += drawCell(rd, r, d)(s[i], i, o);\n                    if (x > self.width) {\n                        break;\n                    }\n                }\n                self.lastFrozenColumnPixel = x;\n                // cell height might have changed during drawing\n                cellHeight = rowHeight;\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                // don't draw a tree for the new row\n                treeGrid = self.childGrids[rd[self.uniqueId]];\n                if (r !== self.data.length && rowOpen) {\n                    treeGrid.visible = true;\n                    treeGrid.parentNode = {\n                        offsetTop: y + rowSansTreeHeight + self.canvasOffsetTop,\n                        offsetLeft: rowHeaderCellWidth - 1 + self.canvasOffsetLeft,\n                        offsetHeight: treeHeight,\n                        offsetWidth: self.width - rowHeaderCellWidth - self.style.scrollBarWidth - 1,\n                        offsetParent: self.intf.parentNode,\n                        parentNode: self.intf.parentNode,\n                        style: self.style,\n                        nodeType: 'canvas-datagrid-tree',\n                        scrollTop: self.scrollBox.scrollTop,\n                        scrollLeft: self.scrollBox.scrollLeft,\n                        rowIndex: r\n                    };\n                    self.visibleCells.unshift({\n                        rowIndex: r,\n                        columnIndex: 0,\n                        y: treeGrid.parentNode.offsetTop,\n                        x: treeGrid.parentNode.offsetLeft,\n                        height: treeGrid.height,\n                        width: treeGrid.width,\n                        style: 'tree-grid',\n                        type: treeGrid.parentNode.nodeType\n                    });\n                    treeGrid.draw();\n                } else if (treeGrid) {\n                    treeGrid.parentNode.offsetHeight = 0;\n                    delete self.sizes.trees[rd[self.uniqueId]];\n                }\n                rowHeaders.push([rd, r, d, y, rowHeight]);\n                self.visibleRowHeights[r] = rowHeight;\n                y += cellHeight + (bc ? 0 : self.style.cellBorderWidth);\n                return true;\n            }\n            function initDraw() {\n                self.visibleRows = [];\n                s = self.getVisibleSchema();\n                self.visibleCells = [];\n                self.canvasOffsetTop = self.isChildGrid ? self.parentNode.offsetTop : 0;\n                self.canvasOffsetLeft = self.isChildGrid ? self.parentNode.offsetLeft : 0;\n                h = self.height;\n                w = self.width;\n            }\n            function drawBackground() {\n                radiusRect(0, 0, w, h, 0);\n                self.ctx.clip();\n                self.ctx.fillStyle = self.style.gridBackgroundColor;\n                fillRect(0, 0, w, h);\n            }\n            function drawFrozenRows() {\n                var n, ln = Math.min(self.data.length, self.frozenRow);\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                y = columnHeaderCellHeight;\n                for (r = 0; r < ln; r += 1) {\n                    n = self.orders.rows[r];\n                    if (!drawRow(n, r)) {\n                        break;\n                    }\n                }\n                if (self.attributes.allowFreezingRows) {\n                    // HACK great, another stupid magic number.\n                    // Background will appear as a 0.5px artifact behind the row freeze bar without this hack\n                    y += self.style.frozenMarkerBorderWidth + self.style.frozenMarkerWidth - 0.4999999999;\n                }\n                self.lastFrozenRowPixel = y;\n            }\n            function drawRows() {\n                self.ctx.save();\n                if (self.frozenRow > 0) {\n                    radiusRect(0, self.lastFrozenRowPixel, self.width, self.height - self.lastFrozenRowPixel, 0);\n                    self.ctx.clip();\n                }\n                var o, n, i, g = s.length;\n                x = -self.scrollBox.scrollLeft + self.scrollPixelLeft + self.style.cellBorderWidth;\n                if (!self.attributes.snapToRow) {\n                    y += -self.scrollBox.scrollTop + self.scrollPixelTop;\n                }\n                for (r = self.frozenRow + self.scrollIndexTop; r < l; r += 1) {\n                    n = self.orders.rows[r];\n                    if (!drawRow(n, r)) {\n                        self.scrollIndexBottom = r;\n                        self.scrollPixelBottom = y;\n                        break;\n                    }\n                }\n                if (self.attributes.showNewRow) {\n                    if (self.attributes.showRowHeaders) {\n                        x += rowHeaderCellWidth;\n                    }\n                    rowHeight = cellHeight = self.style.cellHeight;\n                    rowOpen = false;\n                    for (o = self.scrollIndexLeft; o < g; o += 1) {\n                        i = self.orders.columns[o];\n                        x += drawCell(self.newRow, self.data.length, self.data.length)(s[i], i, o);\n                        if (x > self.width + self.scrollBox.scrollLeft) {\n                            break;\n                        }\n                    }\n                    rowHeaders.push([self.newRow, self.data.length, self.data.length, y, rowHeight]);\n                }\n                self.ctx.restore();\n            }\n            function drawMoveMarkers() {\n                if (!self.movingSelection) { return; }\n                self.ctx.lineWidth = self.style.moveOverlayBorderWidth;\n                self.ctx.strokeStyle = self.style.moveOverlayBorderColor;\n                self.ctx.setLineDash(self.style.moveOverlayBorderSegments);\n                moveBorders.forEach(function (c) {\n                    addBorderLine(c[0], c[1]);\n                });\n                self.ctx.setLineDash([]);\n            }\n            function drawReorderMarkers() {\n                if (!self.reorderObject) { return; }\n                var b = {\n                        height: self.reorderObject.height,\n                        width: self.reorderObject.width,\n                        x: self.reorderObject.x + self.reorderObject.dragOffset.x,\n                        y: self.reorderObject.y + self.reorderObject.dragOffset.y\n                    },\n                    m = {\n                        width: w,\n                        height: h,\n                        x: 0,\n                        y: 0\n                    };\n                self.ctx.fillStyle = self.style.reorderMarkerBackgroundColor;\n                self.ctx.lineWidth = self.style.reorderMarkerBorderWidth;\n                self.ctx.strokeStyle = self.style.reorderMarkerBorderColor;\n                if (self.dragMode === 'row-reorder') {\n                    b.width = w;\n                    b.x = 0;\n                    m.width = w;\n                    m.height = self.currentCell.height;\n                    m.y = self.currentCell.y;\n                    fillRect(b.x, b.y, b.width, b.height);\n                    strokeRect(b.x, b.y, b.width, b.height);\n                    self.ctx.lineWidth = self.style.reorderMarkerIndexBorderWidth;\n                    self.ctx.strokeStyle = self.style.reorderMarkerIndexBorderColor;\n                    if (self.currentCell.rowIndex !== self.reorderObject.rowIndex\n                            && self.currentCell.rowIndex > -1\n                            && self.currentCell.rowIndex < l) {\n                        addBorderLine(m, self.reorderTarget.sortRowIndex > self.reorderObject.sortRowIndex ? 'b' : 't');\n                    }\n                } else if (self.dragMode === 'column-reorder' && self.reorderObject) {\n                    b.height = h;\n                    b.y = 0;\n                    m.height = h;\n                    m.width = self.currentCell.width;\n                    m.y = 0;\n                    m.x = self.currentCell.x;\n                    fillRect(b.x, b.y, b.width, b.height);\n                    strokeRect(b.x, b.y, b.width, b.height);\n                    self.ctx.lineWidth = self.style.reorderMarkerIndexBorderWidth;\n                    self.ctx.strokeStyle = self.style.reorderMarkerIndexBorderColor;\n                    if (self.currentCell.columnIndex !== self.reorderObject.columnIndex\n                            && self.currentCell.columnIndex > -1\n                            && self.currentCell.columnIndex < s.length) {\n                        addBorderLine(m, self.reorderTarget.sortColumnIndex > self.reorderObject.sortColumnIndex ? 'r' : 'l');\n                    }\n                }\n            }\n            function drawBorder() {\n                self.ctx.lineWidth = self.style.gridBorderWidth;\n                self.ctx.strokeStyle = self.style.gridBorderColor;\n                strokeRect(0, 0, self.width, self.height);\n            }\n            function drawSelectionBorders() {\n                self.ctx.lineWidth = self.style.selectionOverlayBorderWidth;\n                self.ctx.strokeStyle = self.style.selectionOverlayBorderColor;\n                function dsb(c) {\n                    addBorderLine(c[0], c[1]);\n                }\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex < self.frozenRow && c[0].columnIndex < self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.save();\n                clipFrozenArea(0);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex >= self.frozenRow && c[0].columnIndex >= self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n                self.ctx.save();\n                clipFrozenArea(1);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex >= self.frozenRow && c[0].columnIndex < self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n                self.ctx.save();\n                clipFrozenArea(2);\n                selectionBorders.filter(function (c) {\n                    return c[0].rowIndex < self.frozenRow && c[0].columnIndex >= self.frozenColumn;\n                }).forEach(dsb);\n                self.ctx.restore();\n            }\n            function drawSelectionHandles() {\n                if (self.mobile || self.attributes.allowMovingSelection) {\n                    self.ctx.lineWidth = self.style.selectionHandleBorderWidth;\n                    self.ctx.strokeStyle = self.style.selectionHandleBorderColor;\n                    self.ctx.fillStyle = self.style.selectionHandleColor;\n                    selectionHandles.forEach(function (c) {\n                        addselectionHandle(c[0], c[1]);\n                        var az = self.attributes.touchSelectHandleZone / 2,\n                            ax = c[0].x + (c[1] === 'tl' || c[1] === 'bl' ? 0 : c[0].width) - az,\n                            ay = c[0].y + (c[1] === 'bl' || c[1] === 'br' ? c[0].height : 0) - az;\n                        self.visibleCells.unshift({\n                            x: ax,\n                            y: ay,\n                            height: self.style.selectionHandleSize + az,\n                            width: self.style.selectionHandleSize + az,\n                            style: 'selection-handle-' + c[1]\n                        });\n                    });\n                }\n            }\n            function drawActiveCell() {\n                if (!aCell) { return; }\n                self.ctx.save();\n                var cl = self.activeCell.columnIndex + 1 > self.frozenColumn || self.activeCell.rowIndex + 1 > self.frozenRow,\n                    acx = cl ? self.lastFrozenColumnPixel : 0,\n                    acy = cl ? self.lastFrozenRowPixel : 0,\n                    acw = cl ? self.width - self.lastFrozenColumnPixel : self.width,\n                    ach = cl ? self.height - self.lastFrozenRowPixel : self.height;\n                radiusRect(acx, acy, acw, ach, 0);\n                self.ctx.clip();\n                if (self.attributes.selectionMode === 'row') {\n                    if (self.activeCell && self.activeCell.rowIndex === aCell.rowIndex) {\n                        self.ctx.lineWidth = self.style.activeCellOverlayBorderWidth;\n                        self.ctx.strokeStyle = self.style.activeCellOverlayBorderColor;\n                        strokeRect(0, aCell.y, self.getHeaderWidth() + rowHeaderCellWidth, self.visibleRowHeights[aCell.rowIndex]);\n                    }\n                } else {\n                    self.ctx.lineWidth = self.style.activeCellOverlayBorderWidth;\n                    self.ctx.strokeStyle = self.style.activeCellOverlayBorderColor;\n                    strokeRect(aCell.x, aCell.y, aCell.width, aCell.height);\n                }\n                self.ctx.restore();\n            }\n            function drawFrozenMarkers() {\n                var my = self.lastFrozenRowPixel - self.style.frozenMarkerWidth,\n                    mx = self.lastFrozenColumnPixel - self.style.frozenMarkerBorderWidth,\n                    xHover = self.currentCell && self.currentCell.style === 'frozen-row-marker',\n                    yHover = self.currentCell && self.currentCell.style === 'frozen-column-marker';\n                self.ctx.lineWidth = self.style.frozenMarkerBorderWidth;\n                if (self.attributes.allowFreezingColumns) {\n                    self.ctx.fillStyle = yHover ? self.style.frozenMarkerHoverColor : self.style.frozenMarkerColor;\n                    self.ctx.strokeStyle = yHover ? self.style.frozenMarkerHoverBorderColor : self.style.frozenMarkerBorderColor;\n                    fillRect(mx, 0, self.style.frozenMarkerWidth, self.height);\n                    strokeRect(mx, 0, self.style.frozenMarkerWidth, self.height);\n                    self.visibleCells.unshift({\n                        x: mx,\n                        y: 0,\n                        height: self.height,\n                        width: self.style.frozenMarkerWidth + self.style.frozenMarkerBorderWidth,\n                        style: 'frozen-column-marker'\n                    });\n                }\n                if (self.attributes.allowFreezingRows) {\n                    self.ctx.fillStyle = xHover ? self.style.frozenMarkerHoverColor : self.style.frozenMarkerColor;\n                    self.ctx.strokeStyle = xHover ? self.style.frozenMarkerHoverBorderColor : self.style.frozenMarkerBorderColor;\n                    fillRect(0, my, self.width, self.style.frozenMarkerWidth);\n                    strokeRect(0, my, self.width, self.style.frozenMarkerWidth);\n                    self.visibleCells.unshift({\n                        x: 0,\n                        y: my,\n                        height: self.style.frozenMarkerWidth + self.style.frozenMarkerBorderWidth,\n                        width: self.width,\n                        style: 'frozen-row-marker'\n                    });\n                }\n                if (self.freezeMarkerPosition) {\n                    self.ctx.fillStyle = self.style.frozenMarkerActiveColor;\n                    self.ctx.strokeStyle = self.style.frozenMarkerActiveBorderColor;\n                    if (self.dragMode === 'frozen-column-marker') {\n                        fillRect(self.freezeMarkerPosition.x, 0, self.style.frozenMarkerWidth, self.height);\n                        strokeRect(self.freezeMarkerPosition.x, 0, self.style.frozenMarkerWidth, self.height);\n                    } else {\n                        fillRect(0, self.freezeMarkerPosition.y, self.width, self.style.frozenMarkerWidth);\n                        strokeRect(0, self.freezeMarkerPosition.y, self.width, self.style.frozenMarkerWidth);\n                    }\n                }\n            }\n            function drawPerfLines() {\n                if (!self.attributes.showPerformance) { return; }\n                var pw = 250,\n                    px = self.width - pw - self.style.scrollBarWidth - (self.style.scrollBarBorderWidth * 2),\n                    py = columnHeaderCellHeight,\n                    ph = 100;\n                if (scrollDebugCounters.length === 0) { scrollDebugCounters = self.fillArray(0, perfWindowSize, 1, function () { return [0, 0]; }); }\n                if (touchPPSCounters.length === 0) { touchPPSCounters = self.fillArray(0, perfWindowSize, 1, function () { return [0, 0]; }); }\n                if (entityCount.length === 0) { entityCount = self.fillArray(0, perfWindowSize, 1, 0); }\n                self.ctx.lineWidth = 0.5;\n                function dpl(name, perfArr, arrIndex, max, color, useAbs, rowIndex) {\n                    var v;\n                    drawPerfLine(pw, ph, px, py, perfArr, arrIndex, max, color, useAbs);\n                    self.ctx.fillStyle = color;\n                    fillRect(3 + px, py + 9 + (rowIndex * 11), 8, 8);\n                    self.ctx.fillStyle = '#999999';\n                    v = arrIndex !== undefined ? perfArr[0][arrIndex] : perfArr[0];\n                    fillText(name + ' ' + (isNaN(v) ? 0 : v).toFixed(3), 14 + px, py + 16 + (rowIndex * 11));\n                }\n                self.ctx.textAlign = 'left';\n                self.ctx.font = '8px sans-serif';\n                self.ctx.fillStyle = 'rgba(29, 25, 26, 1.00)';\n                fillRect(px, py, pw, ph);\n                [['Scroll Height', scrollDebugCounters, 0, self.scrollBox.scrollHeight, 'rgba(248, 33, 103, 1.00)', false],\n                    ['Scroll Width', scrollDebugCounters, 1, self.scrollBox.scrollWidth, 'rgba(66, 255, 27, 1.00)', false],\n                    ['Performance', perfCounters, undefined, 200, 'rgba(252, 255, 37, 1.00)', false],\n                    ['Entities', entityCount, undefined, 1500, 'rgba(76, 231, 239, 1.00)', false],\n                    ['TouchPPSX', touchPPSCounters, 0, 1000, 'rgba(246, 102, 24, 1.00)', true],\n                    ['TouchPPSY', touchPPSCounters, 1, 1000, 'purple', true]\n                    ].forEach(function (i, index) {\n                    i.push(index);\n                    dpl.apply(null, i);\n                });\n                self.ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';\n                entityCount.pop();\n                entityCount.unshift(self.visibleCells.length);\n                scrollDebugCounters.pop();\n                scrollDebugCounters.unshift([self.scrollBox.scrollTop, self.scrollBox.scrollLeft]);\n                touchPPSCounters.pop();\n                touchPPSCounters.unshift([self.yPPS, self.xPPS]);\n            }\n            function drawDebug() {\n                self.ctx.save();\n                var d;\n                if (self.attributes.showPerformance || self.attributes.debug) {\n                    if (perfCounters.length === 0) { perfCounters = self.fillArray(0, perfWindowSize, 1, 0); }\n                    perfCounters.pop();\n                    perfCounters.unshift(performance.now() - p);\n                }\n                if (!self.attributes.debug) {\n                    self.ctx.restore();\n                    return;\n                }\n                self.ctx.font = '14px sans-serif';\n                d = {};\n                d.perf = (perfCounters.reduce(function (a, b) {\n                    return a + b;\n                }, 0) / Math.min(drawCount, perfCounters.length)).toFixed(1);\n                d.htmlImages = Object.keys(self.htmlImageCache).length;\n                d.reorderObject = 'x: ' + (self.reorderObject || {columnIndex: 0}).columnIndex + ', y: ' + (self.reorderObject || {rowIndex: 0}).rowIndex;\n                d.reorderTarget = 'x: ' + (self.reorderTarget || {columnIndex: 0}).columnIndex + ', y: ' + (self.reorderTarget || {rowIndex: 0}).rowIndex;\n                d.scale = self.scale;\n                d.startScale = self.startScale;\n                d.scaleDelta = self.scaleDelta;\n                d.zoomDeltaStart = self.zoomDeltaStart;\n                d.touchLength = self.touchLength;\n                d.touches = 'y0: ' + (self.touchPosition || {y: 0}).y + ' y1: ' + (self.touchPosition1 || {y: 0}).y;\n                d.scrollBox = self.scrollBox.toString();\n                d.scrollIndex = 'x: ' + self.scrollIndexLeft + ', y: ' + self.scrollIndexTop;\n                d.scrollPixel = 'x: ' + self.scrollPixelLeft + ', y: ' + self.scrollPixelTop;\n                d.canvasOffset = 'x: ' + self.canvasOffsetLeft + ', y: ' + self.canvasOffsetTop;\n                d.touchDelta = 'x: ' + self.touchDelta.x + ', y: ' + self.touchDelta.y;\n                d.touchAnimateTo = 'x: ' + self.touchAnimateTo.x + ', y: ' + self.touchAnimateTo.y;\n                d.scrollAnimation = 'x: ' + self.scrollAnimation.x + ', y: ' + self.scrollAnimation.y;\n                d.touchPPS = 'x: ' + self.xPPS + ', y: ' + self.yPPS;\n                d.touchPPST = 'x: ' + self.xPPST + ', y: ' + self.yPPST;\n                d.touchDuration = self.touchDuration;\n                d.pointerLockPosition =  self.pointerLockPosition ?\n                        self.pointerLockPosition.x + ', ' + self.pointerLockPosition.y : '';\n                d.size = 'w: ' + self.width + ', h: ' + self.height;\n                d.mouse = 'x: ' + self.mouse.x + ', y: ' + self.mouse.y;\n                d.touch = !self.touchStart\n                    ? '' : 'x: ' + self.touchStart.x + ', y: ' + self.touchStart.y;\n                d.entities = self.visibleCells.length;\n                d.hasFocus = self.hasFocus;\n                d.dragMode = self.dragMode;\n                if (self.currentCell) {\n                    d.columnIndex = self.currentCell.columnIndex;\n                    d.rowIndex = self.currentCell.rowIndex;\n                    d.sortColumnIndex = self.currentCell.sortColumnIndex;\n                    d.sortRowIndex = self.currentCell.sortRowIndex;\n                    d.context = self.currentCell.context;\n                    d.dragContext = self.currentCell.dragContext;\n                    d.style = self.currentCell.style;\n                    d.type = self.currentCell.type;\n                }\n                self.ctx.textAlign = 'right';\n                self.ctx.fillStyle = 'rgba(0, 0, 0, .60)';\n                fillRect(0, 0, self.width, self.height);\n                Object.keys(d).forEach(function (key, index) {\n                    var m = key + ': ' + d[key],\n                        lh = 14;\n                    self.ctx.fillStyle = 'rgba(37, 254, 21, 1)';\n                    fillText(m, w - 20, (self.attributes.showPerformance ? 140 : 24) + (index * lh));\n                });\n                self.ctx.restore();\n            }\n            self.ctx.save();\n            initDraw();\n            drawBackground();\n            drawFrozenRows();\n            drawRows();\n            drawActiveCell();\n            drawHeaders();\n            drawFrozenMarkers();\n            drawSelectionBorders();\n            drawSelectionHandles();\n            drawReorderMarkers();\n            drawMoveMarkers();\n            drawScrollBars();\n            if (checkScrollHeight) {\n                self.resize(true);\n            }\n            drawBorder();\n            drawDebug();\n            drawPerfLines();\n            if (self.dispatchEvent('afterdraw', {})) { return; }\n            self.ctx.restore();\n        };\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/draw.js\n// module id = 3\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true, plusplus: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        var wheeling;\n        self.stopPropagation = function (e) { e.stopPropagation(); };\n        /**\n         * Adds an event listener to the given event.\n         * @memberof canvasDatagrid\n         * @name addEventListener\n         * @method\n         * @param {string} ev The name of the event to subscribe to.\n         * @param {function} fn The event procedure to execute when the event is raised.\n         */\n        self.addEventListener = function (ev, fn) {\n            self.events[ev] = self.events[ev] || [];\n            self.events[ev].unshift(fn);\n        };\n        /**\n         * Removes the given listener function from the given event.  Must be an actual reference to the function that was bound.\n         * @memberof canvasDatagrid\n         * @name removeEventListener\n         * @method\n         * @param {string} ev The name of the event to unsubscribe from.\n         * @param {function} fn The event procedure to execute when the event is raised.\n         */\n        self.removeEventListener = function (ev, fn) {\n            (self.events[ev] || []).forEach(function removeEachListener(sfn, idx) {\n                if (fn === sfn) {\n                    self.events[ev].splice(idx, 1);\n                }\n            });\n        };\n        /**\n         * Fires the given event, padding an event object to the event subscribers.\n         * @memberof canvasDatagrid\n         * @name dispatchEvent\n         * @method\n         * @param {number} ev The name of the event to dispatch.\n         * @param {number} e The event object.\n         */\n        self.dispatchEvent = function (ev, e) {\n            e = ev.type ? ev : (e || {});\n            ev = ev.type || ev;\n            var defaultPrevented;\n            function preventDefault() {\n                defaultPrevented = true;\n            }\n            if (!self.events[ev]) { return; }\n            self.events[ev].forEach(function dispatchEachEvent(fn) {\n                e.ctx = self.ctx;\n                e.preventDefault = preventDefault;\n                fn.apply(self.intf, [e]);\n            });\n            return defaultPrevented;\n        };\n        self.getRatio = function () {\n            return Math.min(self.attributes.maxPixelRatio, (window.devicePixelRatio || 1) /\n                (self.ctx.webkitBackingStorePixelRatio ||\n                    self.ctx.mozBackingStorePixelRatio ||\n                    self.ctx.msBackingStorePixelRatio ||\n                    self.ctx.oBackingStorePixelRatio ||\n                    self.ctx.backingStorePixelRatio || 1));\n        };\n        self.resize = function (drawAfterResize) {\n            if (!self.canvas) { return; }\n            var ratio = self.getRatio(),\n                bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                cellBorder = self.style.cellBorderWidth * bm,\n                columnHeaderCellBorder = self.style.columnHeaderCellBorderWidth * bm,\n                scrollHeight,\n                scrollWidth,\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                ch = self.style.cellHeight,\n                // TODO: What the hell are these numbers!?  They are probably some value in the style.\n                scrollDragPositionOffsetY = 30,\n                scrollDragPositionOffsetX = 15;\n            scrollHeight = self.data.reduce(function reduceData(accumulator, row, rowIndex) {\n                return accumulator\n                    + (((self.sizes.rows[row[self.uniqueId]] || ch) + (self.sizes.trees[row[self.uniqueId]] || 0)) * self.scale)\n                    + cellBorder\n                    // HACK? if an expanded tree row is frozen it is necessary to add the tree row's height a second time.\n                    + (self.frozenRow > rowIndex ? (self.sizes.trees[row[self.uniqueId]] || 0) : 0);\n            }, 0) || 0;\n            scrollWidth = self.getVisibleSchema().reduce(function reduceSchema(accumulator, column) {\n                if (column.hidden) { return accumulator; }\n                return accumulator + ((self.sizes.columns[column[self.uniqueId]] || column.width || self.style.cellWidth) * self.scale) + cellBorder;\n            }, 0) || 0;\n            if (self.isChildGrid) {\n                self.width = self.parentNode.offsetWidth;\n                self.height = self.parentNode.offsetHeight;\n            } else {\n                self.height = self.canvas.offsetHeight;\n                self.width = self.canvas.offsetWidth;\n                self.canvas.width = self.width * ratio;\n                self.canvas.height = self.height * ratio;\n                self.ctx.scale(ratio, ratio);\n                self.canvasOffsetLeft = self.args.canvasOffsetLeft || 0;\n                self.canvasOffsetTop = self.args.canvasOffsetTop || 0;\n            }\n            if (self.attributes.showNewRow) {\n                scrollHeight += ch + cellBorder;\n            }\n            self.scrollBox.width = self.width - rowHeaderCellWidth;\n            self.scrollBox.height = self.height - columnHeaderCellHeight - columnHeaderCellBorder;\n            self.scrollBox.top = columnHeaderCellHeight + columnHeaderCellBorder;\n            self.scrollBox.left = rowHeaderCellWidth;\n            self.scrollBox.scrollHeight = scrollHeight + self.style.scrollBarWidth - self.scrollBox.height;\n            self.scrollBox.scrollWidth = scrollWidth + self.style.scrollBarWidth - self.scrollBox.width;\n            self.scrollBox.widthBoxRatio = ((self.scrollBox.width - scrollDragPositionOffsetX)\n                / (self.scrollBox.scrollWidth + self.scrollBox.width - scrollDragPositionOffsetX));\n            self.scrollBox.scrollBoxWidth = self.scrollBox.width\n                * self.scrollBox.widthBoxRatio\n                - self.style.scrollBarWidth;\n            self.scrollBox.heightBoxRatio = ((self.scrollBox.height - scrollDragPositionOffsetY)\n                / (self.scrollBox.scrollHeight + (self.scrollBox.height - scrollDragPositionOffsetY)));\n            self.scrollBox.scrollBoxHeight = self.scrollBox.height\n                * self.scrollBox.heightBoxRatio\n                - self.style.scrollBarWidth;\n            self.scrollBox.scrollBoxWidth = Math.max(self.scrollBox.scrollBoxWidth, self.style.scrollBarBoxMinSize);\n            self.scrollBox.scrollBoxHeight = Math.max(self.scrollBox.scrollBoxHeight, self.style.scrollBarBoxMinSize);\n            self.page = self.visibleRows.length - 3 - self.attributes.pageUpDownOverlap;\n            self.resizeEditInput();\n            self.scroll(true);\n            if (drawAfterResize) {\n                self.draw(true);\n            }\n            self.dispatchEvent('resize', {});\n            return true;\n        };\n        self.scroll = function (dontDraw) {\n            var bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                s = self.getVisibleSchema(),\n                cellBorder = self.style.cellBorderWidth * bm,\n                ch = self.style.cellHeight;\n            self.scrollIndexTop = 0;\n            self.scrollPixelTop = 0;\n            self.scrollIndexLeft = 0;\n            self.scrollPixelLeft = 0;\n            while (self.scrollPixelTop < self.scrollBox.scrollTop && self.scrollIndexTop < self.data.length) {\n                self.scrollPixelTop +=\n                    (((self.sizes.rows[self.data[self.scrollIndexTop][self.uniqueId]] || ch)\n                        + (self.sizes.trees[self.data[self.scrollIndexTop][self.uniqueId]] || 0)) * self.scale)\n                    + cellBorder;\n                self.scrollIndexTop += 1;\n            }\n            while (self.scrollPixelLeft < self.scrollBox.scrollLeft && self.scrollIndexLeft < s.length) {\n                self.scrollPixelLeft +=\n                    ((self.sizes.columns[s[self.scrollIndexLeft][self.uniqueId]]\n                        || s[self.scrollIndexLeft].width\n                        || self.style.cellWidth) * self.scale)\n                    + cellBorder;\n                self.scrollIndexLeft += 1;\n            }\n            if (self.data.length > 0) {\n                self.scrollIndexLeft = Math.max(self.scrollIndexLeft - 1, 0);\n                self.scrollPixelLeft = Math.max(self.scrollPixelLeft\n                    - ((self.sizes.columns[s[self.scrollIndexLeft][self.uniqueId]] || s[self.scrollIndexLeft].width || self.style.cellWidth) * self.scale), 0);\n                self.scrollIndexTop = Math.max(self.scrollIndexTop - 1, 0);\n                self.scrollPixelTop = Math.max((self.scrollPixelTop\n                    - ((self.sizes.rows[self.data[self.scrollIndexTop][self.uniqueId]] || ch)\n                    + (self.sizes.trees[self.data[self.scrollIndexTop][self.uniqueId]] || 0)) * self.scale), 0);\n            }\n            self.ellipsisCache = {};\n            if (!dontDraw) {\n                self.draw(true);\n            }\n            //TODO: figure out why this has to be delayed for child grids\n            //BUG: wheeling event on 3rd level hierarchy fails to move input box\n            requestAnimationFrame(self.resizeEditInput);\n            self.dispatchEvent('scroll', {top: self.scrollBox.scrollTop, left: self.scrollBox.scrollLeft});\n        };\n        self.mousemove = function (e, overridePos) {\n            if (self.contextMenu || self.input) {\n                return;\n            }\n            self.mouse = overridePos || self.getLayerPos(e);\n            var ctrl = (e.ctrlKey || e.metaKey || self.attributes.persistantSelectionMode),\n                i,\n                vs = self.getVisibleSchema(),\n                dragBounds,\n                sBounds,\n                x = self.mouse.x,\n                y = self.mouse.y,\n                o = self.getCellAt(x, y),\n                delta,\n                ev = {NativeEvent: e, cell: o, x: x, y: y},\n                previousCell = self.currentCell;\n            clearTimeout(self.scrollTimer);\n            if (!self.isInGrid({x: x, y: y})) {\n                self.hasFocus = false;\n            }\n            if (self.dispatchEvent('mousemove', ev)) {\n                return;\n            }\n            if (o && self.currentCell) {\n                self.rowBoundaryCrossed = self.currentCell.rowIndex !== o.rowIndex;\n                self.columnBoundaryCrossed = self.currentCell.columnIndex !== o.columnIndex;\n                self.cellBoundaryCrossed = self.rowBoundaryCrossed || self.columnBoundaryCrossed;\n                ['row', 'column', 'cell'].forEach(function (prefix) {\n                    if (self[prefix + 'BoundaryCrossed']) {\n                        ev.cell = previousCell;\n                        self.dispatchEvent(prefix + 'mouseout', ev);\n                        ev.cell = o;\n                        self.dispatchEvent(prefix + 'mouseover', ev);\n                    }\n                });\n            }\n            self.currentCell = o;\n            if (!self.hasFocus) {\n                return;\n            }\n            self.hovers = {};\n            if (!self.draggingItem\n                    && o\n                    && self.scrollModes.indexOf(o.context) === -1) {\n                self.dragItem = o;\n                self.dragMode = o.dragContext;\n                self.cursor = o.context;\n                if (o.context === 'cell' && o.data) {\n                    self.cursor = 'default';\n                    self.hovers[o.data[self.uniqueId]] = [o.columnIndex];\n                }\n                if ((self.selecting || self.reorderObject)\n                        && o.context === 'cell'\n                        && o.data) {\n                    sBounds = self.getSelectionBounds();\n                    delta = {\n                        x: Math.abs(self.dragStart.x - x),\n                        y: Math.abs(self.dragStart.y - y)\n                    };\n                    if (self.dragStartObject.columnIndex !== -1 && e.shiftKey) {\n                        self.dragStartObject = {\n                            rowIndex: self.activeCell.rowIndex,\n                            columnIndex: self.activeCell.columnIndex\n                        };\n                    }\n                    dragBounds = {\n                        top: Math.min(self.dragStartObject.rowIndex, o.rowIndex),\n                        left: Math.min(self.dragStartObject.columnIndex, o.columnIndex),\n                        bottom: Math.max(self.dragStartObject.rowIndex, o.rowIndex),\n                        right: Math.max(self.dragStartObject.columnIndex, o.columnIndex)\n                    };\n                    if (self.dragStartObject.columnIndex === -1) {\n                        dragBounds.left = -1;\n                        dragBounds.right = vs.length - 1;\n                        dragBounds.top = Math.min(sBounds.top, o.rowIndex);\n                        dragBounds.bottom = Math.max(sBounds.bottom, o.rowIndex);\n                    }\n                    if (self.dragStartObject.rowIndex !== o.rowIndex\n                                || self.dragStartObject.columnIndex !== o.columnIndex) {\n                        self.ignoreNextClick = true;\n                    }\n                    if (self.cellBoundaryCrossed || (delta.x === 0 && delta.y === 0) || (self.attributes.selectionMode === 'row')) {\n                        if (((self.attributes.selectionMode === 'row') || self.dragStartObject.columnIndex === -1)\n                                && self.rowBoundaryCrossed) {\n                            self.selectRow(o.rowIndex, ctrl, null, true);\n                        } else if (self.attributes.selectionMode !== 'row') {\n                            if (!self.dragAddToSelection && o.rowIndex !== undefined) {\n                                if (self.selections[o.rowIndex] && self.selections[o.rowIndex].indexOf(o.columnIndex) !== -1) {\n                                    self.selections[o.rowIndex].splice(self.selections[o.rowIndex].indexOf(o.columnIndex), 1);\n                                }\n                            } else {\n                                self.selections[o.rowIndex] = self.selections[o.rowIndex] || [];\n                                if (self.selections[o.rowIndex].indexOf(o.columnIndex) === -1) {\n                                    self.selections[o.rowIndex].push(o.columnIndex);\n                                }\n                            }\n                        }\n                    }\n                    if ((!self.selectionBounds || (dragBounds.top !== self.selectionBounds.top\n                            || dragBounds.left !== self.selectionBounds.left\n                            || dragBounds.bottom !== self.selectionBounds.bottom\n                            || dragBounds.right !== self.selectionBounds.right)) && !ctrl) {\n                        self.selections = [];\n                        sBounds = dragBounds;\n                        if (self.attributes.selectionMode === 'row') {\n                            for (i = sBounds.top; i <= sBounds.bottom; i += 1) {\n                                self.selectRow(i, true, null, true);\n                            }\n                        } else if (dragBounds.top !== -1) {\n                            self.selectArea(sBounds, true);\n                        }\n                    }\n                    self.autoScrollZone(e, x, y, ctrl);\n                }\n            }\n            self.cellBoundaryCrossed = false;\n            self.rowBoundaryCrossed = false;\n            self.columnBoundaryCrossed = false;\n            self.draw(true);\n        };\n        self.click = function (e, overridePos) {\n            var i,\n                ctrl = (e.ctrlKey || e.metaKey || self.attributes.persistantSelectionMode),\n                pos = overridePos || self.getLayerPos(e);\n            self.currentCell = self.getCellAt(pos.x, pos.y);\n            if (self.currentCell.grid !== undefined) {\n                return;\n            }\n            function checkSelectionChange() {\n                self.dispatchEvent('selectionchanged', {\n                    selectedData: self.getSelectedData(),\n                    selections: self.selections,\n                    selectionBounds: self.selectionBounds\n                });\n            }\n            if (self.input) {\n                self.endEdit();\n            }\n            if (self.ignoreNextClick) {\n                self.ignoreNextClick = false;\n                return;\n            }\n            i = self.currentCell;\n            if (self.dispatchEvent('click', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (['rowHeaderCell', 'columnHeaderCell'].indexOf(self.currentCell.style) === -1 && !ctrl) {\n                self.setActiveCell(i.columnIndex, i.rowIndex);\n            }\n            if (self.currentCell.context === 'cell') {\n                if (self.currentCell.style === 'cornerCell') {\n                    self.selectAll();\n                    self.draw();\n                    checkSelectionChange();\n                    return;\n                }\n                if (self.currentCell.style === 'columnHeaderCell') {\n                    if (self.attributes.columnHeaderClickBehavior === 'sort') {\n                        if (self.orderBy === i.header.name) {\n                            self.orderDirection = self.orderDirection === 'asc' ? 'desc' : 'asc';\n                        } else {\n                            self.orderDirection = 'asc';\n                        }\n                        self.order(i.header.name, self.orderDirection);\n                        checkSelectionChange();\n                        return;\n                    }\n                    if (self.attributes.columnHeaderClickBehavior === 'select') {\n                        self.selectColumn(i.header.index, ctrl, e.shiftKey, true);\n                        checkSelectionChange();\n                        self.draw();\n                        return;\n                    }\n                }\n                self.selections[i.rowIndex] = self.selections[i.rowIndex] || [];\n                if (((self.attributes.selectionMode === 'row') || self.currentCell.style === 'rowHeaderCell')) {\n                    if (self.currentCell.style === 'rowHeaderCell'\n                            && self.attributes.tree && pos.x > 0\n                            && pos.x - self.currentCell.x < self.style.treeArrowWidth\n                            + self.style.treeArrowMarginLeft\n                            + self.style.treeArrowMarginRight + self.style.treeArrowClickRadius\n                            && pos.y - self.currentCell.y < self.style.treeArrowHeight\n                            + self.style.treeArrowMarginTop + self.style.treeArrowClickRadius\n                            && pos.y > 0) {\n                        self.toggleTree(i.rowIndex);\n                        return;\n                    }\n                }\n                if (e.shiftKey && !ctrl) {\n                    self.selectionBounds = self.getSelectionBounds();\n                    self.selectArea(undefined, false);\n                }\n            }\n            checkSelectionChange();\n            self.draw(true);\n        };\n        self.dragResizeColumn = function (e) {\n            var pos, x, y;\n            pos = self.getLayerPos(e);\n            x = self.resizingStartingWidth + pos.x - self.dragStart.x;\n            y = self.resizingStartingHeight + pos.y - self.dragStart.y;\n            if (x < self.style.minColumnWidth) {\n                x = self.style.minColumnWidth;\n            }\n            if (y < self.style.minRowHeight) {\n                y = self.style.minRowHeight;\n            }\n            if (self.dispatchEvent('resizecolumn', {x: x, y: y, draggingItem: self.draggingItem})) { return false; }\n            if (self.scrollBox.scrollLeft > self.scrollBox.scrollWidth - self.attributes.resizeScrollZone\n                    && self.dragMode === 'ew-resize') {\n                self.resize(true);\n                self.scrollBox.scrollLeft += x;\n            }\n            if (self.dragMode === 'ew-resize') {\n                self.sizes.columns[self.draggingItem.header.style === 'rowHeaderCell'\n                       ? 'cornerCell' : self.draggingItem.header[self.uniqueId]] = x;\n                if (['rowHeaderCell', 'cornerCell'].indexOf(self.draggingItem.header.style) !== -1) {\n                    self.resize(true);\n                }\n                self.resizeChildGrids();\n                return;\n            }\n            if (self.dragMode === 'ns-resize') {\n                if (self.draggingItem.rowOpen) {\n                    self.sizes.trees[self.draggingItem.data[self.uniqueId]] = y;\n                } else if (self.attributes.globalRowResize) {\n                    self.style.cellHeight = y;\n                } else {\n                    self.sizes.rows[self.draggingItem.data[self.uniqueId]] = y;\n                }\n                self.dispatchEvent('resizerow', {row: y});\n                self.resizeChildGrids();\n                return;\n            }\n            self.ellipsisCache = {};\n        };\n        self.stopDragResize = function () {\n            self.resize();\n            document.body.removeEventListener('mousemove', self.dragResizeColumn, false);\n            document.body.removeEventListener('mouseup', self.stopDragResize, false);\n            self.setStorageData();\n            self.draw(true);\n            self.ignoreNextClick = true;\n        };\n        self.scrollGrid = function (e) {\n            var pos = self.getLayerPos(e);\n            if (self.attributes.scrollPointerLock && self.pointerLockPosition\n                    && ['horizontal-scroll-box', 'vertical-scroll-box'].indexOf(self.scrollStartMode) !== -1) {\n                self.pointerLockPosition.x += e.movementX;\n                self.pointerLockPosition.y += e.movementY;\n                self.pointerLockPosition.x = Math.min(self.width - self.style.scrollBarWidth, Math.max(0, self.pointerLockPosition.x));\n                self.pointerLockPosition.y = Math.min(self.height - self.style.scrollBarWidth, Math.max(0, self.pointerLockPosition.y));\n                pos = self.pointerLockPosition;\n            }\n            self.scrollMode = self.getCellAt(pos.x, pos.y).context;\n            if (self.scrollMode === 'horizontal-scroll-box' && self.scrollStartMode !== 'horizontal-scroll-box') {\n                self.scrollStartMode = 'horizontal-scroll-box';\n                self.dragStart = pos;\n                self.scrollStart.left = self.scrollBox.scrollLeft;\n                clearTimeout(self.scrollTimer);\n                return;\n            }\n            if (self.scrollMode === 'vertical-scroll-box' && self.scrollStartMode !== 'vertical-scroll-box') {\n                self.scrollStartMode = 'vertical-scroll-box';\n                self.dragStart = pos;\n                self.scrollStart.top = self.scrollBox.scrollTop;\n                clearTimeout(self.scrollTimer);\n                return;\n            }\n            if (self.scrollStartMode === 'vertical-scroll-box'\n                    && self.scrollMode !== 'vertical-scroll-box') {\n                self.scrollMode = 'vertical-scroll-box';\n            }\n            if (self.scrollStartMode === 'horizontal-scroll-box'\n                    && self.scrollMode !== 'horizontal-scroll-box') {\n                self.scrollMode = 'horizontal-scroll-box';\n            }\n            clearTimeout(self.scrollTimer);\n            if (self.scrollModes.indexOf(self.scrollMode) === -1) {\n                return;\n            }\n            if (self.scrollMode === 'vertical-scroll-box') {\n                self.scrollBox.scrollTop = self.scrollStart.top + ((pos.y - self.dragStart.y)\n                    / self.scrollBox.heightBoxRatio);\n            } else if (self.scrollMode === 'vertical-scroll-top') {\n                self.scrollBox.scrollTop -= (self.page * self.style.cellHeight);\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            } else if (self.scrollMode === 'vertical-scroll-bottom') {\n                self.scrollBox.scrollTop += (self.page * self.style.cellHeight);\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            }\n            if (self.scrollMode === 'horizontal-scroll-box') {\n                self.scrollBox.scrollLeft = self.scrollStart.left + ((pos.x - self.dragStart.x)\n                    / self.scrollBox.widthBoxRatio);\n            } else if (self.scrollMode === 'horizontal-scroll-right') {\n                self.scrollBox.scrollLeft += self.attributes.selectionScrollIncrement;\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            } else if (self.scrollMode === 'horizontal-scroll-left') {\n                self.scrollBox.scrollLeft -= self.attributes.selectionScrollIncrement;\n                self.scrollTimer = setTimeout(self.scrollGrid, self.attributes.scrollRepeatRate, e);\n            }\n        };\n        self.stopScrollGrid = function () {\n            clearTimeout(self.scrollTimer);\n            if (document.exitPointerLock) {\n                document.exitPointerLock();\n            }\n            document.body.removeEventListener('mousemove', self.scrollGrid, false);\n        };\n        self.dragReorder = function (e) {\n            var pos, x, y;\n            pos = self.getLayerPos(e);\n            x = pos.x - self.dragStart.x;\n            y = pos.y - self.dragStart.y;\n            if (!self.attributes.allowColumnReordering && self.dragMode === 'column-reorder') {\n                return;\n            }\n            if (!self.attributes.allowRowReordering && self.dragMode === 'row-reorder') {\n                return;\n            }\n            if (self.dispatchEvent('reordering', {\n                    NativeEvent: e,\n                    source: self.dragStartObject,\n                    target: self.currentCell,\n                    dragMode: self.dragMode\n                })) {\n                return;\n            }\n            if (Math.abs(x) > self.attributes.reorderDeadZone || Math.abs(y) > self.attributes.reorderDeadZone) {\n                self.reorderObject = self.draggingItem;\n                self.reorderTarget = self.currentCell;\n                self.reorderObject.dragOffset = {\n                    x: x,\n                    y: y\n                };\n                self.autoScrollZone(e, pos.x, pos.y, false);\n            }\n        };\n        self.stopDragReorder = function (e) {\n            var oIndex,\n                tIndex,\n                cr = {\n                    'row-reorder': self.orders.rows,\n                    'column-reorder': self.orders.columns\n                },\n                i = {\n                    'row-reorder': 'rowIndex',\n                    'column-reorder': 'columnIndex'\n                }[self.dragMode];\n            document.body.removeEventListener('mousemove', self.dragReorder, false);\n            document.body.removeEventListener('mouseup', self.stopDragReorder, false);\n            if (self.reorderObject\n                    && self.reorderTarget\n                    && ((self.dragMode === 'column-reorder' && self.reorderTarget.columnIndex > -1\n                        && self.reorderTarget.columnIndex < self.getVisibleSchema().length)\n                    || (self.dragMode === 'row-reorder' && self.reorderTarget.rowIndex > -1\n                        && self.reorderTarget.rowIndex < self.data.length))\n                    && self.reorderObject[i] !== self.reorderTarget[i]\n                    && !self.dispatchEvent('reorder', {\n                        NativeEvent: e,\n                        source: self.reorderObject,\n                        target: self.reorderTarget,\n                        dragMode: self.dragMode\n                    })) {\n                self.ignoreNextClick = true;\n                oIndex = cr[self.dragMode].indexOf(self.reorderObject[i]);\n                tIndex = cr[self.dragMode].indexOf(self.reorderTarget[i]);\n                cr[self.dragMode].splice(oIndex, 1);\n                cr[self.dragMode].splice(tIndex, 0, self.reorderObject[i]);\n                self.setStorageData();\n            }\n            self.reorderObject = undefined;\n            self.reorderTarget = undefined;\n            self.draw(true);\n        };\n        self.dragMove = function (e) {\n            if (self.dispatchEvent('moving', {NativeEvent: e, cell: self.currentCell})) { return; }\n            var pos = self.getLayerPos(e);\n            self.moveOffset = {\n                x: self.currentCell.columnIndex - self.dragStartObject.columnIndex,\n                y: self.currentCell.rowIndex - self.dragStartObject.rowIndex\n            };\n            if (Math.abs(pos.x) > self.attributes.reorderDeadZone || Math.abs(pos.y) > self.attributes.reorderDeadZone) {\n                setTimeout(function () {\n                    self.autoScrollZone(e, pos.x, pos.y, false);\n                }, 1);\n            }\n        };\n        self.stopDragMove = function (e) {\n            document.body.removeEventListener('mousemove', self.dragMove, false);\n            document.body.removeEventListener('mouseup', self.stopDragMove, false);\n            var b = self.getSelectionBounds();\n            if (self.dispatchEvent('endmove', {NativeEvent: e, cell: self.currentCell})) {\n                self.movingSelection = undefined;\n                self.moveOffset = undefined;\n                self.draw(true);\n                return;\n            }\n            if (self.moveOffset) {\n                self.moveTo(self.movingSelection, b.left + self.moveOffset.x, b.top + self.moveOffset.y);\n                self.moveSelection(self.moveOffset.x, self.moveOffset.y);\n            }\n            self.movingSelection = undefined;\n            self.moveOffset = undefined;\n            self.draw(true);\n        };\n        self.freezeMove = function (e) {\n            if (self.dispatchEvent('freezemoving', {NativeEvent: e, cell: self.currentCell})) { return; }\n            var pos = self.getLayerPos(e);\n            self.ignoreNextClick = true;\n            self.freezeMarkerPosition = pos;\n            if (self.currentCell && self.currentCell.rowIndex !== undefined && self.dragMode === 'frozen-row-marker') {\n                self.scrollBox.scrollTop = 0;\n                self.frozenRow = self.currentCell.rowIndex + 1;\n            }\n            if (self.currentCell && self.currentCell.columnIndex !== undefined && self.dragMode === 'frozen-column-marker') {\n                self.scrollBox.scrollLeft = 0;\n                self.frozenColumn = self.currentCell.columnIndex + 1;\n            }\n            if (Math.abs(pos.x) > self.attributes.reorderDeadZone || Math.abs(pos.y) > self.attributes.reorderDeadZone) {\n                setTimeout(function () {\n                    self.autoScrollZone(e, pos.x, pos.y, false);\n                }, 1);\n            }\n        };\n        self.stopFreezeMove = function (e) {\n            document.body.removeEventListener('mousemove', self.freezeMove, false);\n            document.body.removeEventListener('mouseup', self.stopFreezeMove, false);\n            self.freezeMarkerPosition = undefined;\n            if (self.dispatchEvent('endfreezemove', {NativeEvent: e})) {\n                self.frozenRow = self.startFreezeMove.x;\n                self.frozenColumn = self.startFreezeMove.y;\n                self.draw(true);\n                return;\n            }\n            self.draw(true);\n        };\n        self.mousedown = function (e, overridePos) {\n            self.lastMouseDownTarget = e.target;\n            if (self.dispatchEvent('mousedown', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (e.button === 2 || self.input) { return; }\n            var ctrl = (e.ctrlKey || e.metaKey),\n                move = /-move/.test(self.dragMode),\n                freeze = /frozen-row-marker|frozen-column-marker/.test(self.dragMode),\n                resize = /-resize/.test(self.dragMode);\n            self.dragStart = overridePos || self.getLayerPos(e);\n            self.scrollStart = {\n                left: self.scrollBox.scrollLeft,\n                top: self.scrollBox.scrollTop\n            };\n            self.dragStartObject = self.getCellAt(self.dragStart.x, self.dragStart.y);\n            self.dragAddToSelection = !self.dragStartObject.selected;\n            if (!ctrl && !e.shiftKey && !/(vertical|horizontal)-scroll-(bar|box)/\n                    .test(self.dragStartObject.context)\n                    && self.currentCell\n                    && !self.currentCell.isColumnHeader\n                    && !move\n                    && !freeze\n                    && !resize) {\n                self.selections = [];\n            }\n            if (self.dragStartObject.isGrid) {\n                return;\n            }\n            if (self.scrollModes.indexOf(self.dragStartObject.context) !== -1) {\n                self.scrollMode = self.dragStartObject.context;\n                self.scrollStartMode = self.dragStartObject.context;\n                self.scrollGrid(e);\n                if (self.attributes.scrollPointerLock\n                        && ['horizontal-scroll-box', 'vertical-scroll-box'].indexOf(self.scrollStartMode) !== -1) {\n                    self.pointerLockPosition = {\n                        x: self.dragStart.x,\n                        y: self.dragStart.y\n                    };\n                    self.canvas.requestPointerLock();\n                }\n                document.body.addEventListener('mousemove', self.scrollGrid, false);\n                document.body.addEventListener('mouseup', self.stopScrollGrid, false);\n                self.ignoreNextClick = true;\n                return;\n            }\n            if (self.dragMode === 'cell') {\n                self.selecting = true;\n                if ((self.attributes.selectionMode === 'row' || self.dragStartObject.columnIndex === -1)\n                        && self.dragStartObject.rowIndex > -1) {\n                    self.selectRow(self.dragStartObject.rowIndex, ctrl, null, true);\n                } else if (self.attributes.selectionMode !== 'row') {\n                    self.mousemove(e);\n                }\n                return;\n            }\n            if (move) {\n                self.draggingItem = self.dragItem;\n                self.movingSelection = self.selections.concat([]);\n                self.dragging = self.dragStartObject;\n                if (self.dispatchEvent('beginmove', {NativeEvent: e, cell: self.currentCell})) { return; }\n                document.body.addEventListener('mousemove', self.dragMove, false);\n                document.body.addEventListener('mouseup', self.stopDragMove, false);\n                return self.mousemove(e);\n            }\n            if (freeze) {\n                self.draggingItem = self.dragItem;\n                self.startFreezeMove = {\n                    x: self.frozenRow,\n                    y: self.frozenColumn\n                };\n                if (self.dispatchEvent('beginfreezemove', {NativeEvent: e})) { return; }\n                document.body.addEventListener('mousemove', self.freezeMove, false);\n                document.body.addEventListener('mouseup', self.stopFreezeMove, false);\n                return self.mousemove(e);\n            }\n            if (resize) {\n                self.draggingItem = self.dragItem;\n                if (self.draggingItem.rowOpen) {\n                    self.resizingStartingHeight = self.sizes.trees[self.draggingItem.data[self.uniqueId]];\n                } else {\n                    self.resizingStartingHeight = self.sizes.rows[self.draggingItem.data[self.uniqueId]] || self.style.cellHeight;\n                }\n                self.resizingStartingWidth = self.sizes.columns[self.draggingItem.header.style === 'rowHeaderCell'\n                       ? 'cornerCell' : self.draggingItem.header[self.uniqueId]] || self.draggingItem.width;\n                document.body.addEventListener('mousemove', self.dragResizeColumn, false);\n                document.body.addEventListener('mouseup', self.stopDragResize, false);\n                return;\n            }\n            if (['row-reorder', 'column-reorder'].indexOf(self.dragMode) !== -1) {\n                self.draggingItem = self.dragStartObject;\n                document.body.addEventListener('mousemove', self.dragReorder, false);\n                document.body.addEventListener('mouseup', self.stopDragReorder, false);\n                return;\n            }\n        };\n        self.mouseup = function (e) {\n            clearTimeout(self.scrollTimer);\n            self.cellBoundaryCrossed = true;\n            self.rowBoundaryCrossed = true;\n            self.columnBoundaryCrossed = true;\n            self.selecting = undefined;\n            self.draggingItem = undefined;\n            self.dragStartObject = undefined;\n            if (self.dispatchEvent('mouseup', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus && e.target !== self.canvas) {\n                return;\n            }\n            if (self.currentCell && self.currentCell.grid !== undefined) {\n                return;\n            }\n            if (self.contextMenu || self.input) { return; }\n            if (self.dragStart && self.isInGrid(self.dragStart)) {\n                self.controlInput.focus();\n            }\n            e.preventDefault();\n        };\n        self.keydown = function (e) {\n            var i,\n                x = self.activeCell.columnIndex,\n                y = self.activeCell.rowIndex,\n                ctrl = (e.ctrlKey || e.metaKey),\n                last = self.data.length - 1,\n                cols = self.getVisibleSchema().length - 1;\n            if (self.dispatchEvent('keydown', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            self.page = self.visibleRows.length - 3 - self.attributes.pageUpDownOverlap;\n            if (self.attributes.showNewRow) {\n                last += 1;\n            }\n            if (e.keyCode === 9) {\n                e.preventDefault();\n            }\n            // esc\n            if (e.keyCode === 27) {\n                self.selections = [];\n                self.draw(true);\n            // ctrl + a\n            } else if (ctrl && e.keyCode === 65) {\n                self.selectAll();\n            //ArrowDown\n            } else if (e.keyCode === 40) {\n                y += 1;\n            //ArrowUp\n            } else if (e.keyCode === 38) {\n                y -= 1;\n            //ArrowLeft Tab\n            } else if (e.keyCode === 37 || (e.shiftKey && e.keyCode === 9)) {\n                x -= 1;\n            //ArrowRight Tab\n            } else if (e.keyCode === 39 || (!e.shiftKey && e.keyCode === 9)) {\n                x += 1;\n            //PageUp\n            } else if (e.keyCode === 33) {\n                y -= self.page;\n                e.preventDefault();\n            //PageDown\n            } else if (e.keyCode === 34) {\n                y += self.page;\n                e.preventDefault();\n            //Home ArrowUp\n            } else if (e.keyCode === 36 || (ctrl && e.keyCode === 38)) {\n                y = 0;\n            //End ArrowDown\n            } else if (e.keyCode === 35 || (ctrl && e.keyCode === 40)) {\n                y = self.data.length - 1;\n            //ArrowRight\n            } else if (ctrl && e.keyCode === 39) {\n                x = cols;\n            //ArrowLeft\n            } else if (ctrl && e.keyCode === 37) {\n                x = 0;\n            }\n            //Enter\n            if (e.keyCode === 13) {\n                return self.beginEditAt(x, y);\n            }\n            //Space\n            if (e.keyCode === 32) {\n                self.selections = [];\n                self.selections[Math.max(y, 0)] = [];\n                self.selections[Math.max(y, 0)].push(x);\n                self.selectionBounds = self.getSelectionBounds();\n                if (self.attributes.selectionMode === 'row') {\n                    for (i = self.selectionBounds.top; i <= self.selectionBounds.bottom; i += 1) {\n                        self.selectRow(i, ctrl, null, true);\n                    }\n                } else {\n                    self.selectArea(undefined, ctrl);\n                }\n                e.preventDefault();\n                self.draw(true);\n                return;\n            }\n            if (x < 0) {\n                x = 0;\n            }\n            if (y > last) {\n                y = last;\n            }\n            if (y < 0) {\n                y = 0;\n            }\n            if (x > cols) {\n                x = cols;\n            }\n            // Arrows\n            if (e.shiftKey && [37, 38, 39, 40].indexOf(e.keyCode) !== -1) {\n                self.selections[Math.max(y, 0)] = self.selections[Math.max(y, 0)] || [];\n                self.selections[Math.max(y, 0)].push(x);\n                self.selectionBounds = self.getSelectionBounds();\n                self.selectArea(undefined, ctrl);\n                self.draw(true);\n            }\n            if (x !== self.activeCell.columnIndex || y !== self.activeCell.rowIndex) {\n                self.scrollIntoView(x !== self.activeCell.columnIndex ? x : undefined, y !== self.activeCell.rowIndex ? y : undefined);\n                self.setActiveCell(x, y);\n                if (!e.shiftKey && self.attributes.selectionFollowsActiveCell) {\n                    if (!ctrl) {\n                        self.selections = [];\n                    }\n                    self.selections[y] = self.selections[y] || [];\n                    self.selections[y].push(x);\n                    self.dispatchEvent('selectionchanged', {\n                        selectedData: self.getSelectedData(),\n                        selections: self.selections,\n                        selectionBounds: self.selectionBounds\n                    });\n                }\n                self.draw(true);\n            }\n        };\n        self.keyup = function (e) {\n            if (self.dispatchEvent('keyup', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n        };\n        self.keypress = function (e) {\n            if (!self.hasFocus) {\n                return;\n            }\n            if (self.dispatchEvent('keypress', {NativeEvent: e, cell: self.currentCell})) { return; }\n        };\n        self.dblclick = function (e) {\n            if (self.dispatchEvent('dblclick', {NativeEvent: e, cell: self.currentCell})) { return; }\n            if (!self.hasFocus) {\n                return;\n            }\n            if (self.currentCell.context === 'ew-resize'\n                    && self.currentCell.style === 'columnHeaderCell') {\n                self.fitColumnToValues(self.currentCell.header.name);\n            } else if (self.currentCell.context === 'ew-resize'\n                    && self.currentCell.style === 'cornerCell') {\n                self.autosize();\n            } else if (['cell', 'activeCell'].indexOf(self.currentCell.style) !== -1) {\n                self.beginEditAt(self.currentCell.columnIndex, self.currentCell.rowIndex);\n            }\n        };\n        self.scrollWheel = function (e) {\n            var l,\n                t,\n                deltaX = e.deltaX === undefined ? e.NativeEvent.deltaX : e.deltaX,\n                deltaY = e.deltaY === undefined ? e.NativeEvent.deltaY : e.deltaY,\n                deltaMode = e.deltaMode === undefined ? e.NativeEvent.deltaMode : e.deltaMode;\n            if (wheeling) {\n                return;\n            }\n            if (self.dispatchEvent('wheel', {NativeEvent: e})) {\n                return;\n            }\n            e = e.NativeEvent || e;\n            self.touchHaltAnimation = true;\n            l = self.scrollBox.scrollLeft;\n            t = self.scrollBox.scrollTop;\n            if (self.hasFocus) {\n                //BUG Issue 42: https://github.com/TonyGermaneri/canvas-datagrid/issues/42\n                //https://stackoverflow.com/questions/20110224/what-is-the-height-of-a-line-in-a-wheel-event-deltamode-dom-delta-line\n                if (deltaMode === 1) {\n                    // line mode = 17 pixels per line\n                    deltaY = deltaY * 17;\n                }\n                if ((self.scrollBox.scrollTop < self.scrollBox.scrollHeight && deltaY > 0)\n                        || (self.scrollBox.scrollLeft < self.scrollBox.scrollWidth && deltaX > 0)\n                        || (self.scrollBox.scrollTop > 0 && deltaY < 0)\n                        || (self.scrollBox.scrollLeft > 0 && deltaX < 0)) {\n                    e.preventDefault(e);\n                }\n                wheeling = setTimeout(function () {\n                    wheeling = undefined;\n                    self.scrollBox.scrollTo(deltaX + l, deltaY + t);\n                }, 1);\n            }\n        };\n        self.pasteItem = function (clipData, x, y, mimeType) {\n            var l, s = self.getVisibleSchema(), yi = y - 1, sel = [];\n            function normalizeRowData(importingRow, existingRow, offsetX, schema, mimeType, rowIndex) {\n                var r = existingRow;\n                if (!Array.isArray(importingRow) && importingRow !== null && typeof importingRow === 'object') {\n                    importingRow = Object.keys(importingRow).map(function (colKey) {\n                        return importingRow[colKey];\n                    });\n                }\n                if (/^text\\/html/.test(mimeType)) {\n                    importingRow = importingRow.substring(4, importingRow.length - 5).split('</td><td>');\n                }\n                if (typeof importingRow === 'string') {\n                    importingRow = [importingRow];\n                }\n                sel[rowIndex] = [];\n                importingRow.forEach(function (cellData, colIndex) {\n                    var cName = schema[colIndex + offsetX].name;\n                    if (importingRow[colIndex] === undefined || importingRow[colIndex] === null) {\n                        r[cName] = existingRow[cName];\n                        return;\n                    }\n                    sel[rowIndex].push(colIndex + offsetX);\n                    r[cName] = importingRow[colIndex];\n                });\n                return r;\n            }\n            if (/^text\\/html/.test(mimeType)) {\n                if (!/^(<meta[^>]+>)?<table>/.test(clipData.substring(0, 29))) {\n                    console.warn('Unrecognized HTML format.  HTML must be a simple table, e.g.: <table><tr><td>data</td></tr></table>.  Data with the mime type text/html not in this format will not be imported as row data.');\n                    return;\n                }\n                // strip table beginning and ending off, then split at rows\n                clipData = clipData.substring(clipData.indexOf('<table><tr>') + 11, clipData.length - 13).split('</tr><tr>');\n            } else {\n                clipData = clipData.split('\\n');\n            }\n            l = clipData.length;\n            clipData.forEach(function (rowData) {\n                yi += 1;\n                self.data[yi] = normalizeRowData(rowData, self.data[yi], x, s, mimeType, yi);\n            });\n            self.selections = sel;\n            return l;\n        };\n        self.paste = function (e) {\n            var d;\n            function getItem(dti) {\n                var type = dti.type;\n                dti.getAsString(function (s) {\n                    self.pasteItem(s, self.activeCell.columnIndex, self.activeCell.rowIndex, type);\n                    self.draw();\n                });\n            }\n            d = Array.prototype.filter.call(e.clipboardData.items, function (dti) {\n                return dti.type === 'text/html';\n            })[0] || Array.prototype.filter(function (dti) {\n                return dti.type === 'text/csv';\n            })[0] || Array.prototype.filter(function (dti) {\n                return dti.type === 'text/plain';\n            })[0];\n            if (!d) {\n                console.warn('Cannot find supported clipboard data type.  Supported types are text/html, text/csv, text/plain.');\n                return;\n            }\n            getItem(d);\n        };\n        self.cut = function (e) {\n            self.copy(e);\n            self.forEachSelectedCell(function (data, index, colName) {\n                data[index][colName] = '';\n            });\n        };\n        self.copy = function (e) {\n            if (self.dispatchEvent('copy', {NativeEvent: e})) { return; }\n            if (!self.hasFocus || !e.clipboardData) { return; }\n            var t,\n                d,\n                rows = [],\n                trows = [],\n                sData = self.getSelectedData();\n            function fCopyCell(d) {\n                d = d === null || d === undefined ? '' : d;\n                return '<td>' + (typeof d === 'string' ? d.replace(/</g, '&lt;').replace(/>/g, '&gt;') : d) + '</td>';\n            }\n            if (sData.length > 0) {\n                sData.forEach(function (row) {\n                    if (row) {\n                        // r = array for HTML, rt = array for plain text\n                        var r = [],\n                            rt = [];\n                        Object.keys(row).forEach(function (key) {\n                            // escape strings\n                            if (row[key] !== null\n                                    && row[key] !== false\n                                    && row[key] !== undefined\n                                    && row[key].replace) {\n                                rt.push('\"' + row[key].replace(/\"/g, '\"\"') + '\"');\n                                r.push(fCopyCell(row[key]));\n                                return;\n                            }\n                            rt.push(row[key]);\n                            r.push(fCopyCell(row[key]));\n                        });\n                        rows.push(r.join(''));\n                        trows.push(rt.join(','));\n                    }\n                });\n                d = '<table><tr>' + rows.join('</tr><tr>') + '</tr></table>';\n                t = trows.join('\\n');\n                e.clipboardData.setData('text/html', d);\n                e.clipboardData.setData('text/plain', t);\n                e.clipboardData.setData('text/csv', t);\n                e.preventDefault();\n            }\n        };\n        return;\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/events.js\n// module id = 4\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true, plusplus: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        var touchTimerMs = 50,\n            touchScrollTimeout;\n        self.scrollAnimation = {};\n        self.touchDelta = {};\n        self.touchAnimateTo = {};\n        self.animationFrames = 0;\n        self.getTouchPos = function (e, touchIndex) {\n            var t = touchIndex ? e.touches[touchIndex] : e.touches[0],\n                rect = self.canvas.getBoundingClientRect(),\n                pos;\n            if (!t) { return; }\n            pos = {\n                x: t.clientX - rect.left,\n                y: t.clientY - rect.top\n            };\n            if (self.isChildGrid) {\n                pos.x -= self.canvasOffsetLeft;\n                pos.y -= self.canvasOffsetTop;\n            }\n            return {\n                x: pos.x,\n                y: pos.y,\n                rect: rect\n            };\n        };\n        // shamelessly stolen from from https://gist.github.com/gre/1650294\n        self.easingFunctions = {\n            linear: function (t) { return t; },\n            easeInQuad: function (t) { return t * t; },\n            easeOutQuad: function (t) { return t * (2 - t); },\n            easeInOutQuad: function (t) { return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t; },\n            easeInCubic: function (t) { return t * t * t; },\n            easeOutCubic: function (t) { return (--t) * t * t + 1; },\n            easeInOutCubic: function (t) { return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1; },\n            easeInQuart: function (t) { return t * t * t * t; },\n            easeOutQuart: function (t) { return 1 - (--t) * t * t * t; },\n            easeInOutQuart: function (t) { return t < 0.5 ? 8 * t  * t  * t * t : 1 - 8 * (--t) * t * t * t; },\n            easeInQuint: function (t) { return t * t * t * t * t; },\n            easeOutQuint: function (t) { return 1 + (--t) * t *  t * t * t; },\n            easeInOutQuint: function (t) { return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t; }\n        };\n        self.easing = function (t, b, c, d) {\n            return c * self.easingFunctions[self.attributes.touchEasingMethod](t / d) + b;\n        };\n        self.calculatePPSTimed = function () {\n            self.xPPST = -((self.touchDelta.x - self.touchSigmaTimed.x) / (self.touchDelta.t - self.touchSigmaTimed.t));\n            self.yPPST = -((self.touchDelta.y - self.touchSigmaTimed.y) / (self.touchDelta.t - self.touchSigmaTimed.t));\n            self.touchSigmaTimed = {\n                x: self.touchDelta.x,\n                y: self.touchDelta.y,\n                t: performance.now()\n            };\n        };\n        self.calculatePPS = function () {\n            self.xPPS = -((self.touchDelta.x - self.touchSigma.x) / (self.touchDelta.t - self.touchSigma.t));\n            self.yPPS = -((self.touchDelta.y - self.touchSigma.y) / (self.touchDelta.t - self.touchSigma.t));\n            self.touchSigma = {\n                x: self.touchDelta.x,\n                y: self.touchDelta.y,\n                t: performance.now()\n            };\n        };\n        self.touchEndAnimation = function () {\n            if (!self.canvas || !self.scrollBox.scrollTo) { return requestAnimationFrame(self.touchEndAnimation); }\n            var n = performance.now(),\n                d = self.attributes.touchReleaseAnimationDurationMs,\n                t;\n            t = n - self.touchDelta.t;\n            self.animationFrames += 1;\n            self.scrollAnimation.x = self.easing(t, self.touchDelta.scrollLeft, self.touchAnimateTo.x, d);\n            self.scrollAnimation.y = self.easing(t, self.touchDelta.scrollTop, self.touchAnimateTo.y, d);\n            if (t > d || (self.scrollAnimation.y === self.scrollBox.scrollTop\n                    && self.scrollAnimation.x === self.scrollBox.scrollLeft) || self.stopAnimation) {\n                return;\n            }\n            self.scrollBox.scrollTo(self.scrollAnimation.x, self.scrollAnimation.y);\n            requestAnimationFrame(self.touchEndAnimation);\n        };\n        self.touchEditCell = function (cell) {\n            self.beginEditAt(cell.columnIndex, cell.rowIndex);\n        };\n        self.touchCell = function (e) {\n            return function () {\n                clearInterval(self.calculatePPSTimer);\n                var i, pos = self.getTouchPos(e);\n                if (Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) < self.attributes.touchDeadZone) {\n                    i = self.getCellAt(pos.x, pos.y);\n                    if (!i) { return; }\n                    if (self.touchingCell && self.touchingCell.rowIndex === i.rowIndex\n                            && self.touchingCell.columnIndex === i.columnIndex) {\n                        self.touchEditCell(i);\n                        return;\n                    }\n                    if (self.input && self.input.editCell) {\n                        self.endEdit();\n                    }\n                    self.touchingCell = i;\n                    self.selectArea({\n                        top: i.rowIndex,\n                        bottom: i.rowIndex,\n                        left: i.columnIndex,\n                        right: i.columnIndex\n                    });\n                    self.draw(true);\n                }\n            };\n        };\n        self.touchstart = function (e) {\n            if (e.changedTouches[0]) {\n                self.touchStart = self.getTouchPos(e);\n                self.startingCell = self.getCellAt(self.touchStart.x, self.touchStart.y, true);\n            }\n            if (self.dispatchEvent('touchstart', {NativeEvent: e, cell: self.startingCell})) { return; }\n            self.disposeContextMenu();\n            clearInterval(self.calculatePPSTimer);\n            clearTimeout(self.touchContextTimeout);\n            self.touchStartEvent = e;\n            self.stopAnimation = true;\n            self.animationFrames = 0;\n            self.stopPropagation(e);\n            e.preventDefault();\n            if (e.touches.length === 1 && e.changedTouches[0] && !self.zoomAltered) {\n                self.touchLength = 1;\n                self.touchStart = self.touchStart || self.touchStart1;\n                self.touchScrollStart = {\n                    x: self.scrollBox.scrollLeft,\n                    y: self.scrollBox.scrollTop,\n                    t: performance.now()\n                };\n                self.touchDelta = {\n                    x: 0,\n                    y: 0,\n                    scrollLeft: self.scrollBox.scrollLeft,\n                    scrollTop: self.scrollBox.scrollTop,\n                    t: self.touchScrollStart.t\n                };\n                self.touchSigma = {\n                    x: self.touchDelta.x,\n                    y: self.touchDelta.y,\n                    t: self.touchDelta.t\n                };\n                self.touchSigmaTimed = {\n                    x: self.touchDelta.x,\n                    y: self.touchDelta.y,\n                    t: self.touchDelta.t\n                };\n                self.touchContextTimeout = setTimeout(function () {\n                    self.contextmenuEvent(e, self.touchStart);\n                }, self.attributes.touchContextMenuTimeMs);\n                self.calculatePPSTimer = setInterval(self.calculatePPSTimed, touchTimerMs);\n                if (self.startingCell && (self.startingCell.isGrid || ['tree', 'inherit'].indexOf(self.startingCell.context) !== -1)) {\n                    self.hasFocus = false;\n                    return;\n                }\n                self.hasFocus = true;\n                if (self.startingCell.isHeader) {\n                    if (self.startingCell.isRowHeader) {\n                        self.selectArea({\n                            top: self.startingCell.rowIndex,\n                            bottom: self.startingCell.rowIndex,\n                            left: 0,\n                            right: self.getVisibleSchema().length - 1,\n                        });\n                        self.draw(true);\n                    } else if (self.startingCell.isColumnHeader) {\n                        if (self.attributes.columnHeaderClickBehavior === 'sort') {\n                            if (self.orderBy === self.startingCell.header.name) {\n                                self.orderDirection = self.orderDirection === 'asc' ? 'desc' : 'asc';\n                            } else {\n                                self.orderDirection = 'asc';\n                            }\n                            self.order(self.startingCell.header.name, self.orderDirection);\n                        }\n                        if (self.attributes.columnHeaderClickBehavior === 'select') {\n                            self.selectArea({\n                                top: 0,\n                                bottom: self.data.length - 1,\n                                left: self.startingCell.columnIndex,\n                                right: self.startingCell.columnIndex,\n                            });\n                            self.draw(true);\n                        }\n                    }\n                    self.touchEndEvents(e);\n                    return;\n                }\n            }\n            if (self.zoomAltered) { return; }\n            document.body.addEventListener('touchmove', self.touchmove, {passive: false});\n            document.body.addEventListener('touchend', self.touchend, false);\n            document.body.addEventListener('touchcancel', self.touchcancel, false);\n            self.draw(true);\n        };\n        self.touchSelect = function (cell, handleType) {\n            if (cell.rowIndex === undefined || cell.columnIndex === undefined) { return; }\n            self.touchSelecting = true;\n            var bounds = self.getSelectionBounds();\n            if (handleType === 'selection-handle-bl'\n                    && cell.rowIndex >= bounds.top\n                    && cell.columnIndex <= bounds.right) {\n                bounds.bottom = cell.rowIndex;\n                bounds.left = cell.columnIndex;\n            } else if (handleType === 'selection-handle-tl'\n                    && cell.rowIndex <= bounds.bottom\n                    && cell.columnIndex <= bounds.right) {\n                bounds.top = cell.rowIndex;\n                bounds.left = cell.columnIndex;\n            } else if (handleType === 'selection-handle-tr'\n                    && cell.rowIndex <= bounds.bottom\n                    && cell.columnIndex >= bounds.left) {\n                bounds.top = cell.rowIndex;\n                bounds.right = cell.columnIndex;\n            } else if (handleType === 'selection-handle-br'\n                    && cell.rowIndex >= bounds.top\n                    && cell.columnIndex >= bounds.left) {\n                bounds.bottom = cell.rowIndex;\n                bounds.right = cell.columnIndex;\n            }\n            if (self.attributes.selectionMode === 'row' || cell.rowIndex === -1) {\n                bounds.left = 0;\n                bounds.right = self.getSchema().length - 1;\n            } else {\n                bounds.left = Math.max(0, bounds.left);\n            }\n            self.selectArea(bounds);\n            self.draw(true);\n        };\n        self.touchmove = function (e) {\n            var ch, rw, rScrollZone, lScrollZone, bScrollZone, tScrollZone, sbw, t1, t2;\n            if (self.dispatchEvent('beforetouchmove', {NativeEvent: e})) { return; }\n            clearTimeout(touchScrollTimeout);\n            if (e.changedTouches[0]) {\n                self.touchPosition = self.getTouchPos(e);\n            }\n            if (e.changedTouches[1]) {\n                self.touchPosition1 = self.getTouchPos(e, 1);\n            }\n            if (Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) > self.attributes.touchDeadZone) {\n                clearTimeout(self.touchContextTimeout);\n            }\n            if (e.touches.length === 2 && self.touchPosition && self.touchPosition1) {\n                t1 = self.touchPosition.y;\n                t2 = self.touchPosition1.y;\n                if (!self.zoomDeltaStart) {\n                    self.zoomDeltaStart = Math.abs(t1 - t2);\n                    self.startScale = self.scale;\n                }\n                self.touchLength = 2;\n                self.scaleDelta = self.zoomDeltaStart - Math.abs(t1 - t2);\n                self.scale = self.startScale - (self.scaleDelta * self.attributes.touchZoomSensitivity);\n                self.scale = Math.min(Math.max(self.scale, self.attributes.touchZoomMin), self.attributes.touchZoomMax);\n                self.zoomAltered = true;\n                self.resize(true);\n                self.resizeChildGrids();\n                return;\n            }\n            if (self.zoomAltered) { return; }\n            self.touchLength = 1;\n            self.touchPosition = self.touchPosition || self.touchPosition1;\n            ch = self.getColumnHeaderCellHeight();\n            rw = self.getRowHeaderCellWidth();\n            rScrollZone = self.width - self.style.scrollBarWidth - self.touchPosition.x < self.attributes.selectionScrollZone;\n            lScrollZone = self.touchPosition.x - rw < self.attributes.selectionScrollZone;\n            bScrollZone = self.height - self.style.scrollBarWidth - self.touchPosition.y < self.attributes.selectionScrollZone;\n            tScrollZone = self.touchPosition.y - ch < self.attributes.selectionScrollZone;\n            sbw = self.style.scrollBarWidth;\n            function touchScroll() {\n                var x = self.scrollBox.scrollLeft,\n                    y = self.scrollBox.scrollTop;\n                x += (rScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                y += (bScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                y -= (tScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                x -= (lScrollZone ? self.attributes.selectionScrollIncrement : 0);\n                self.scrollBox.scrollTo(x, y);\n                touchScrollTimeout = setTimeout(touchScroll, self.attributes.scrollRepeatRate);\n            }\n            e.stopPropagation();\n            self.touchDelta = {\n                x: self.touchPosition.x - self.touchStart.x,\n                y: self.touchPosition.y - self.touchStart.y,\n                scrollLeft: self.scrollBox.scrollLeft,\n                scrollTop: self.scrollBox.scrollTop,\n                t: performance.now()\n            };\n            self.currentCell = self.getCellAt(self.touchPosition.x, self.touchPosition.y);\n            self.dispatchEvent('touchmove', {NativeEvent: e, cell: self.currentCell});\n            self.calculatePPS();\n            self.touchDuration = performance.now() - self.touchScrollStart.t;\n            self.stopAnimation = true;\n            self.animationFrames = 0;\n            if (self.touchSelecting && (rScrollZone || lScrollZone || tScrollZone || bScrollZone)) {\n                touchScroll();\n            }\n            if (/vertical-scroll-/.test(self.startingCell.style)) {\n                self.scrollBox.scrollTop = self.scrollBox.scrollHeight\n                    * ((self.touchPosition.y - ch - sbw) / (self.scrollBox.height - sbw - ch));\n                return;\n            }\n            if (/horizontal-scroll-/.test(self.startingCell.style)) {\n                self.scrollBox.scrollLeft = self.scrollBox.scrollWidth\n                    * ((self.touchPosition.x - rw - sbw) / (self.scrollBox.width - sbw - rw));\n                return;\n            }\n            if (/selection-handle-/.test(self.startingCell.style)) {\n                self.touchSelect(self.currentCell, self.startingCell.style);\n                return;\n            }\n            self.scrollBox.scrollTo(self.touchScrollStart.x - self.touchDelta.x,\n                self.touchScrollStart.y - self.touchDelta.y);\n            self.draw(true);\n        };\n        self.touchEndEvents = function (e) {\n            self.zoomDeltaStart = undefined;\n            self.touchSelecting = false;\n            clearInterval(self.touchScrollTimeout);\n            clearInterval(self.touchContextTimeout);\n            clearInterval(self.calculatePPSTimer);\n            e.stopPropagation();\n            document.body.removeEventListener('touchmove', self.touchmove, {passive: false});\n            document.body.removeEventListener('touchend', self.touchend, false);\n            document.body.removeEventListener('touchcancel', self.touchcancel, false);\n        };\n        self.touchend = function (e) {\n            if (self.dispatchEvent('touchend', {NativeEvent: e, cell: self.currentCell})) { return; }\n            self.zoomDeltaStart = undefined;\n            if (e.changedTouches[0]) {\n                self.touchPosition = undefined;\n            }\n            if (e.changedTouches[1]) {\n                self.touchPosition1 = undefined;\n            }\n            if (self.zoomAltered) {\n                if (e.touches.length === 0) {\n                    self.zoomAltered = false;\n                }\n                return;\n            }\n            var dz = Math.abs(self.touchDelta.x) + Math.abs(self.touchDelta.y) < self.attributes.touchDeadZone;\n            if (isNaN(self.xPPS)) {\n                self.xPPS = 0;\n            }\n            if (isNaN(self.yPPS)) {\n                self.yPPS = 0;\n            }\n            if (isNaN(self.xPPST)) {\n                self.xPPST = 0;\n            }\n            if (isNaN(self.yPPST)) {\n                self.yPPST = 0;\n            }\n            self.touchAnimateTo.x = self.xPPS * self.attributes.touchReleaseAcceleration;\n            self.touchAnimateTo.y = self.yPPS * self.attributes.touchReleaseAcceleration;\n            self.calculatePPSTimed();\n            if (dz && !self.contextMenu) {\n                self.touchCell(self.touchStartEvent)();\n            } else if (self.animationFrames === 0\n                    && (Math.abs(self.xPPST) > self.attributes.scrollAnimationPPSThreshold\n                        || Math.abs(self.yPPST) > self.attributes.scrollAnimationPPSThreshold)\n                    && !/-scroll-/.test(self.startingCell.style)\n                    && !dz) {\n                self.stopAnimation = false;\n                self.touchEndAnimation();\n            }\n            self.touchEndEvents(e);\n        };\n        self.touchcancel = function (e) {\n            if (self.dispatchEvent('touchcancel', {NativeEvent: e, cell: self.currentCell})) { return; }\n            self.touchEndEvents(e);\n        };\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/touch.js\n// module id = 5\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals HTMLElement: false, Reflect: false, define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self, ctor) {\n        self.scale = 1;\n        self.orders = {\n            rows: [],\n            columns: []\n        };\n        self.visibleRowHeights = [];\n        self.hasFocus = false;\n        self.activeCell = {\n            columnIndex: 0,\n            rowIndex: 0\n        };\n        self.storageName = 'canvasDataGrid';\n        self.invalidSearchExpClass = 'canvas-datagrid-invalid-search-regExp';\n        self.localStyleLibraryStorageKey = 'canvas-datagrid-user-style-library';\n        self.uniqueId = '_canvasDataGridUniqueId';\n        self.orderBy = self.uniqueId;\n        self.orderDirection = 'asc';\n        self.columnFilters = {};\n        self.filters = {};\n        self.frozenRow = 0;\n        self.frozenColumn = 0;\n        self.ellipsisCache = {};\n        self.scrollBox = {};\n        self.visibleRows = [];\n        self.sizes = {\n            rows: {},\n            columns: {},\n            trees: {}\n        };\n        self.currentFilter = function () {\n            return true;\n        };\n        self.selections = [];\n        self.hovers = {};\n        self.attributes = {};\n        self.style = {};\n        self.formatters = {};\n        self.sorters = {};\n        self.schemaHashes = {};\n        self.events = {};\n        self.uId = 0;\n        self.changes = [];\n        self.scrollIndexTop = 0;\n        self.scrollPixelTop = 0;\n        self.scrollIndexLeft = 0;\n        self.scrollPixelLeft = 0;\n        self.childGrids = {};\n        self.openChildren = {};\n        self.scrollModes = [\n            'vertical-scroll-box',\n            'vertical-scroll-top',\n            'vertical-scroll-bottom',\n            'horizontal-scroll-box',\n            'horizontal-scroll-right',\n            'horizontal-scroll-left'\n        ];\n        self.componentL1Events = {};\n        self.eventNames = ['afterdraw', 'afterrendercell', 'attributechanged', 'beforebeginedit',\n            'beforecreatecellgrid', 'beforedraw', 'beforeendedit', 'beforerendercell', 'beforerendercellgrid',\n            'beginedit', 'cellmouseout', 'cellmouseover', 'click', 'collapsetree', 'contextmenu', 'copy',\n            'datachanged', 'dblclick', 'endedit', 'expandtree', 'formatcellvalue', 'keydown', 'keypress',\n            'keyup', 'mousedown', 'mousemove', 'mouseup', 'newrow', 'ordercolumn', 'rendercell', 'rendercellgrid',\n            'renderorderbyarrow', 'rendertext', 'rendertreearrow', 'reorder', 'reordering', 'resize',\n            'resizecolumn', 'resizerow', 'schemachanged', 'scroll', 'selectionchanged', 'stylechanged',\n            'touchcancel', 'touchend', 'touchmove', 'touchstart', 'wheel'];\n        self.mouse = { x: 0, y: 0};\n        self.getSelectedData = function (expandToRow) {\n            var d = [], s = expandToRow ? self.getSchema() : self.getVisibleSchema(), l = self.data.length;\n            if (l === 0) { return []; }\n            self.selections.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) {\n                    d[index] = null;\n                    return;\n                }\n                d[index] = {};\n                row.forEach(function (col) {\n                    if (col === -1 || !s[col]) { return; }\n                    d[index][s[col].name] = self.data[index][s[col].name];\n                });\n            });\n            return d;\n        };\n        self.fillArray = function (low, high, step, def) {\n            step = step || 1;\n            var i = [], x;\n            for (x = low; x <= high; x += step) {\n                i[x] = def === undefined ? x : (typeof def === 'function' ? def(x) : def);\n            }\n            return i;\n        };\n        self.getColumnHeaderCellHeight = function () {\n            if (!self.attributes.showColumnHeaders) { return 0; }\n            return ((self.sizes.rows[-1] || self.style.columnHeaderCellHeight) * self.scale);\n        };\n        self.getRowHeaderCellWidth = function () {\n            if (!self.attributes.showRowHeaders) { return 0; }\n            return (self.sizes.columns.cornerCell || self.style.rowHeaderCellWidth) * self.scale;\n        };\n        self.setStorageData = function () {\n            if (!self.attributes.saveAppearance || !self.attributes.name) { return; }\n            var visibility = {};\n            self.getSchema().forEach(function (column) {\n                visibility[column.name] = !column.hidden;\n            });\n            localStorage.setItem(self.storageName + '-' + self.attributes.name, JSON.stringify({\n                sizes: {\n                    rows: self.sizes.rows,\n                    columns: self.sizes.columns\n                },\n                orders: {\n                    rows: self.orders.rows,\n                    columns: self.orders.columns\n                },\n                orderBy: self.orderBy,\n                orderDirection: self.orderDirection,\n                visibility: visibility\n            }));\n        };\n        self.getSchema = function () {\n            return self.schema || self.tempSchema;\n        };\n        self.createColumnOrders = function () {\n            var s = self.getSchema();\n            self.orders.columns = self.fillArray(0, s.length - 1);\n        };\n        self.createRowOrders = function () {\n            self.orders.rows = self.fillArray(0, self.data.length - 1);\n        };\n        self.getVisibleSchema = function () {\n            return self.getSchema().filter(function (col) {\n                return !col.hidden && col.name !== self.uniqueId;\n            });\n        };\n        self.applyDefaultValue = function (row, header) {\n            var d = header.defaultValue || '';\n            if (typeof d === 'function') {\n                d = d.apply(self.intf, [header]);\n            }\n            row[header.name] = d;\n        };\n        self.createNewRowData = function () {\n            self.newRow = {};\n            self.newRow[self.uniqueId] = self.uId;\n            self.uId += 1;\n            self.getSchema().forEach(function forEachHeader(header) {\n                self.applyDefaultValue(self.newRow, header);\n            });\n        };\n        self.getSchemaNameHash = function (key) {\n            var n = 0;\n            while (self.schemaHashes[key]) {\n                n += 1;\n                key = key + n;\n            }\n            return key;\n        };\n        self.filter = function (type) {\n            var f = self.filters[type];\n            if (!f && type !== undefined) {\n                console.warn('Cannot find filter for type %s, falling back to substring match.', type);\n                f = self.filters.string;\n            }\n            return f;\n        };\n        self.getBestGuessDataType = function (columnName) {\n            var t, x, l = self.data.length;\n            for (x = 0; x < l; x += 1) {\n                if ([null, undefined].indexOf(self.data[x][columnName]) !== -1) {\n                    t = typeof self.data[x];\n                    return t === 'object' ? 'string' : t;\n                }\n            }\n            return 'string';\n        };\n        self.drawChildGrids = function () {\n            Object.keys(self.childGrids).forEach(function (gridKey) {\n                self.childGrids[gridKey].draw();\n            });\n        };\n        self.resizeChildGrids = function () {\n            Object.keys(self.childGrids).forEach(function (gridKey) {\n                self.childGrids[gridKey].resize();\n            });\n        };\n        self.autoScrollZone = function (e, x, y, ctrl) {\n            var setTimer,\n                rowHeaderCellWidth = self.getRowHeaderCellWidth(),\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight();\n            if (x > self.width - self.attributes.selectionScrollZone && x < self.width) {\n                self.scrollBox.scrollLeft += self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (y > self.height - self.attributes.selectionScrollZone && y < self.height) {\n                self.scrollBox.scrollTop += self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (x - self.attributes.selectionScrollZone - rowHeaderCellWidth < 0) {\n                self.scrollBox.scrollLeft -= self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (y - self.attributes.selectionScrollZone - columnHeaderCellHeight < 0) {\n                self.scrollBox.scrollTop -= self.attributes.selectionScrollIncrement;\n                setTimer = true;\n            }\n            if (setTimer && !ctrl && self.currentCell && self.currentCell.columnIndex !== -1) {\n                self.scrollTimer = setTimeout(self.mousemove, self.attributes.scrollRepeatRate, e);\n            }\n        };\n        self.refreshFromOrigialData = function () {\n            self.data = self.originalData.filter(function (row) {\n                return true;\n            });\n        };\n        self.validateColumn = function (c, s) {\n            if (!c.name) {\n                throw new Error('A column must contain at least a name.');\n            }\n            if (s.filter(function (i) { return i.name === c.name; }).length > 0) {\n                throw new Error('A column with the name '\n                    + c.name + ' already exists and cannot be added again.');\n            }\n            return true;\n        };\n        self.setDefaults = function (obj1, obj2, key, def) {\n            obj1[key] = obj2[key] === undefined ? def : obj2[key];\n        };\n        self.setAttributes = function () {\n            self.defaults.attributes.forEach(function eachAttribute(i) {\n                self.setDefaults(self.attributes, self.args, i[0], i[1]);\n            });\n        };\n        self.setStyle = function () {\n            self.defaults.styles.forEach(function eachStyle(i) {\n                self.setDefaults(self.style, self.args.style || {}, i[0], i[1]);\n            });\n        };\n        self.autosize = function (colName) {\n            self.getVisibleSchema().forEach(function (col) {\n                if (col.name === colName || colName === undefined) {\n                    self.fitColumnToValues(col.name);\n                }\n            });\n            self.fitColumnToValues('cornerCell');\n        };\n        self.dispose = function () {\n            if (!self.isChildGrid && self.canvas && self.canvas.parentNode) {\n                self.canvas.parentNode.removeChild(self.canvas);\n            }\n            self.eventParent.removeEventListener('mouseup', self.mouseup, false);\n            self.eventParent.removeEventListener('mousedown', self.mousedown, false);\n            self.eventParent.removeEventListener('dblclick', self.dblclick, false);\n            self.eventParent.removeEventListener('click', self.click, false);\n            self.eventParent.removeEventListener('mousemove', self.mousemove);\n            self.eventParent.removeEventListener('wheel', self.scrollWheel, false);\n            self.canvas.removeEventListener('contextmenu', self.contextmenu, false);\n            self.canvas.removeEventListener('copy', self.copy);\n            self.controlInput.removeEventListener('keypress', self.keypress, false);\n            self.controlInput.removeEventListener('keyup', self.keyup, false);\n            self.controlInput.removeEventListener('keydown', self.keydown, false);\n            window.removeEventListener('resize', self.resize);\n            if (self.observer && self.observer.disconnect) {\n                self.observer.disconnect();\n            }\n        };\n        self.tryLoadStoredOrders = function () {\n            var s;\n            if (self.storedSettings\n                    && typeof self.storedSettings.orders === 'object'\n                    && self.storedSettings.orders !== null) {\n                if (self.storedSettings.orders.rows.length >= self.data.length) {\n                    self.orders.rows = self.storedSettings.orders.rows;\n                }\n                s = self.getSchema();\n                if (self.storedSettings.orders.columns.length === s.length) {\n                    self.orders.columns = self.storedSettings.orders.columns;\n                }\n                self.orderBy = self.storedSettings.orderBy === undefined\n                    ? self.uniqueId : self.storedSettings.orderBy;\n                self.orderDirection = self.storedSettings.orderDirection === undefined\n                    ? self.uniqueId : self.storedSettings.orderDirection;\n                if (self.orderBy !== self.uniqueId && self.getHeaderByName(self.orderBy) && self.orderDirection) {\n                    self.order(self.orderBy, self.orderDirection);\n                }\n            }\n        };\n        self.getDomRoot = function () {\n            return self.shadowRoot ? self.shadowRoot.host : self.parentNode;\n        };\n        self.getFontName = function (fontStyle) {\n            return fontStyle.replace(/\\d+\\.?\\d*px/, '');\n        };\n        self.getFontHeight = function (fontStyle) {\n            return parseFloat(fontStyle, 10);\n        };\n        self.parseStyleValue = function (key) {\n            if (/Font/.test(key)) {\n                self.style[key + 'Height'] = self.getFontHeight(self.style[key]);\n                self.style[key + 'Name'] = self.getFontName(self.style[key]);\n                return;\n            }\n            // when inheriting styles from already instantiated grids, don't parse already parsed values.\n            if (key === 'moveOverlayBorderSegments' && typeof self.style[key] === 'string') {\n                self.style[key] = self.style[key].split(',')\n                    .map(function (i) { return parseInt(i, 10); });\n            }\n        };\n        self.initProp = function (propName) {\n            if (!self.args[propName]) { return; }\n            Object.keys(self.args[propName]).forEach(function (key) {\n                self[propName][key] = self.args[propName][key];\n            });\n        };\n        self.getStyleProperty = function (key) {\n            if (self.styleKeys.indexOf(key) === -1) {\n                return self.parentNodeStyle[key];\n            }\n            return self.style[key];\n        };\n        self.setStyleProperty = function (key, value, supressDrawAndEvent) {\n            if (self.styleKeys.indexOf(key) === -1) {\n                self.parentNodeStyle[key] = value;\n            } else {\n                self.style[key] = value;\n                self.parseStyleValue(key);\n            }\n            if (!supressDrawAndEvent) {\n                self.draw(true);\n                self.dispatchEvent('stylechanged', {name: 'style', value: value});\n            }\n        };\n        self.reloadStoredValues = function () {\n            if (self.attributes.name && self.attributes.saveAppearance) {\n                self.storedSettings = localStorage.getItem(self.storageName + '-' + self.attributes.name);\n                if (self.storedSettings) {\n                    try {\n                        self.storedSettings = JSON.parse(self.storedSettings);\n                    } catch (e) {\n                        console.warn('could not read settings from localStore', e);\n                        self.storedSettings = undefined;\n                    }\n                }\n                if (self.storedSettings) {\n                    if (typeof self.storedSettings.sizes === 'object'\n                            && self.storedSettings.sizes !== null) {\n                        self.sizes.rows = self.storedSettings.sizes.rows;\n                        self.sizes.columns = self.storedSettings.sizes.columns;\n                        ['trees', 'columns', 'rows'].forEach(function (i) {\n                            if (!self.sizes[i]) {\n                                self.sizes[i] = {};\n                            }\n                        });\n                    }\n                    if (typeof self.storedSettings.visibility === 'object') {\n                        self.getSchema().forEach(function (column) {\n                            if (self.storedSettings.visibility[column.name] !== undefined) {\n                                column.hidden = !self.storedSettings.visibility[column.name];\n                            }\n                        });\n                    }\n                }\n            }\n        };\n        self.init = function () {\n            if (self.initialized) { return; }\n            var publicStyleKeyIntf = {};\n            self.setAttributes();\n            self.setStyle();\n            self.initScrollBox();\n            self.setDom();\n            self.type = 'canvas-datagrid';\n            self.initialized = true;\n            self.ie = /Trident/.test(window.navigator.userAgent);\n            self.edge = /Edge/.test(window.navigator.userAgent);\n            self.webKit = /WebKit/.test(window.navigator.userAgent);\n            self.moz = /Gecko/.test(window.navigator.userAgent);\n            self.webKit = /WebKit/.test(window.navigator.userAgent);\n            self.mobile = /Mobile/i.test(window.navigator.userAgent);\n            self.cursorGrab = 'grab';\n            self.cursorGrabing = 'grabbing';\n            self.cursorGrab = self.webKit ? '-webkit-grab' : self.cursorGrab;\n            self.cursorGrabing = self.moz ? '-webkit-grabbing' : self.cursorGrabbing;\n            self.pointerLockPosition = {x: 0, y: 0};\n            Object.keys(self.style).forEach(self.parseStyleValue);\n            self.intf.moveSelection = self.moveSelection;\n            self.intf.moveTo = self.moveTo;\n            self.intf.type = self.type;\n            self.intf.addEventListener = self.addEventListener;\n            self.intf.removeEventListener = self.removeEventListener;\n            self.intf.dispatchEvent = self.dispatchEvent;\n            /**\n             * Releases grid resources and removes grid elements.\n             * @memberof canvasDatagrid\n             * @name dispose\n             * @method\n             */\n            self.intf.dispose = self.dispose;\n            /**\n             * Appends the grid to another element later.  Not implemented.\n             * @memberof canvasDatagrid\n             * @name appendTo\n             * @method\n             * @param {number} el The element to append the grid to.\n             */\n            self.intf.appendTo = self.appendTo;\n            self.intf.filters = self.filters;\n            self.intf.sorters = self.sorters;\n            self.intf.autosize = self.autosize;\n            self.intf.beginEditAt = self.beginEditAt;\n            self.intf.endEdit = self.endEdit;\n            self.intf.setActiveCell = self.setActiveCell;\n            self.intf.forEachSelectedCell = self.forEachSelectedCell;\n            self.intf.scrollIntoView = self.scrollIntoView;\n            self.intf.clearChangeLog = self.clearChangeLog;\n            self.intf.gotoCell = self.gotoCell;\n            self.intf.gotoRow = self.gotoRow;\n            self.intf.getHeaderByName = self.getHeaderByName;\n            self.intf.findColumnScrollLeft = self.findColumnScrollLeft;\n            self.intf.findRowScrollTop = self.findRowScrollTop;\n            self.intf.fitColumnToValues = self.fitColumnToValues;\n            self.intf.findColumnMaxTextLength = self.findColumnMaxTextLength;\n            self.intf.disposeContextMenu = self.disposeContextMenu;\n            self.intf.getCellAt = self.getCellAt;\n            self.intf.isCellVisible = self.isCellVisible;\n            self.intf.order = self.order;\n            self.intf.draw = self.draw;\n            self.intf.selectArea = self.selectArea;\n            self.intf.clipElement = self.clipElement;\n            self.intf.getSchemaFromData = self.getSchemaFromData;\n            self.intf.setFilter = self.setFilter;\n            self.intf.selectRow = self.selectRow;\n            self.intf.parentGrid = self.parentGrid;\n            self.intf.toggleTree = self.toggleTree;\n            self.intf.expandTree = self.expandTree;\n            self.intf.collapseTree = self.collapseTree;\n            self.intf.canvas = self.canvas;\n            self.intf.context = self.ctx;\n            self.intf.insertRow = self.insertRow;\n            self.intf.deleteRow = self.deleteRow;\n            self.intf.addRow = self.addRow;\n            self.intf.insertColumn = self.insertColumn;\n            self.intf.deleteColumn = self.deleteColumn;\n            self.intf.addColumn = self.addColumn;\n            self.intf.getClippingRect = self.getClippingRect;\n            self.intf.setRowHeight = self.setRowHeight;\n            self.intf.setColumnWidth = self.setColumnWidth;\n            self.intf.resetColumnWidths = self.resetColumnWidths;\n            self.intf.resetRowHeights = self.resetRowHeights;\n            self.intf.resize = self.resize;\n            self.intf.selectColumn = self.selectColumn;\n            self.intf.selectRow = self.selectRow;\n            self.intf.selectAll = self.selectAll;\n            self.intf.selectNone = self.selectNone;\n            self.intf.drawChildGrids = self.drawChildGrids;\n            self.intf.assertPxColor = self.assertPxColor;\n            self.intf.clearPxColorAssertions = self.clearPxColorAssertions;\n            self.intf.integerToAlpha = self.integerToAlpha;\n            self.intf.copy = self.copy;\n            self.intf.setStyleProperty = self.setStyleProperty;\n            Object.defineProperty(self.intf, 'defaults', {\n                get: function () {\n                    return {\n                        styles: self.defaults.styles.reduce(function (a, i) { a[i[0]] = i[1]; return a; }, {}),\n                        attributes: self.defaults.attributes.reduce(function (a, i) { a[i[0]] = i[1]; return a; }, {})\n                    };\n                }\n            });\n            self.styleKeys = Object.keys(self.intf.defaults.styles);\n            self.DOMStyles = window.getComputedStyle(document.body, null);\n            Object.keys(self.DOMStyles).concat(Object.keys(self.style)).forEach(function (key) {\n                // unless this line is here, Object.keys() will not work on <instance>.style\n                publicStyleKeyIntf[key] = undefined;\n                Object.defineProperty(publicStyleKeyIntf, key, {\n                    get: function () {\n                        return self.getStyleProperty(key);\n                    },\n                    set: function (value) {\n                        self.setStyleProperty(key, value);\n                    }\n                });\n            });\n            Object.defineProperty(self.intf, 'shadowRoot', {\n                get: function () {\n                    return self.shadowRoot;\n                }\n            });\n            Object.defineProperty(self.intf, 'activeCell', {\n                get: function () {\n                    return self.activeCell;\n                }\n            });\n            Object.defineProperty(self.intf, 'hasFocus', {\n                get: function () {\n                    return self.hasFocus;\n                }\n            });\n            Object.defineProperty(self.intf, 'style', {\n                get: function () {\n                    return publicStyleKeyIntf;\n                },\n                set: function (valueObject) {\n                    Object.keys(valueObject).forEach(function (key) {\n                        self.setStyleProperty(key, valueObject[key], true);\n                    });\n                    self.draw(true);\n                    self.dispatchEvent('stylechanged', {name: 'style', value: valueObject});\n                }\n            });\n            Object.defineProperty(self.intf, 'attributes', { value: {}});\n            Object.keys(self.attributes).forEach(function (key) {\n                Object.defineProperty(self.intf.attributes, key, {\n                    get: function () {\n                        return self.attributes[key];\n                    },\n                    set: function (value) {\n                        self.attributes[key] = value;\n                        if (key === 'name') {\n                            self.reloadStoredValues();\n                            self.tryLoadStoredOrders();\n                        }\n                        self.draw(true);\n                        self.dispatchEvent('attributechanged', {name: key, value: value[key]});\n                    }\n                });\n            });\n            self.filters.string = function (value, filterFor) {\n                value = String(value);\n                var filterRegExp,\n                    regEnd = /\\/(i|g|m)*$/,\n                    pattern = regEnd.exec(filterFor),\n                    flags = pattern ? pattern[0].substring(1) : '',\n                    flagLength = flags.length;\n                self.invalidFilterRegEx = undefined;\n                if (filterFor.substring(0, 1) === '/' && pattern) {\n                    try {\n                        filterRegExp = new RegExp(filterFor.substring(1, filterFor.length - (flagLength + 1)), flags);\n                    } catch (e) {\n                        self.invalidFilterRegEx = e;\n                        return;\n                    }\n                    return filterRegExp.test(value);\n                }\n                return value.toString ? value.toString().toLocaleUpperCase()\n                    .indexOf(filterFor.toLocaleUpperCase()) !== -1 : false;\n            };\n            self.filters.number = function (value, filterFor) {\n                if (!filterFor) { return true; }\n                return value === filterFor;\n            };\n            ['formatters', 'filters', 'sorters'].forEach(self.initProp);\n            self.reloadStoredValues();\n            if (self.args.data) {\n                self.intf.data = self.args.data;\n            }\n            if (!self.data) {\n                self.intf.data = [];\n            }\n            if (self.args.schema) {\n                self.intf.schema = self.args.schema;\n            }\n            if (self.isChildGrid) {\n                requestAnimationFrame(function () { self.resize(true); });\n            } else {\n                self.resize(true);\n            }\n            return self;\n        };\n        /**\n         * Removes focus from the grid.\n         * @memberof canvasDatagrid\n         * @name blur\n         * @method\n         */\n        self.intf.blur = function (e) {\n            self.hasFocus = false;\n        };\n        /**\n         * Focuses on the grid.\n         * @memberof canvasDatagrid\n         * @name focus\n         * @method\n         */\n        self.intf.focus = function () {\n            self.hasFocus = true;\n            self.controlInput.focus();\n        };\n        if (self.shadowRoot || self.isChildGrid) {\n            Object.defineProperty(self.intf, 'height', {\n                get: function () {\n                    if (self.shadowRoot) {\n                        return self.shadowRoot.height;\n                    }\n                    return self.parentNode.height;\n                },\n                set: function (value) {\n                    if (self.shadowRoot) {\n                        self.shadowRoot.height = value;\n                    } else {\n                        self.parentNode.height = value;\n                    }\n                    self.resize(true);\n                }\n            });\n            Object.defineProperty(self.intf, 'width', {\n                get: function () {\n                    if (self.shadowRoot) {\n                        return self.shadowRoot.width;\n                    }\n                    return self.parentNode.width;\n                },\n                set: function (value) {\n                    if (self.shadowRoot) {\n                        self.shadowRoot.width = value;\n                    } else {\n                        self.parentNode.width = value;\n                    }\n                    self.resize(true);\n                }\n            });\n            Object.defineProperty(self.intf, 'parentNode', {\n                get: function () {\n                    return self.parentNode;\n                },\n                set: function (value) {\n                    if (!self.isChildGrid) {\n                        throw new TypeError('Cannot set property parentNode which has only a getter');\n                    }\n                    self.parentNode = value;\n                }\n            });\n        }\n        Object.defineProperty(self.intf, 'visibleRowHeights', {\n            get: function () {\n                return self.visibleRowHeights;\n            }\n        });\n        Object.defineProperty(self.intf, 'openChildren', {\n            get: function () {\n                return self.openChildren;\n            }\n        });\n        Object.defineProperty(self.intf, 'childGrids', {\n            get: function () {\n                return Object.keys(self.childGrids).map(function (gridId) {\n                    return self.childGrids[gridId];\n                });\n            }\n        });\n        Object.defineProperty(self.intf, 'isChildGrid', {\n            get: function () {\n                return self.isChildGrid;\n            }\n        });\n        Object.defineProperty(self, 'cursor', {\n            get: function () {\n                return self.parentNodeStyle.cursor;\n            },\n            set: function (value) {\n                if (value === 'cell') { value = 'default'; }\n                if (self.currentCursor !== value) {\n                    self.parentNodeStyle.cursor = value;\n                    self.currentCursor = value;\n                }\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollHeight', {\n            get: function () {\n                return self.scrollBox.scrollHeight;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollWidth', {\n            get: function () {\n                return self.scrollBox.scrollWidth;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollTop', {\n            get: function () {\n                return self.scrollBox.scrollTop;\n            },\n            set: function (value) {\n                self.scrollBox.scrollTop = value;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollLeft', {\n            get: function () {\n                return self.scrollBox.scrollLeft;\n            },\n            set: function (value) {\n                self.scrollBox.scrollLeft = value;\n            }\n        });\n        Object.defineProperty(self.intf, 'sizes', {\n            get: function () {\n                return self.sizes;\n            }\n        });\n        Object.defineProperty(self.intf, 'input', {\n            get: function () {\n                return self.input;\n            }\n        });\n        Object.defineProperty(self.intf, 'controlInput', {\n            get: function () {\n                return self.controlInput;\n            }\n        });\n        Object.defineProperty(self.intf, 'currentCell', {\n            get: function () {\n                return self.currentCell;\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleCells', {\n            get: function () {\n                return self.visibleCells;\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleRows', {\n            get: function () {\n                return self.visibleRows;\n            }\n        });\n        Object.defineProperty(self.intf, 'selections', {\n            get: function () {\n                return self.selections;\n            }\n        });\n        Object.defineProperty(self.intf, 'dragMode', {\n            get: function () {\n                return self.dragMode;\n            }\n        });\n        Object.defineProperty(self.intf, 'changes', {\n            get: function () {\n                return self.changes;\n            }\n        });\n        self.intf.formatters = self.formatters;\n        self.normalizeDataset = function (data, callback) {\n            var i, d, max, syncFnInvoked;\n            if (data === null || data === '' || data === undefined) {\n                return callback([]);\n            }\n            if (typeof data === 'string'\n                    || typeof data === 'number'\n                    || typeof data === 'boolean') {\n                data = [{'0': data}];\n            }\n            if (!Array.isArray(data) && typeof data === 'object') {\n                data = [data];\n            }\n            if ((!Array.isArray(data[0]) && typeof data[0] === 'object' && data[0] !== null)\n                            || (Array.isArray(data) && data.length === 0)) {\n                return callback(data);\n            }\n            if (typeof data === 'function') {\n                i = data.apply(self.intf, [function (d) {\n                    if (syncFnInvoked) {\n                        console.warn('Detected a callback to the data setter function after the same function already returned a value synchronously.');\n                    }\n                    self.normalizeDataset(d, callback);\n                }]);\n                if (i) {\n                    syncFnInvoked = true;\n                    self.normalizeDataset(i, callback);\n                }\n                return;\n            }\n            if (!Array.isArray(data) && typeof data === 'object') {\n                data = [data];\n            }\n            if (Array.isArray(data)) {\n                if (!Array.isArray(data[0])) {\n                    //array of something?  throw it all into 1 row!\n                    data = [data];\n                }\n                // find the longest length\n                max = 0;\n                d = [];\n                data.forEach(function (row) {\n                    max = Math.max(max, row.length);\n                });\n                // map against length indexes\n                data.forEach(function (row, index) {\n                    var x;\n                    d[index] = {};\n                    for (x = 0; x < max; x += 1) {\n                        d[index][x] = row[x];\n                    }\n                });\n                return callback(d);\n            }\n            throw new Error('Unsupported data type.  Must be an array of arrays or an array of objects, function or string.');\n        };\n        self.eventNames.forEach(function (eventName) {\n            Object.defineProperty(self.intf, 'on' + eventName, {\n                get: function () {\n                    return self.componentL1Events[eventName];\n                },\n                set: function (value) {\n                    self.events[eventName] = [];\n                    self.componentL1Events[eventName] = value;\n                    if (!value) { return; }\n                    self.addEventListener(eventName, value);\n                }\n            });\n        });\n        Object.defineProperty(self.intf, 'frozenRow', {\n            get: function () {\n                return self.frozenRow;\n            },\n            set: function (val) {\n                if (isNaN(val)) {\n                    throw new TypeError('Expected value for frozenRow to be a number.');\n                }\n                if (self.visibleRows.length > val) {\n                    throw new RangeError('Cannot set a value larger than the number of visible rows.');\n                }\n                self.frozenRow = val;\n            }\n        });\n        Object.defineProperty(self.intf, 'frozenColumn', {\n            get: function () {\n                return self.frozenColumn;\n            },\n            set: function (val) {\n                if (isNaN(val)) {\n                    throw new TypeError('Expected value for frozenRow to be a number.');\n                }\n                if (self.getVisibleSchema().length > val) {\n                    throw new RangeError('Cannot set a value larger than the number of visible columns.');\n                }\n                self.frozenColumn = val;\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollIndexRect', {\n            get: function () {\n                return {\n                    top: self.scrollIndexTop,\n                    right: self.scrollIndexRight,\n                    bottom: self.scrollIndexBottom,\n                    left: self.scrollIndexLeft\n                };\n            }\n        });\n        Object.defineProperty(self.intf, 'scrollPixelRect', {\n            get: function () {\n                return {\n                    top: self.scrollPixelTop,\n                    right: self.scrollPixelRight,\n                    bottom: self.scrollPixelBottom,\n                    left: self.scrollPixelLeft\n                };\n            }\n        });\n        Object.defineProperty(self.intf, 'selectionBounds', {\n            get: function () {\n                return self.getSelectionBounds();\n            }\n        });\n        Object.defineProperty(self.intf, 'selectedRows', {\n            get: function () {\n                return self.getSelectedData(true);\n            }\n        });\n        Object.defineProperty(self.intf, 'selectedCells', {\n            get: function () {\n                return self.getSelectedData();\n            }\n        });\n        Object.defineProperty(self.intf, 'visibleSchema', {\n            get: function () {\n                return self.getVisibleSchema().map(function eachDataRow(col) {\n                    return col;\n                });\n            }\n        });\n        Object.defineProperty(self.intf, 'ctx', {\n            get: function () {\n                return self.ctx;\n            }\n        });\n        Object.defineProperty(self.intf, 'schema', {\n            get: function schemaGetter() {\n                return self.getSchema();\n            },\n            set: function schemaSetter(value) {\n                if (!Array.isArray(value) || typeof value[0] !== 'object') {\n                    throw new Error('Schema must be an array of objects.');\n                }\n                if (value[0].name === undefined) {\n                    throw new Error('Expected schema to contain an object with at least a name property.');\n                }\n                self.schema = value.map(function eachSchemaColumn(column, index) {\n                    column.width = column.width || self.style.cellWidth;\n                    column[self.uniqueId] = self.getSchemaNameHash(column.name);\n                    column.filter = column.filter || self.filter(column.type);\n                    column.type = column.type || 'string';\n                    column.index = index;\n                    column.columnIndex = index;\n                    column.rowIndex = -1;\n                    if (self.storedSettings && self.storedSettings.visibility[column.name] !== undefined) {\n                        column.hidden = !self.storedSettings.visibility[column.name];\n                    }\n                    return column;\n                });\n                self.tempSchema = undefined;\n                self.createNewRowData();\n                self.createColumnOrders();\n                self.tryLoadStoredOrders();\n                self.resize(true);\n                self.dispatchEvent('schemachanged', {schema: self.schema});\n            }\n        });\n        Object.defineProperty(self.intf, 'data', {\n            get: function dataGetter() {\n                return self.data.map(function (row) {\n                    delete row[self.uniqueId];\n                    return row;\n                });\n            },\n            set: function dataSetter(value) {\n                self.normalizeDataset(value, function (d) {\n                    self.originalData = d.map(function eachDataRow(row) {\n                        row[self.uniqueId] = self.uId;\n                        self.uId += 1;\n                        return row;\n                    });\n                    self.changes = [];\n                    //TODO apply filter to incoming dataset\n                    self.data = self.originalData;\n                    if (!self.schema) {\n                        self.tempSchema = self.getSchemaFromData();\n                    }\n                    if (!self.schema && self.data.length === 0) {\n                        self.tempSchema = [{name: ''}];\n                        self.tempSchema[0][self.uniqueId] = self.getSchemaNameHash('');\n                    }\n                    if (self.tempSchema && !self.schema) {\n                        self.createColumnOrders();\n                        self.tryLoadStoredOrders();\n                        self.dispatchEvent('schemachanged', {schema: self.tempSchema});\n                    }\n                    self.createNewRowData();\n                    if (self.attributes.autoResizeColumns && self.data.length > 0\n                            && self.storedSettings === undefined) {\n                        self.autosize();\n                    }\n                    self.fitColumnToValues('cornerCell', true);\n                    self.resize(true);\n                    self.createRowOrders();\n                    self.tryLoadStoredOrders();\n                    self.dispatchEvent('datachanged', {data: self.data});\n                });\n            }\n        });\n        self.initScrollBox = function () {\n            var sHeight = 0,\n                sWidth = 0,\n                scrollTop = 0,\n                scrollLeft = 0,\n                scrollHeight = 0,\n                scrollWidth = 0,\n                scrollBoxHeight = 20,\n                scrollBoxWidth = 20;\n            function setScrollTop(value, preventScrollEvent) {\n                if (isNaN(value)) {\n                    throw new Error('ScrollTop value must be a number');\n                }\n                if (value < 0) {\n                    value = 0;\n                }\n                if (value > scrollHeight) {\n                    value = scrollHeight;\n                }\n                if (scrollHeight < 0) {\n                    value = 0;\n                }\n                scrollTop = value;\n                if (!preventScrollEvent) {\n                    self.scroll();\n                }\n            }\n            function setScrollLeft(value, preventScrollEvent) {\n                if (isNaN(value)) {\n                    throw new Error('ScrollLeft value must be a number');\n                }\n                if (value < 0) {\n                    value = 0;\n                }\n                if (value > scrollWidth) {\n                    value = scrollWidth;\n                }\n                if (scrollWidth < 0) {\n                    value = 0;\n                }\n                scrollLeft = value;\n                if (!preventScrollEvent) {\n                    self.scroll();\n                }\n            }\n            self.scrollBox.toString = function () {\n                return '{\"width\": ' + scrollWidth\n                    + ', \"height\": ' + scrollHeight\n                    + ', \"left\": ' + scrollLeft\n                    + ', \"top\": ' + scrollTop + '}';\n            };\n            self.scrollBox.scrollTo = function (x, y, supressDrawEvent) {\n                setScrollLeft(x, true);\n                setScrollTop(y, supressDrawEvent);\n            };\n            Object.defineProperty(self.scrollBox, 'scrollBoxHeight', {\n                get: function () {\n                    return scrollBoxHeight;\n                },\n                set: function (value) {\n                    scrollBoxHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollBoxWidth', {\n                get: function () {\n                    return scrollBoxWidth;\n                },\n                set: function (value) {\n                    scrollBoxWidth = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'height', {\n                get: function () {\n                    return sHeight;\n                },\n                set: function (value) {\n                    if (scrollHeight < value) {\n                        scrollTop = 0;\n                    }\n                    sHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'width', {\n                get: function () {\n                    return sWidth;\n                },\n                set: function (value) {\n                    sWidth = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollTop', {\n                get: function () {\n                    return scrollTop;\n                },\n                set: setScrollTop\n            });\n            Object.defineProperty(self.scrollBox, 'scrollLeft', {\n                get: function () {\n                    return scrollLeft;\n                },\n                set: setScrollLeft\n            });\n            Object.defineProperty(self.scrollBox, 'scrollHeight', {\n                get: function () {\n                    return scrollHeight;\n                },\n                set: function (value) {\n                    if (scrollTop > value) {\n                        scrollTop = Math.max(value, 0);\n                    }\n                    if (scrollHeight < sHeight) {\n                        scrollTop = 0;\n                    }\n                    scrollHeight = value;\n                }\n            });\n            Object.defineProperty(self.scrollBox, 'scrollWidth', {\n                get: function () {\n                    return scrollWidth;\n                },\n                set: function (value) {\n                    if (scrollLeft > value) {\n                        scrollLeft = Math.max(value, 0);\n                    }\n                    scrollWidth = value;\n                }\n            });\n        };\n        return;\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/intf.js\n// module id = 6\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false, Event: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        var zIndexTop, hoverScrollTimeout, autoCompleteContext;\n        function applyContextItemStyle(contextItemContainer) {\n            self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item' + (self.mobile ? '-mobile' : ''));\n            contextItemContainer.addEventListener('mouseover', function () {\n                self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item:hover');\n            });\n            contextItemContainer.addEventListener('mouseout', function () {\n                self.createInlineStyle(contextItemContainer, 'canvas-datagrid-context-menu-item');\n            });\n        }\n        function createContextMenu(ev, pos, items, parentContextMenu) {\n            var container = document.createElement('div'),\n                upArrow = document.createElement('div'),\n                downArrow = document.createElement('div'),\n                children = [],\n                selectedIndex = -1,\n                intf = {},\n                rect;\n            if (!Array.isArray(items)) { throw new Error('createContextMenu expects an array.'); }\n            function createItems() {\n                items.forEach(function (item) {\n                    var contextItemContainer = document.createElement('div'),\n                        childMenuArrow;\n                    function removeChildContext(e) {\n                        if (e.relatedTarget === container\n                                || item.contextMenu.container === e.relatedTarget\n                                || childMenuArrow === e.relatedTarget\n                                || (contextItemContainer === e.relatedTarget)\n                                || item.contextMenu.container.contains(e.relatedTarget)\n                                ) { return; }\n                        item.contextMenu.dispose();\n                        children.splice(children.indexOf(item.contextMenu), 1);\n                        item.contextMenu = undefined;\n                        contextItemContainer.removeEventListener('mouseout', removeChildContext);\n                        container.removeEventListener('mouseout', removeChildContext);\n                        contextItemContainer.setAttribute('contextOpen', '0');\n                        contextItemContainer.setAttribute('opening', '0');\n                    }\n                    function contextAddCallback(items) {\n                        // check yet again if the user hasn't moved off\n                        if (contextItemContainer.getAttribute('opening') !== '1' ||\n                                contextItemContainer.getAttribute('contextOpen') === '1') {\n                            return;\n                        }\n                        var cPos = contextItemContainer.getBoundingClientRect();\n                        cPos = {\n                            left: cPos.left + self.style.childContextMenuMarginLeft + container.offsetWidth,\n                            top: cPos.top + self.style.childContextMenuMarginTop,\n                            bottom: cPos.bottom,\n                            right: cPos.right\n                        };\n                        item.contextMenu = createContextMenu(ev, cPos, items, intf);\n                        contextItemContainer.setAttribute('contextOpen', '1');\n                        contextItemContainer.addEventListener('mouseout', removeChildContext);\n                        container.addEventListener('mouseout', removeChildContext);\n                        children.push(item.contextMenu);\n                    }\n                    function createChildContext() {\n                        var i;\n                        if (contextItemContainer.getAttribute('contextOpen') === '1') {\n                            return;\n                        }\n                        contextItemContainer.setAttribute('opening', '1');\n                        if (typeof item.items === 'function') {\n                            i  = item.items.apply(intf, [function (items) {\n                                contextAddCallback(items);\n                            }]);\n                            if (i !== undefined && Array.isArray(i)) {\n                                contextAddCallback(i);\n                            }\n                            return;\n                        }\n                        contextAddCallback(item.items);\n                    }\n                    function addItem(item) {\n                        function addContent(content) {\n                            if (content === null) { return; }\n                            if (typeof content === 'function') {\n                                return addContent(content(ev));\n                            }\n                            if (typeof content === 'object') {\n                                contextItemContainer.appendChild(content);\n                                return;\n                            }\n                            applyContextItemStyle(contextItemContainer);\n                            contextItemContainer.innerHTML = content;\n                            return;\n                        }\n                        addContent(item.title);\n                        item.contextItemContainer = contextItemContainer;\n                        if ((item.items && item.items.length > 0) || typeof item.items === 'function') {\n                            childMenuArrow = document.createElement('div');\n                            self.createInlineStyle(childMenuArrow, 'canvas-datagrid-context-child-arrow');\n                            childMenuArrow.innerHTML = self.style.childContextMenuArrowHTML;\n                            contextItemContainer.appendChild(childMenuArrow);\n                            contextItemContainer.addEventListener('mouseover', createChildContext);\n                            contextItemContainer.addEventListener('mouseout', function () {\n                                contextItemContainer.setAttribute('opening', '0');\n                            });\n                        }\n                        if (item.click) {\n                            contextItemContainer.addEventListener('click', function (ev) {\n                                item.click.apply(self, [ev]);\n                            });\n                        }\n                    }\n                    addItem(item);\n                    container.appendChild(contextItemContainer);\n                });\n            }\n            function clickIndex(idx) {\n                items[idx].contextItemContainer.dispatchEvent(new Event('click'));\n            }\n            function checkArrowVisibility() {\n                if (container.scrollTop > 0) {\n                    self.parentDOMNode.appendChild(upArrow);\n                } else if (upArrow.parentNode) {\n                    upArrow.parentNode.removeChild(upArrow);\n                }\n                if (container.scrollTop >= container.scrollHeight - container.offsetHeight && downArrow.parentNode) {\n                    downArrow.parentNode.removeChild(downArrow);\n                } else if (container.scrollHeight - container.offsetHeight > 0\n                        && !(container.scrollTop >= container.scrollHeight - container.offsetHeight)) {\n                    self.parentDOMNode.appendChild(downArrow);\n                }\n            }\n            function startHoverScroll(type) {\n                return function t() {\n                    var a = self.attributes.contextHoverScrollAmount;\n                    if (type === 'up' && container.scrollTop === 0) { return; }\n                    if (type === 'down' && container.scrollTop === container.scrollHeight) { return; }\n                    container.scrollTop += (type === 'up' ? -a : a);\n                    hoverScrollTimeout = setTimeout(t, self.attributes.contextHoverScrollRateMs, type);\n                };\n            }\n            function endHoverScroll(type) {\n                return function () {\n                    clearTimeout(hoverScrollTimeout);\n                };\n            }\n            function init() {\n                var loc = {},\n                    s = self.scrollOffset(self.canvas);\n                if (zIndexTop === undefined) {\n                    zIndexTop = self.style.contextMenuZIndex;\n                }\n                createItems();\n                self.createInlineStyle(container, 'canvas-datagrid-context-menu' + (self.mobile ? '-mobile' : ''));\n                loc.x = pos.left - s.left;\n                loc.y = pos.top - s.top;\n                loc.height = 0;\n                zIndexTop += 1;\n                container.style.position = 'absolute';\n                upArrow.style.color = self.style.contextMenuArrowColor;\n                downArrow.style.color = self.style.contextMenuArrowColor;\n                [upArrow, downArrow].forEach(function (el) {\n                    el.style.textAlign = 'center';\n                    el.style.position = 'absolute';\n                    el.style.zIndex = zIndexTop + 1;\n                });\n                container.style.zIndex = zIndexTop;\n                if (parentContextMenu && parentContextMenu.inputDropdown) {\n                    container.style.maxHeight = window.innerHeight - loc.y - self.style.autocompleteBottomMargin + 'px';\n                    container.style.minWidth = pos.width + 'px';\n                    loc.y += pos.height;\n                }\n                if (self.mobile) {\n                    container.style.width = pos.width + 'px';\n                }\n                container.style.left = loc.x + 'px';\n                container.style.top = loc.y + 'px';\n                container.addEventListener('scroll', checkArrowVisibility);\n                container.addEventListener('wheel', function (e) {\n                    if (self.hasFocus) {\n                        container.scrollTop += e.deltaY;\n                        container.scrollLeft += e.deltaX;\n                    }\n                    checkArrowVisibility();\n                });\n                upArrow.innerHTML = self.style.contextMenuArrowUpHTML;\n                downArrow.innerHTML = self.style.contextMenuArrowDownHTML;\n                container.appendChild(upArrow);\n                document.body.appendChild(downArrow);\n                document.body.appendChild(container);\n                rect = container.getBoundingClientRect();\n                // TODO: fix !(parentContextMenu && parentContextMenu.inputDropdown) state (autocomplete)\n                if (rect.bottom > window.innerHeight) {\n                    if (!(parentContextMenu && parentContextMenu.inputDropdown)) {\n                        loc.y -= (rect.bottom + self.style.contextMenuWindowMargin) - window.innerHeight;\n                    }\n                    if (loc.y < 0) { loc.y = 0; }\n                    if (container.offsetHeight > window.innerHeight - self.style.contextMenuWindowMargin) {\n                        container.style.height = window.innerHeight - self.style.contextMenuWindowMargin + 'px';\n                        loc.y -= self.style.contextMenuWindowMargin;\n                    }\n                }\n                if (rect.right > window.innerWidth) {\n                    loc.x -= rect.right - window.innerWidth + self.style.contextMenuWindowMargin;\n                }\n                if (loc.x < 0) { loc.x = 0; }\n                if (loc.y < 0) { loc.y = 0; }\n                container.style.left = loc.x + 'px';\n                container.style.top = loc.y + 'px';\n                rect = container.getBoundingClientRect();\n                upArrow.style.top = rect.top + 'px';\n                downArrow.style.top = rect.top + rect.height - downArrow.offsetHeight + 'px';\n                upArrow.style.left = rect.left + 'px';\n                downArrow.style.left = rect.left + 'px';\n                downArrow.style.width = container.offsetWidth + 'px';\n                upArrow.style.width = container.offsetWidth + 'px';\n                downArrow.addEventListener('mouseover', startHoverScroll('down'));\n                downArrow.addEventListener('mouseout', endHoverScroll('down'));\n                upArrow.addEventListener('mouseover', startHoverScroll('up'));\n                upArrow.addEventListener('mouseout', endHoverScroll('up'));\n                checkArrowVisibility();\n            }\n            intf.parentGrid = self.intf;\n            intf.parentContextMenu = parentContextMenu;\n            intf.container = container;\n            init();\n            intf.clickIndex = clickIndex;\n            intf.rect = rect;\n            intf.items = items;\n            intf.upArrow = upArrow;\n            intf.downArrow = downArrow;\n            intf.dispose = function () {\n                clearTimeout(hoverScrollTimeout);\n                children.forEach(function (c) {\n                    c.dispose();\n                });\n                [downArrow, upArrow, container].forEach(function (el) {\n                    if (el.parentNode) { el.parentNode.removeChild(el); }\n                });\n            };\n            Object.defineProperty(intf, 'selectedIndex', {\n                get: function () {\n                    return selectedIndex;\n                },\n                set: function (value) {\n                    if (typeof value !== 'number' || isNaN(value || !isFinite(value))) {\n                        throw new Error('Context menu selected index must be a sane number.');\n                    }\n                    selectedIndex = value;\n                    if (selectedIndex > items.length - 1) {\n                        selectedIndex = items.length - 1;\n                    }\n                    if (selectedIndex < 0) {\n                        selectedIndex = 0;\n                    }\n                    items.forEach(function (item, index) {\n                        if (index === selectedIndex) {\n                            return self.createInlineStyle(item.contextItemContainer, 'canvas-datagrid-context-menu-item:hover');\n                        }\n                        self.createInlineStyle(item.contextItemContainer, 'canvas-datagrid-context-menu-item');\n                    });\n                }\n            });\n            return intf;\n        }\n        function createFilterContextMenuItems(e) {\n            var filterContainer = document.createElement('div'),\n                filterLabel = document.createElement('div'),\n                filterAutoCompleteButton = document.createElement('button'),\n                filterInput = document.createElement('input'),\n                n = e.cell && e.cell.header ? e.cell.header.title || e.cell.header.name : '',\n                autoCompleteItems,\n                iRect;\n            function checkRegExpErrorState() {\n                filterInput.style.background = self.style.contextFilterInputBackground;\n                filterInput.style.color = self.style.contextFilterInputColor;\n                if (self.invalidFilterRegEx) {\n                    filterInput.style.background = self.style.contextFilterInvalidRegExpBackground;\n                    filterInput.style.color = self.style.contextFilterInvalidRegExpColor;\n                }\n            }\n            function fillAutoComplete() {\n                var count = 0;\n                autoCompleteItems = {};\n                self.data.forEach(function (row) {\n                    var value = row[e.cell.header.name];\n                    if (autoCompleteItems[value] || count > self.attributes.maxAutoCompleteItems) { return; }\n                    count += 1;\n                    autoCompleteItems[value] = {\n                        title: self.formatters[e.cell.header.type || 'string']({ cell: { value: value }}),\n                        click: function (e) {\n                            filterInput.value = value;\n                            e.stopPropagation();\n                            filterInput.dispatchEvent(new Event('keyup'));\n                            self.disposeAutocomplete();\n                            return;\n                        }\n                    };\n                });\n                autoCompleteItems = Object.keys(autoCompleteItems).map(function (key) {\n                    return autoCompleteItems[key];\n                });\n            }\n            function createAutoCompleteContext(ev) {\n                if (ev && [40, 38, 13, 9].indexOf(ev.keyCode) !== -1) { return; }\n                fillAutoComplete();\n                iRect = filterInput.getBoundingClientRect();\n                if (autoCompleteContext) {\n                    autoCompleteContext.dispose();\n                    autoCompleteContext = undefined;\n                }\n                autoCompleteContext = createContextMenu(e, {\n                    left: iRect.left,\n                    top: iRect.top,\n                    right: iRect.right,\n                    bottom: iRect.bottom,\n                    height: iRect.height,\n                    width: iRect.width\n                }, autoCompleteItems, {inputDropdown: true});\n                autoCompleteContext.selectedIndex = 0;\n            }\n            self.createInlineStyle(filterLabel, 'canvas-datagrid-context-menu-label');\n            self.createInlineStyle(filterAutoCompleteButton, 'canvas-datagrid-context-menu-filter-button');\n            self.createInlineStyle(filterInput, 'canvas-datagrid-context-menu-filter-input');\n            checkRegExpErrorState();\n            filterInput.onclick = self.disposeAutocomplete;\n            filterInput.addEventListener('keydown', function (e) {\n                //down\n                if (e.keyCode === 40) {\n                    autoCompleteContext.selectedIndex += 1;\n                }\n                //up\n                if (e.keyCode === 38) {\n                    autoCompleteContext.selectedIndex -= 1;\n                }\n                //enter\n                if (e.keyCode === 13) {\n                    autoCompleteContext.clickIndex(autoCompleteContext.selectedIndex);\n                    self.disposeContextMenu();\n                }\n                //tab\n                if (e.keyCode === 9) {\n                    autoCompleteContext.clickIndex(autoCompleteContext.selectedIndex);\n                    e.preventDefault();\n                }\n                //esc\n                if (e.keyCode === 27) {\n                    self.disposeContextMenu();\n                }\n            });\n            filterInput.addEventListener('keyup', function () {\n                self.setFilter(e.cell.header.name, filterInput.value);\n            });\n            filterInput.addEventListener('keyup', createAutoCompleteContext);\n            ['focus', 'blur', 'keydown', 'keyup', 'change'].forEach(function (en) {\n                filterInput.addEventListener(en, checkRegExpErrorState);\n            });\n            filterInput.value = e.cell.header ? self.columnFilters[e.cell.header.name] || '' : '';\n            filterLabel.innerHTML = self.attributes.filterOptionText.replace(/%s/g, n);\n            filterAutoCompleteButton.onclick = function () {\n                if (autoCompleteContext) {\n                    return self.disposeAutocomplete();\n                }\n                createAutoCompleteContext();\n            };\n            filterAutoCompleteButton.innerHTML = self.style.contextFilterButtonHTML;\n            filterContainer.addEventListener('click', function (e) {\n                return e.stopPropagation();\n            });\n            filterContainer.appendChild(filterLabel);\n            filterContainer.appendChild(filterInput);\n            filterContainer.appendChild(filterAutoCompleteButton);\n            e.items.push({\n                title: filterContainer\n            });\n            if (Object.keys(self.columnFilters).length) {\n                Object.keys(self.columnFilters).forEach(function (cf) {\n                    var h = self.getHeaderByName(cf);\n                    e.items.push({\n                        title: self.attributes.removeFilterOptionText.replace(/%s/g, h.title || h.name),\n                        click: function removeFilterClick(e) {\n                            e.preventDefault();\n                            self.setFilter(cf, '');\n                            self.controlInput.focus();\n                        }\n                    });\n                });\n            }\n        }\n        function addDefaultContextMenuItem(e) {\n            var isNormalCell = !(e.cell.isBackground || e.cell.isHeaderCellCap\n                    || e.cell.isScrollBar || e.cell.isCorner || e.cell.isRowHeader)\n                    && e.cell.header;\n            if (self.attributes.showFilter && isNormalCell) {\n                createFilterContextMenuItems(e);\n            }\n            if (self.attributes.showCopy\n                    && self.selections.reduce(function (p, r) {\n                        return p + r.length;\n                    }, 0) > 0) {\n                e.items.push({\n                    title: self.attributes.copyText,\n                    click: function () {\n                        document.execCommand('copy');\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n            if (self.attributes.showPaste && self.clipBoardData) {\n                e.items.push({\n                    title: self.attributes.pasteText,\n                    click: function () {\n                        self.paste(self.clipBoardData, e.cell.columnIndex, e.cell.rowIndex);\n                        self.draw();\n                    }\n                });\n            }\n            if (self.attributes.showColumnSelector) {\n                e.items.push({\n                    title: self.attributes.columnSelectorText,\n                    items: function () {\n                        var d = [];\n                        self.getSchema().forEach(function (column) {\n                            if (column.name === self.uniqueId) { return; }\n                            function toggleColumnVisibility(e) {\n                                column.hidden = !column.hidden;\n                                e.preventDefault();\n                                self.stopPropagation(e);\n                                self.disposeContextMenu();\n                                self.resize(true);\n                                self.setStorageData();\n                            }\n                            var el = document.createElement('div');\n                            applyContextItemStyle(el);\n                            el.addEventListener('touchstart', toggleColumnVisibility);\n                            el.addEventListener('click', toggleColumnVisibility);\n                            el.innerHTML = (column.hidden ? self.attributes.columnSelectorHiddenText\n                                    : self.attributes.columnSelectorVisibleText)\n                                    + (column.title || column.name);\n                            d.push({\n                                title: el\n                            });\n                        });\n                        return d;\n                    }\n                });\n                if (e.cell && e.cell.header) {\n                    e.items.push({\n                        title: self.attributes.hideColumnText\n                            .replace(/%s/ig, e.cell.header.title || e.cell.header.name),\n                        click: function (ev) {\n                            e.cell.header.hidden = true;\n                            ev.preventDefault();\n                            self.stopPropagation(ev);\n                            self.disposeContextMenu();\n                            self.setStorageData();\n                            setTimeout(function () { self.resize(true); }, 10);\n                        }\n                    });\n                }\n            }\n            if (self.attributes.saveAppearance && self.attributes.showClearSettingsOption\n                    && (Object.keys(self.sizes.rows).length > 0\n                        || Object.keys(self.sizes.columns).length > 0)) {\n                e.items.push({\n                    title: self.attributes.clearSettingsOptionText,\n                    click: function (e) {\n                        e.preventDefault();\n                        self.sizes.rows = {};\n                        self.sizes.columns = {};\n                        self.createRowOrders();\n                        self.createColumnOrders();\n                        self.storedSettings = undefined;\n                        self.dispatchEvent('resizecolumn', {columnWidth: self.style.cellWidth});\n                        self.dispatchEvent('resizerow', {cellHeight: self.style.cellHeight});\n                        self.setStorageData();\n                        self.resize(true);\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n            if (self.attributes.allowSorting && self.attributes.showOrderByOption && isNormalCell) {\n                e.items.push({\n                    title: self.attributes.showOrderByOptionTextAsc.replace('%s', e.cell.header.title || e.cell.header.name),\n                    click: function (ev) {\n                        ev.preventDefault();\n                        self.order(e.cell.header.name, 'asc');\n                        self.controlInput.focus();\n                    }\n                });\n                e.items.push({\n                    title: self.attributes.showOrderByOptionTextDesc.replace('%s', e.cell.header.title || e.cell.header.name),\n                    click: function (ev) {\n                        ev.preventDefault();\n                        self.order(e.cell.header.name, 'desc');\n                        self.disposeContextMenu();\n                        self.controlInput.focus();\n                    }\n                });\n            }\n        }\n        self.disposeAutocomplete = function () {\n            if (autoCompleteContext) {\n                autoCompleteContext.dispose();\n                autoCompleteContext = undefined;\n            }\n        };\n        self.disposeContextMenu = function () {\n            document.removeEventListener('click', self.disposeContextMenu);\n            zIndexTop = self.style.contextMenuZIndex;\n            self.disposeAutocomplete();\n            if (self.contextMenu) {\n                self.contextMenu.dispose();\n            }\n            self.contextMenu = undefined;\n        };\n        self.contextmenuEvent = function (e, overridePos) {\n            if (!self.hasFocus && e.target !== self.canvas) {\n                return;\n            }\n            function createDiposeEvent() {\n                requestAnimationFrame(function () {\n                    document.addEventListener('click', self.disposeContextMenu);\n                    document.removeEventListener('mouseup', createDiposeEvent);\n                });\n            }\n            var contextPosition,\n                items = [],\n                pos = overridePos || self.getLayerPos(e),\n                ev = {\n                    NativeEvent: e,\n                    cell: self.getCellAt(pos.x, pos.y),\n                    items: items\n                };\n            if (!ev.cell.isGrid) {\n                addDefaultContextMenuItem(ev);\n            }\n            if (self.dispatchEvent('contextmenu', ev)) {\n                return;\n            }\n            if (!ev.cell.isGrid) {\n                if (self.contextMenu) {\n                    self.disposeContextMenu();\n                }\n                contextPosition = {\n                    left: pos.x + pos.rect.left\n                        + self.style.contextMenuMarginLeft + self.canvasOffsetLeft,\n                    top: pos.y + pos.rect.top\n                        + self.style.contextMenuMarginTop + self.canvasOffsetTop,\n                    right: ev.cell.width + ev.cell.x + pos.rect.left,\n                    bottom: ev.cell.height + ev.cell.y + pos.rect.top,\n                    height: ev.cell.height,\n                    width: ev.cell.width\n                };\n                if (self.mobile) {\n                    contextPosition.left = self.style.mobileContextMenuMargin + 'px';\n                    contextPosition.width = self.width - (self.style.mobileContextMenuMargin * 2) + 'px';\n                }\n                self.contextMenu = createContextMenu(ev, contextPosition, items);\n                document.addEventListener('mouseup', createDiposeEvent);\n                e.preventDefault();\n            }\n        };\n        return;\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/contextMenu.js\n// module id = 7\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        self.getClippingRect = function (ele) {\n            var boundingRect = self.position(self.parentNode),\n                eleRect = self.position(ele),\n                s = self.scrollOffset(self.canvas),\n                clipRect = {\n                    x: 0,\n                    y: 0,\n                    h: 0,\n                    w: 0\n                },\n                parentRect = {\n                    x: -Infinity,\n                    y: -Infinity,\n                    h: Infinity,\n                    w: Infinity\n                },\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.getRowHeaderCellWidth();\n            boundingRect.top -= s.top;\n            boundingRect.left -= s.left;\n            eleRect.top -= s.top;\n            eleRect.left -= s.left;\n            clipRect.h = boundingRect.top + boundingRect.height - ele.offsetTop - self.style.scrollBarWidth;\n            clipRect.w = boundingRect.left + boundingRect.width - ele.offsetLeft - self.style.scrollBarWidth;\n            clipRect.x = boundingRect.left + (eleRect.left * -1) + rowHeaderCellWidth;\n            clipRect.y = boundingRect.top + (eleRect.top * -1) + columnHeaderCellHeight;\n            return {\n                x: clipRect.x > parentRect.x ? clipRect.x : parentRect.x,\n                y: clipRect.y > parentRect.y ? clipRect.y : parentRect.y,\n                h: clipRect.h < parentRect.h ? clipRect.h : parentRect.h,\n                w: clipRect.w < parentRect.w ? clipRect.w : parentRect.w\n            };\n        };\n        self.clipElement = function (ele) {\n            var clipRect = self.getClippingRect(ele);\n            if (clipRect.w < 0) { clipRect.w = 0; }\n            if (clipRect.h < 0) { clipRect.h = 0; }\n            ele.style.clip = 'rect('\n                + clipRect.y + 'px,'\n                + clipRect.w + 'px,'\n                + clipRect.h + 'px,'\n                + clipRect.x + 'px'\n                + ')';\n            // INFO https://developer.mozilla.org/en-US/docs/Web/CSS/clip\n            // clip has been \"deprecated\" for clipPath.  Of course nothing but chrome\n            // supports clip path, so we'll keep using clip until someday clipPath becomes\n            // more widely support.  The code below works correctly, but setting clipPath and clip\n            // at the same time has undesirable results.\n            // ele.style.clipPath = 'polygon('\n            //     + clipRect.x + 'px ' + clipRect.y + 'px,'\n            //     + clipRect.x + 'px ' + clipRect.h + 'px,'\n            //     + clipRect.w + 'px ' + clipRect.h + 'px,'\n            //     + clipRect.w + 'px ' + clipRect.y + 'px'\n            //     + ')';\n        };\n        self.scrollOffset = function (e) {\n            var x = 0, y = 0;\n            while (e.parentNode && e.nodeName !== 'CANVAS-DATAGRID' && e !== self.intf) {\n                if (e.nodeType !== 'canvas-datagrid-tree'\n                        && e.nodeType !== 'canvas-datagrid-cell') {\n                    x -= e.scrollLeft;\n                    y -= e.scrollTop;\n                }\n                e = e.parentNode;\n            }\n            return {\n                left: x - document.scrollingElement.scrollLeft,\n                top: y - document.scrollingElement.scrollTop\n            };\n        };\n        self.resizeEditInput = function () {\n            if (self.input && self.input.editCell) {\n                var pos = self.canvas.getBoundingClientRect(),\n                    s = self.scrollOffset(self.intf),\n                    bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                    borderWidth = (self.style.cellBorderWidth * bm),\n                    cell = self.getVisibleCellByIndex(self.input.editCell.columnIndex, self.input.editCell.rowIndex)\n                        || {x: -100, y: -100, height: 0, width: 0};\n                if (self.mobile) {\n                    self.input.style.left = '0';\n                    self.input.style.top = (self.height - self.style.mobileEditInputHeight) - borderWidth - 1 + 'px';\n                    self.input.style.height = self.style.mobileEditInputHeight + 'px';\n                    self.input.style.width = self.width - borderWidth - 1 + 'px';\n                    return;\n                }\n                self.input.style.left = pos.left + cell.x + self.canvasOffsetLeft - s.left + 'px';\n                self.input.style.top = pos.top + cell.y - self.style.cellBorderWidth + self.canvasOffsetTop - s.top + 'px';\n                self.input.style.height = cell.height - borderWidth + 'px';\n                self.input.style.width = cell.width - self.style.cellPaddingLeft + 'px';\n                self.clipElement(self.input);\n            }\n        };\n        self.position = function (e, ignoreScrollOffset) {\n            var x = 0, y = 0, s = e, h, w;\n            while (e.offsetParent && e.nodeName !== 'CANVAS-DATAGRID') {\n                x += e.offsetLeft;\n                y += e.offsetTop;\n                h = e.offsetHeight;\n                w = e.offsetWidth;\n                e = e.offsetParent;\n            }\n            if (ignoreScrollOffset) {\n                return {left: x, top: y, height: h, width: w};\n            }\n            e = s;\n            s = self.scrollOffset(e);\n            return { left: x + s.left, top: y + s.top, height: h, width: w };\n        };\n        self.getLayerPos = function (e) {\n            var rect = self.canvas.getBoundingClientRect(),\n                pos = {\n                    x: e.clientX - rect.left,\n                    y: e.clientY - rect.top\n                };\n            if (self.isChildGrid) {\n                pos.x -= self.canvasOffsetLeft;\n                pos.y -= self.canvasOffsetTop;\n            }\n            return {\n                x: pos.x,\n                y: pos.y,\n                rect: rect\n            };\n        };\n        /**\n         * Ends editing, optionally aborting the edit.\n         * @memberof canvasDatagrid\n         * @name endEdit\n         * @method\n         * @param {boolean} abort When true, abort the edit.\n         */\n        self.endEdit = function (abort) {\n            var cell = self.input.editCell,\n                y = cell.rowIndex;\n            function abortEdit() {\n                abort = true;\n            }\n            if (self.dispatchEvent('beforeendedit', {\n                    cell: cell,\n                    newValue: self.input.value,\n                    oldValue: cell.value,\n                    abort: abortEdit,\n                    input: self.input\n                })) { return false; }\n            if (self.input.value !== cell.value && !abort) {\n                self.changes[y] = self.changes[y] || {};\n                self.changes[y][cell.header.name] = self.input.value;\n                cell.data[cell.header.name] = self.input.value;\n                if (y === self.data.length) {\n                    if (self.dispatchEvent('newrow', {\n                            value: self.input.value,\n                            defaultValue: cell.value,\n                            aborted: abort,\n                            cell: cell,\n                            input: self.input\n                        })) { return false; }\n                    self.uId += 1;\n                    self.addRow(cell.data);\n                    self.createNewRowData();\n                }\n                self.draw(true);\n            }\n            document.body.removeChild(self.input);\n            self.intf.focus();\n            self.dispatchEvent('endedit', {\n                cell: cell,\n                value: self.input.value,\n                aborted: abort,\n                input: self.input\n            });\n            self.input = undefined;\n            return true;\n        };\n        /**\n         * Begins editing at cell x, row y.\n         * @memberof canvasDatagrid\n         * @name beginEditAt\n         * @method\n         * @param {number} x The column index of the cell to edit.\n         * @param {number} y The row index of the cell to edit.\n         */\n        self.beginEditAt = function (x, y) {\n            if (!self.attributes.editable) { return; }\n            if (self.input) {\n                self.endEdit();\n            }\n            var cell = self.getVisibleCellByIndex(x, y),\n                s = self.getVisibleSchema(),\n                enumItems,\n                enu,\n                option,\n                valueInEnum;\n            if (!(cell && cell.header)) { return; }\n            //HACK for IE10, does not like literal enum\n            enu = cell.header['enum'];\n            if (self.dispatchEvent('beforebeginedit', {cell: cell})) { return false; }\n            self.scrollIntoView(x, y);\n            self.setActiveCell(x, y);\n            if (enu) {\n                self.input = document.createElement('select');\n            } else {\n                self.input = document.createElement(self.attributes.multiLine\n                    ? 'textarea' : 'input');\n            }\n            cell = self.getVisibleCellByIndex(x, y);\n            //HACK on mobile devices sometimes edit can begin without the cell being in view, I don't know how.\n            if (!cell) { return; }\n            if (enu) {\n                // add enums\n                if (typeof enu === 'function') {\n                    enumItems = enu.apply(self.intf, [{cell: cell}]);\n                } else if (Array.isArray(enu)) {\n                    enumItems = enu;\n                }\n                enumItems.forEach(function (e) {\n                    var i = document.createElement('option'),\n                        val,\n                        title;\n                    if (Array.isArray(e)) {\n                        val = e[0];\n                        title = e[1];\n                    } else {\n                        val = e;\n                        title = e;\n                    }\n                    if (val === cell.value) { valueInEnum = true; }\n                    i.value = val;\n                    i.innerHTML = title;\n                    self.input.appendChild(i);\n                });\n                if (!valueInEnum) {\n                    option = document.createElement('option');\n                    option.value = cell.value;\n                    option.innerHTML = cell.value;\n                    self.input.appendChild(option);\n                }\n                self.input.addEventListener('change', function () {\n                    self.endEdit();\n                    self.draw(true);\n                });\n            }\n            document.body.appendChild(self.input);\n            self.createInlineStyle(self.input, self.mobile ? 'canvas-datagrid-edit-mobile-input' : 'canvas-datagrid-edit-input');\n            self.input.style.position = 'absolute';\n            self.input.editCell = cell;\n            self.resizeEditInput();\n            self.input.style.zIndex = self.style.editCellZIndex;\n            self.input.style.fontSize = (parseInt(self.style.editCellFontSize, 10) * self.scale) + 'px';\n            self.input.value = cell.value;\n            self.input.focus();\n            self.input.addEventListener('click', self.stopPropagation);\n            self.input.addEventListener('dblclick', self.stopPropagation);\n            self.input.addEventListener('mouseup', self.stopPropagation);\n            self.input.addEventListener('mousedown', self.stopPropagation);\n            self.input.addEventListener('keydown', function (e) {\n                var nx = cell.columnIndex,\n                    ny = cell.rowIndex;\n                // esc\n                if (e.keyCode === 27) {\n                    self.endEdit(true);\n                    self.draw(true);\n                // enter\n                } else if (e.keyCode === 13\n                        && (!self.attributes.multiLine\n                            || (self.attributes.multiLine && e.shiftKey))) {\n                    self.endEdit();\n                    self.draw(true);\n                } else if (e.keyCode === 9) {\n                    e.preventDefault();\n                    if (!self.endEdit()) {\n                        return;\n                    }\n                    if (e.shiftKey) {\n                        nx -= 1;\n                    } else {\n                        nx += 1;\n                    }\n                    if (nx < 0) {\n                        nx = s.length - 1;\n                        ny -= 1;\n                    }\n                    if (nx > s.length - 1) {\n                        nx = 0;\n                        ny += 1;\n                    }\n                    if (ny < 0) {\n                        ny = self.data.length - 1;\n                    }\n                    if (ny > self.data.length - 1) {\n                        ny = 0;\n                    }\n                    self.scrollIntoView(nx, ny);\n                    self.beginEditAt(nx, ny);\n                }\n            });\n            self.dispatchEvent('beginedit', {cell: cell, input: self.input});\n        };\n        self.createInlineStyle = function (el, className) {\n            var css = {\n                'canvas-datagrid-context-menu-filter-input': {\n                    height: '19px',\n                    verticalAlign: 'bottom',\n                    marginLeft: '2px',\n                    padding: '0',\n                    background: self.style.contextFilterInputBackground,\n                    color: self.style.contextFilterInputColor,\n                    border: self.style.contextFilterInputBorder,\n                    borderRadius: self.style.contextFilterInputBorderRadius,\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextFilterInputFontFamily,\n                    fontSize: self.style.contextFilterInputFontSize\n                },\n                'canvas-datagrid-context-menu-filter-button': {\n                    height: '19px',\n                    verticalAlign: 'bottom',\n                    marginLeft: '2px',\n                    padding: '0',\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextFilterButtonBorder,\n                    borderRadius: self.style.contextFilterButtonBorderRadius,\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFilterButtonFontFamily,\n                    fontSize: self.style.contextMenuFilterButtonFontSize\n                },\n                'canvas-datagrid-context-child-arrow': {\n                    cssFloat: 'right',\n                    color: self.style.childContextMenuArrowColor,\n                    fontSize: self.style.contextMenuChildArrowFontSize,\n                    fontFamily: self.style.contextMenuFontFamily,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-autocomplete': {\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    position: 'absolute',\n                    zIndex: 9999,\n                    overflow: 'hidden'\n                },\n                'canvas-datagrid-autocomplete-item': {\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor\n                },\n                'canvas-datagrid-autocomplete-item:hover': {\n                    background: self.style.contextMenuHoverBackground,\n                    color: self.style.contextMenuHoverColor\n                },\n                'canvas-datagrid-canvas': {\n                    position: 'absolute',\n                    zIndex: '-1'\n                },\n                'canvas-datagrid': {\n                    display: 'block'\n                },\n                'canvas-datagrid-control-input': {\n                    position: 'fixed',\n                    top: '-5px',\n                    left: '-5px',\n                    border: 'none',\n                    opacity: '0',\n                    cursor: 'pointer',\n                    width: '1px',\n                    height: '1px',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize\n                },\n                'canvas-datagrid-edit-mobile-input': {\n                    boxSizing: 'content-box',\n                    outline: 'none',\n                    margin: '0',\n                    padding: '0 0 0 0',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.mobileEditFontFamily,\n                    fontSize: self.style.mobileEditFontSize,\n                    border: self.style.editCellBorder,\n                    color: self.style.editCellColor,\n                    background: self.style.editCellBackgroundColor,\n                    appearance: 'none',\n                    webkitAppearance: 'none',\n                    mozAppearance: 'none',\n                    borderRadius: '0'\n                },\n                'canvas-datagrid-edit-input': {\n                    boxSizing: 'content-box',\n                    outline: 'none',\n                    margin: '0',\n                    padding: '0 0 0 ' + self.style.editCellPaddingLeft + 'px',\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.editCellFontFamily,\n                    fontSize: self.style.editCellFontSize,\n                    boxShadow: self.style.editCellBoxShadow,\n                    border: self.style.editCellBorder,\n                    color: self.style.editCellColor,\n                    background: self.style.editCellBackgroundColor,\n                    appearance: 'none',\n                    webkitAppearance: 'none',\n                    mozAppearance: 'none',\n                    borderRadius: '0'\n                },\n                'canvas-datagrid-context-menu-item-mobile': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    color: 'inherit',\n                    background: 'inherit',\n                    margin: self.style.contextMenuItemMargin,\n                    borderRadius: self.style.contextMenuItemBorderRadius,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-context-menu-item': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    color: 'inherit',\n                    background: 'inherit',\n                    margin: self.style.contextMenuItemMargin,\n                    borderRadius: self.style.contextMenuItemBorderRadius,\n                    verticalAlign: 'middle'\n                },\n                'canvas-datagrid-context-menu-item:hover': {\n                    background: self.style.contextMenuHoverBackground,\n                    color: self.style.contextMenuHoverColor\n                },\n                'canvas-datagrid-context-menu-label': {\n                    margin: self.style.contextMenuLabelMargin,\n                    display: self.style.contextMenuLabelDisplay,\n                    minWidth: self.style.contextMenuLabelMinWidth,\n                    maxWidth: self.style.contextMenuLabelMaxWidth\n                },\n                'canvas-datagrid-context-menu-mobile': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    overflow: 'hidden',\n                    whiteSpace: 'nowrap'\n                },\n                'canvas-datagrid-context-menu': {\n                    lineHeight: 'normal',\n                    fontWeight: 'normal',\n                    fontFamily: self.style.contextMenuFontFamily,\n                    fontSize: self.style.contextMenuFontSize,\n                    background: self.style.contextMenuBackground,\n                    color: self.style.contextMenuColor,\n                    border: self.style.contextMenuBorder,\n                    padding: self.style.contextMenuPadding,\n                    borderRadius: self.style.contextMenuBorderRadius,\n                    opacity: self.style.contextMenuOpacity,\n                    overflow: 'hidden',\n                    whiteSpace: 'nowrap'\n                },\n                'canvas-datagrid-invalid-search-regExp': {\n                    background: self.style.contextMenuFilterInvalidExpresion\n                }\n            };\n            if (css[className]) {\n                Object.keys(css[className]).map(function (prop) {\n                    el.style[prop] = css[className][prop];\n                });\n            }\n            return;\n        };\n        self.appendTo = function (e) {\n            self.parentNode = e;\n            self.setDom();\n        };\n        self.setDom = function () {\n            if (self.isChildGrid) {\n                self.parentGrid = self.parentNode.parentGrid;\n                self.ctx = self.parentGrid.context;\n                self.canvas = self.parentGrid.canvas;\n                self.controlInput = self.parentGrid.controlInput;\n                self.eventParent = self.canvas;\n            } else {\n                self.controlInput = self.controlInput || document.createElement('input');\n                self.controlInput.onblur = self.intf.blur;\n                self.createInlineStyle(self.controlInput, 'canvas-datagrid-control-input');\n                self.isChildGrid = false;\n                self.parentDOMNode = self.parentNode;\n                self.parentIsCanvas = /^canvas$/i.test(self.parentDOMNode.tagName);\n                if (self.parentIsCanvas) {\n                    self.canvas = self.parentDOMNode;\n                    self.parentDOMNode.appendChild(self.controlInput);\n                } else {\n                    self.canvas = document.createElement('canvas');\n                    self.parentDOMNode.appendChild(self.canvas);\n                    self.parentDOMNode.appendChild(self.controlInput);\n                }\n                self.createInlineStyle(self.canvas, 'canvas-datagrid');\n                self.ctx = self.canvas.getContext('2d');\n                self.ctx.textBaseline = 'alphabetic';\n                self.eventParent = self.canvas;\n            }\n            self.parentNodeStyle = self.canvas.style;\n            // simulate a block element\n            if (self.intf.tagName === 'SECTION') {\n                // required for non custom tag browsers\n                self.intf.style.height = '100%';\n                self.intf.style.width = '100%';\n            }\n            self.parentNodeStyle.width = '100%';\n            self.parentNodeStyle.height = '100%';\n            self.controlInput.setAttribute('readonly', true);\n            self.controlInput.addEventListener('blur', function (e) {\n                if (e.target !== self.canvas) {\n                    self.hasFocus = false;\n                }\n            });\n            self.eventParent.addEventListener('scroll', self.resize, false);\n            self.eventParent.addEventListener('touchstart', self.touchstart, false);\n            self.eventParent.addEventListener('mouseup', self.mouseup, false);\n            self.eventParent.addEventListener('mousedown', self.mousedown, false);\n            self.eventParent.addEventListener('dblclick', self.dblclick, false);\n            self.eventParent.addEventListener('click', self.click, false);\n            self.eventParent.addEventListener('mousemove', self.mousemove);\n            self.eventParent.addEventListener('wheel', self.scrollWheel, false);\n            self.canvas.addEventListener('contextmenu', self.contextmenuEvent, false);\n            self.controlInput.addEventListener('copy', self.copy);\n            self.controlInput.addEventListener('cut', self.cut);\n            self.controlInput.addEventListener('paste', self.paste);\n            self.controlInput.addEventListener('keypress', self.keypress, false);\n            self.controlInput.addEventListener('keyup', self.keyup, false);\n            self.controlInput.addEventListener('keydown', self.keydown, false);\n            window.addEventListener('resize', self.resize);\n        };\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/dom.js\n// module id = 8\n// module chunks = 0","/*jslint browser: true, unparam: true, todo: true*/\n/*globals define: true, MutationObserver: false, requestAnimationFrame: false, performance: false, btoa: false*/\ndefine([], function () {\n    'use strict';\n    return function (self) {\n        // all methods here are exposed by intf\n        // to users\n        /**\n         * Converts a integer into a letter A - ZZZZZ...\n         * @memberof canvasDatagrid\n         * @name integerToAlpha\n         * @method\n         * @param {column} n The number to convert.\n         */\n        self.integerToAlpha = function (n) {\n            var ordA = 'a'.charCodeAt(0),\n                ordZ = 'z'.charCodeAt(0),\n                len = ordZ - ordA + 1,\n                s = '';\n            while (n >= 0) {\n                s = String.fromCharCode(n % len + ordA) + s;\n                n = Math.floor(n / len) - 1;\n            }\n            return s;\n        };\n        /**\n         * Inserts a new column before the specified index into the schema.\n         * @tutorial schema\n         * @memberof canvasDatagrid\n         * @name insertColumn\n         * @method\n         * @param {column} c The column to insert into the schema.\n         * @param {number} index The index of the column to insert before.\n         */\n        self.insertColumn = function (c, index) {\n            var s = self.getSchema();\n            if (s.length < index) {\n                throw new Error('Index is beyond the length of the schema.');\n            }\n            self.validateColumn(c, s);\n            s.splice(index, 0, c);\n            self.data.forEach(function (row) {\n                self.applyDefaultValue(row, c);\n            });\n            self.intf.schema = s;\n        };\n        /**\n         * Deletes a column from the schema at the specified index.\n         * @memberof canvasDatagrid\n         * @name deleteColumn\n         * @tutorial schema\n         * @method\n         * @param {number} index The index of the column to delete.\n         */\n        self.deleteColumn = function (index) {\n            var s = self.getSchema();\n            // remove data matching this column name from data\n            self.data.forEach(function (row) {\n                delete row[s[index].name];\n            });\n            s.splice(index, 1);\n            self.intf.schema = s;\n        };\n        /**\n         * Adds a new column into the schema.\n         * @tutorial schema\n         * @memberof canvasDatagrid\n         * @name addColumn\n         * @method\n         * @param {column} c The column to add to the schema.\n         */\n        self.addColumn = function (c) {\n            var s = self.getSchema();\n            self.validateColumn(c, s);\n            s.push(c);\n            self.data.forEach(function (row) {\n                self.applyDefaultValue(row, c);\n            });\n            self.intf.schema = s;\n        };\n        /**\n         * Deletes a row from the dataset at the specified index.\n         * @memberof canvasDatagrid\n         * @name deleteRow\n         * @method\n         * @param {number} index The index of the row to delete.\n         */\n        self.deleteRow = function (index) {\n            self.originalData.splice(index, 1);\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Inserts a new row into the dataset before the specified index.\n         * @memberof canvasDatagrid\n         * @name insertRow\n         * @method\n         * @param {object} d data.\n         * @param {number} index The index of the row to insert before.\n         */\n        self.insertRow = function (d, index) {\n            if (self.originalData.length < index) {\n                throw new Error('Index is beyond the length of the dataset.');\n            }\n            self.originalData.splice(index, 0, d);\n            self.getSchema().forEach(function (c) {\n                if (d[c.name] === undefined) {\n                    self.applyDefaultValue(self.originalData[index], c);\n                }\n            });\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Adds a new row into the dataset.\n         * @memberof canvasDatagrid\n         * @name addRow\n         * @method\n         * @param {object} d data.\n         */\n        self.addRow = function (d) {\n            self.originalData.push(d);\n            self.getSchema().forEach(function (c) {\n                if (d[c.name] === undefined) {\n                    self.applyDefaultValue(self.originalData[self.originalData.length - 1], c);\n                }\n            });\n            self.setFilter();\n            self.resize(true);\n        };\n        /**\n         * Sets the height of a given row by index number.\n         * @memberof canvasDatagrid\n         * @name setRowHeight\n         * @method\n         * @param {number} rowIndex The index of the row to set.\n         * @param {number} height Height to set the row to.\n         */\n        self.setRowHeight = function (rowIndex, height) {\n            self.sizes.rows[self.data[rowIndex][self.uniqueId]] = height;\n            self.draw(true);\n        };\n        /**\n         * Sets the width of a given column by index number.\n         * @memberof canvasDatagrid\n         * @name setColumnWidth\n         * @method\n         * @param {number} colIndex The index of the column to set.\n         * @param {number} width Width to set the column to.\n         */\n        self.setColumnWidth = function (colIndex, width) {\n            var s = self.getSchema();\n            self.sizes.columns[s[colIndex][self.uniqueId]] = width;\n            self.draw(true);\n        };\n        /**\n         * Removes any changes to the width of the columns due to user or api interaction, setting them back to the schema or style default.\n         * @memberof canvasDatagrid\n         * @name resetColumnWidths\n         * @tutorial schema\n         * @method\n         */\n        self.resetColumnWidths = function () {\n            self.sizes.columns = {};\n            self.draw(true);\n        };\n        /**\n         * Removes any changes to the height of the rows due to user or api interaction, setting them back to the schema or style default.\n         * @memberof canvasDatagrid\n         * @name resetRowHeights\n         * @tutorial schema\n         * @method\n         */\n        self.resetRowHeights = function () {\n            self.sizes.rows = {};\n            self.draw(true);\n        };\n        /**\n         * Sets the value of the filter.\n         * @memberof canvasDatagrid\n         * @name setFilter\n         * @method\n         * @param {string} column Name of the column to filter.\n         * @param {string} value The value to filter for.\n         */\n        self.setFilter = function (column, value) {\n            function applyFilter() {\n                self.refreshFromOrigialData();\n                Object.keys(self.columnFilters).forEach(function (filter) {\n                    var header = self.getHeaderByName(column);\n                    if (!header) {\n                        return;\n                    }\n                    self.currentFilter = header.filter || self.filter(column.type || 'string');\n                    self.data = self.data.filter(function (row) {\n                        return self.currentFilter(row[filter], self.columnFilters[filter]);\n                    });\n                });\n                self.resize();\n                self.draw(true);\n            }\n            if (column === undefined && value === undefined) {\n                self.columnFilters = {};\n                return applyFilter();\n            }\n            if (column && (value === '' || value === undefined)) {\n                delete self.columnFilters[column];\n            } else {\n                self.columnFilters[column] = value;\n            }\n            applyFilter();\n        };\n        /**\n         * Returns the number of pixels to scroll down to line up with row rowIndex.\n         * @memberof canvasDatagrid\n         * @name findRowScrollTop\n         * @method\n         * @param {number} rowIndex The row index of the row to scroll find.\n         */\n        self.findRowScrollTop = function (rowIndex) {\n            var top = 0, x = 0, l = self.data.length,\n                bm = self.style.gridBorderCollapse === 'collapse' ? 1 : 2,\n                cellBorder = self.style.cellBorderWidth * bm;\n            if (!self.attributes.showNewRow) {\n                l -= 1;\n            }\n            if (rowIndex > l) {\n                throw new Error('Impossible row index');\n            }\n            while (x < rowIndex) {\n                top += (self.sizes.rows[self.data[x][self.uniqueId]] || self.style.cellHeight) + cellBorder;\n                x += 1;\n            }\n            //TODO: This is not super accurate, causes pageUp/Dn to not move around right\n            return top - (self.sizes.rows[self.data[rowIndex][self.uniqueId]] || self.style.cellHeight);\n        };\n        /**\n         * Returns the number of pixels to scroll to the left to line up with column columnIndex.\n         * @memberof canvasDatagrid\n         * @name findColumnScrollLeft\n         * @method\n         * @param {number} columnIndex The column index of the column to find.\n         */\n        self.findColumnScrollLeft = function (columnIndex) {\n            var left = 0, y = 0, s = self.getSchema(), l = s.length - 1;\n            if (columnIndex > l) {\n                throw new Error('Impossible column index');\n            }\n            while (y < columnIndex) {\n                left += self.sizes.columns[s[y][self.uniqueId]] || s[y].width || self.style.cellWidth;\n                y += 1;\n            }\n            return left;\n        };\n        /**\n         * Scrolls the cell at cell x, row y.\n         * @memberof canvasDatagrid\n         * @name gotoCell\n         * @method\n         * @param {number} x The column index of the cell to scroll to.\n         * @param {number} y The row index of the cell to scroll to.\n         */\n        self.gotoCell = function (x, y) {\n            if (x !== undefined) {\n                self.scrollBox.scrollLeft = self.findColumnScrollLeft(x);\n            }\n            if (y !== undefined) {\n                self.scrollBox.scrollTop = self.findRowScrollTop(y);\n            }\n        };\n        /**\n         * Scrolls the row y.\n         * @memberof canvasDatagrid\n         * @name gotoRow\n         * @method\n         * @param {number} y The row index of the cell to scroll to.\n         */\n        self.gotoRow = function (y) {\n            self.gotoCell(0, y);\n        };\n        /**\n         * Scrolls the cell at cell x, row y into view if it is not already.\n         * @memberof canvasDatagrid\n         * @name scrollIntoView\n         * @method\n         * @param {number} x The column index of the cell to scroll into view.\n         * @param {number} y The row index of the cell to scroll into view.\n         */\n        self.scrollIntoView = function (x, y) {\n            if (self.visibleCells.filter(function (cell) {\n                    return (cell.rowIndex === y || y === undefined)\n                        && (cell.columnIndex === x || x === undefined)\n                        && cell.x > 0\n                        && cell.y > 0\n                        && cell.x + cell.width < self.width\n                        && cell.y + cell.height < self.height;\n                }).length === 0) {\n                self.gotoCell(x, y);\n            }\n        };\n        /**\n         * Sets the active cell. Requires redrawing.\n         * @memberof canvasDatagrid\n         * @name setActiveCell\n         * @method\n         * @param {number} x The column index of the cell to set active.\n         * @param {number} y The row index of the cell to set active.\n         */\n        self.setActiveCell = function (x, y) {\n            self.activeCell = {\n                rowIndex: y,\n                columnIndex: x\n            };\n        };\n        /**\n         * Removes the selection.\n         * @memberof canvasDatagrid\n         * @name selectNone\n         * @param {boolean} dontDraw Suppress the draw method after the selection change.\n         * @method\n         */\n        self.selectNone = function (dontDraw) {\n            self.selections = [];\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n            if (dontDraw) { return; }\n            self.draw();\n        };\n        /**\n         * Selects every visible cell.\n         * @memberof canvasDatagrid\n         * @name selectAll\n         * @param {boolean} dontDraw Suppress the draw method after the selection change.\n         * @method\n         */\n        self.selectAll = function (dontDraw) {\n            self.selectArea({\n                top: 0,\n                left: 0,\n                right: self.getVisibleSchema().length - 1,\n                bottom: self.data.length - 1\n            });\n            if (dontDraw) { return; }\n            self.draw();\n        };\n        /**\n         * Returns true if the selected columnIndex is selected on every row.\n         * @memberof canvasDatagrid\n         * @name isColumnSelected\n         * @method\n         * @param {number} columnIndex The column index to check.\n         */\n        self.isColumnSelected = function (columnIndex) {\n            var colIsSelected = true;\n            self.data.forEach(function (row, rowIndex) {\n                if (!self.selections[rowIndex] || self.selections[rowIndex].indexOf(self.orders.columns[columnIndex]) === -1) {\n                    colIsSelected = false;\n                }\n            });\n            return colIsSelected;\n        };\n        /**\n         * Runs the defined method on each selected cell.\n         * @memberof canvasDatagrid\n         * @name forEachSelectedCell\n         * @method\n         * @param {number} fn The function to execute.  The signature of the function is: (data, rowIndex, columnName).\n         * @param {number} expandToRow When true the data in the array is expanded to the entire row.\n         */\n        self.forEachSelectedCell = function (fn, expandToRow) {\n            var d = [], s = expandToRow ? self.getSchema() : self.getVisibleSchema(), l = self.data.length;\n            self.selections.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) {\n                    d[index] = null;\n                    return;\n                }\n                d[index] = {};\n                row.forEach(function (col) {\n                    if (col === -1 || !s[col]) { return; }\n                    fn(self.data, index, s[col].name);\n                });\n            });\n        };\n        /**\n         * Selects a column.\n         * @memberof canvasDatagrid\n         * @name selectColumn\n         * @method\n         * @param {number} columnIndex The column index to select.\n         * @param {boolean} toggleSelectMode When true, behaves as if you were holding control/command when you clicked the column.\n         * @param {boolean} shift When true, behaves as if you were holding shift when you clicked the column.\n         * @param {boolean} supressSelectionchangedEvent When true, prevents the selectionchanged event from firing.\n         */\n        self.selectColumn = function (columnIndex, ctrl, shift, supressEvent) {\n            var s, e, x;\n            function addCol(i) {\n                self.data.forEach(function (row, rowIndex) {\n                    self.selections[rowIndex] = self.selections[rowIndex] || [];\n                    if (self.selections[rowIndex].indexOf(i) === -1) {\n                        self.selections[rowIndex].push(i);\n                    }\n                });\n            }\n            function removeCol(i) {\n                self.data.forEach(function (row, rowIndex) {\n                    self.selections[rowIndex] = self.selections[rowIndex] || [];\n                    if (self.selections[rowIndex].indexOf(i) !== -1) {\n                        self.selections[rowIndex].splice(self.selections[rowIndex].indexOf(i), 1);\n                    }\n                });\n            }\n            if (shift) {\n                if (!self.activeCell) { return; }\n                s = Math.min(self.activeCell.columnIndex, columnIndex);\n                e = Math.max(self.activeCell.columnIndex, columnIndex);\n                for (x = s; e > x; x += 1) {\n                    addCol(x);\n                }\n            }\n            if (!ctrl && !shift) {\n                self.selections = [];\n                self.activeCell.columnIndex = columnIndex;\n                self.activeCell.rowIndex = self.scrollIndexTop;\n            }\n            if (ctrl && self.isColumnSelected(columnIndex)) {\n                removeCol(columnIndex);\n            } else {\n                addCol(columnIndex);\n            }\n            if (supressEvent) { return; }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.getSelectionBounds()\n            });\n        };\n        /**\n         * Selects a row.\n         * @memberof canvasDatagrid\n         * @name selectRow\n         * @method\n         * @param {number} rowIndex The row index to select.\n         * @param {boolean} ctrl When true, behaves as if you were holding control/command when you clicked the row.\n         * @param {boolean} shift When true, behaves as if you were holding shift when you clicked the row.\n         * @param {boolean} supressSelectionchangedEvent When true, prevents the selectionchanged event from firing.\n         */\n        self.selectRow = function (rowIndex, ctrl, shift, supressEvent) {\n            var x, st, en, s = self.getVisibleSchema();\n            function addRow(ri) {\n                self.selections[ri] = [];\n                self.selections[ri].push(-1);\n                s.forEach(function (col, index) {\n                    self.selections[ri].push(index);\n                });\n            }\n            if (self.dragAddToSelection === false || self.dragObject === undefined) {\n                if (self.selections[rowIndex] && self.selections[rowIndex].length - 1 === s.length) {\n                    if (ctrl) {\n                        self.selections[rowIndex] = [];\n                        return;\n                    }\n                }\n            }\n            if (self.dragAddToSelection === true || self.dragObject === undefined) {\n                if (shift && self.dragObject === undefined) {\n                    if (!self.activeCell) { return; }\n                    st = Math.min(self.activeCell.rowIndex, rowIndex);\n                    en = Math.max(self.activeCell.rowIndex, rowIndex);\n                    for (x = st; en >= x; x += 1) {\n                        addRow(x);\n                    }\n                } else {\n                    addRow(rowIndex);\n                }\n            }\n            if (supressEvent) { return; }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n        };\n        /**\n         * Collapse a tree grid by row index.\n         * @memberof canvasDatagrid\n         * @name collapseTree\n         * @method\n         * @param {number} index The index of the row to collapse.\n         */\n        self.collapseTree = function (rowIndex) {\n            var rowId = self.data[rowIndex][self.uniqueId];\n            self.dispatchEvent('collapsetree', {\n                childGrid: self.childGrids[rowId],\n                data: self.data[rowIndex],\n                rowIndex: rowIndex\n            });\n            self.openChildren[rowId].blur();\n            self.openChildren[rowId].dispose();\n            delete self.openChildren[rowId];\n            delete self.sizes.trees[rowId];\n            delete self.childGrids[rowId];\n            self.dispatchEvent('resizerow', {\n                cellHeight: self.style.cellHeight\n            });\n            self.resize(true);\n            self.draw(true);\n        };\n        /**\n         * Expands a tree grid by row index.\n         * @memberof canvasDatagrid\n         * @name expandTree\n         * @method\n         * @param {number} index The index of the row to expand.\n         */\n        self.expandTree = function (rowIndex) {\n            var trArgs = self.args.treeGridAttributes || {},\n                columnHeaderCellHeight = self.getColumnHeaderCellHeight(),\n                rowHeaderCellWidth = self.sizes.columns.cornerCell || self.style.rowHeaderCellWidth,\n                rowId = self.data[rowIndex][self.uniqueId],\n                h = self.sizes.trees[rowId] || self.style.treeGridHeight,\n                treeGrid;\n            if (!self.childGrids[rowId]) {\n                trArgs.debug = self.attributes.debug;\n                trArgs.name = self.attributes.saveAppearance ? self.attributes.name + 'tree' + rowId : undefined;\n                trArgs.style = trArgs.style || self.style;\n                trArgs.parentNode = {\n                    parentGrid: self.intf,\n                    nodeType: 'canvas-datagrid-tree',\n                    offsetHeight: h,\n                    offsetWidth: self.width - rowHeaderCellWidth,\n                    header: { width: self.width - rowHeaderCellWidth },\n                    offsetLeft: rowHeaderCellWidth,\n                    offsetTop: columnHeaderCellHeight,\n                    offsetParent: self.intf.parentNode,\n                    parentNode: self.intf.parentNode,\n                    style: 'tree',\n                    data: self.data[rowIndex]\n                };\n                treeGrid = self.createGrid(trArgs);\n                self.childGrids[rowId] = treeGrid;\n            }\n            treeGrid = self.childGrids[rowId];\n            treeGrid.visible = true;\n            self.dispatchEvent('expandtree', {\n                treeGrid: treeGrid,\n                data: self.data[rowIndex],\n                rowIndex: rowIndex\n            });\n            self.openChildren[rowId] = treeGrid;\n            self.sizes.trees[rowId] = h;\n            self.dispatchEvent('resizerow', {height: self.style.cellHeight});\n            self.resize(true);\n        };\n        /**\n         * Toggles tree grid open and close by row index.\n         * @memberof canvasDatagrid\n         * @name toggleTree\n         * @method\n         * @param {number} index The index of the row to toggle.\n         */\n        self.toggleTree = function (rowIndex) {\n            var i = self.openChildren[self.data[rowIndex][self.uniqueId]];\n            if (i) {\n                return self.collapseTree(rowIndex);\n            }\n            self.expandTree(rowIndex);\n        };\n        /**\n         * Returns a header from the schema by name.\n         * @memberof canvasDatagrid\n         * @name getHeaderByName\n         * @tutorial schema\n         * @method\n         * @returns {header} header with the selected name, or undefined.\n         * @param {string} name The name of the column to resize.\n         */\n        self.getHeaderByName = function (name) {\n            var x, i = self.getSchema();\n            for (x = 0; x < i.length; x += 1) {\n                if (i[x].name === name) {\n                    return i[x];\n                }\n            }\n        };\n        /**\n         * Resizes a column to fit the longest value in the column. Call without a value to resize all columns.\n         * Warning, can be slow on very large record sets (1m records ~3-5 seconds on an i7).\n         * @memberof canvasDatagrid\n         * @name fitColumnToValues\n         * @method\n         * @param {string} name The name of the column to resize.\n         */\n        self.fitColumnToValues = function (name, internal) {\n            if (!self.canvas) { return; }\n            self.sizes.columns[name === 'cornerCell' ? name : self.getHeaderByName(name)[self.uniqueId]]\n                = self.findColumnMaxTextLength(name);\n            if (!internal) {\n                self.resize();\n                self.draw(true);\n            }\n        };\n        /**\n         * Checks if a cell is currently visible.\n         * @memberof canvasDatagrid\n         * @name isCellVisible\n         * @overload\n         * @method\n         * @returns {boolean} when true, the cell is visible, when false the cell is not currently drawn.\n         * @param {number} columnIndex The column index of the cell to check.\n         * @param {number} rowIndex The row index of the cell to check.\n         */\n        /**\n         * Checks if a cell is currently visible.\n         * @memberof canvasDatagrid\n         * @name isCellVisible\n         * @method\n         * @returns {boolean} when true, the cell is visible, when false the cell is not currently drawn.\n         * @param {cell} cell The cell to check for.  Alternatively you can pass an object { x: <x-pixel-value>, y: <y-pixel-value> }.\n         */\n        self.isCellVisible = function (cell, rowIndex) {\n            // overload\n            if (rowIndex !== undefined) {\n                return self.visibleCells.filter(function (c) {\n                    return c.columnIndex === cell && c.rowIndex === rowIndex;\n                }).length > 0;\n            }\n            var x, l = self.visibleCells.length;\n            for (x = 0; x < l; x += 1) {\n                if (cell.x === self.visibleCells[x].x && cell.y === self.visibleCells[x].y) {\n                    return true;\n                }\n            }\n            return false;\n        };\n        /**\n         * Sets the order of the data.\n         * @memberof canvasDatagrid\n         * @name order\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} columnName Name of the column to be sorted.\n         * @param {string} direction `asc` for ascending or `desc` for descending.\n         * @param {function} [sortFunction] When defined, override the default sorting method defined in the column's schema and use this one.\n         * @param {bool} [dontSetStorageData] Don't store this setting for future use.\n         */\n        self.order = function (columnName, direction, sortFunction, dontSetStorageData) {\n            var f,\n                c = self.getSchema().filter(function (col) {\n                    return col.name === columnName;\n                });\n            self.orderBy = columnName;\n            if (c.length === 0) {\n                throw new Error('Cannot sort.  No such column name');\n            }\n            f = sortFunction || self.sorters[c[0].type];\n            if (!f && c[0].type !== undefined) {\n                console.warn('Cannot sort type \"%s\" falling back to string sort.', c[0].type);\n            }\n            self.data = self.data.sort(typeof f === 'function' ? f(columnName, direction) : self.sorters.string);\n            self.dispatchEvent('ordercolumn', {name: columnName, direction: direction});\n            self.draw(true);\n            if (dontSetStorageData) { return; }\n            self.setStorageData();\n        };\n        self.isInGrid = function (e) {\n            if (e.x < 0\n                    || e.x > self.width\n                    || e.y < 0\n                    || e.y > self.height) {\n                return false;\n            }\n            return true;\n        };\n        /**\n         * Moves the current selection relative to the its current position.  Note: this method does not move the selected data, just the selection itself.\n         * @memberof canvasDatagrid\n         * @name moveSelection\n         * @method\n         * @param {number} offsetX The number of columns to offset the selection.\n         * @param {number} offsetY The number of rows to offset the selection.\n         */\n        self.moveSelection = function (offsetX, offsetY) {\n            var sel = [];\n            self.selections.forEach(function (row, rowIndex) {\n                sel[rowIndex + offsetY] = [];\n                row.forEach(function (colIndex) {\n                    sel[rowIndex + offsetY].push(colIndex + offsetX);\n                });\n            });\n            self.selections = sel;\n        };\n        /**\n         * Moves data in the provided selection to another position in the grid.  Moving data off the edge of the schema (columns/x) will truncate data.\n         * @memberof canvasDatagrid\n         * @name moveTo\n         * @method\n         * @param {array} sel 2D array representing selected rows and columns.  `canvasDatagrid.selections` is in this format and can be used here.\n         * @param {number} x The column index to start inserting the selection at.\n         * @param {number} y The row index to start inserting the selection at.\n         */\n        self.moveTo = function (sel, x, y) {\n            var d = self.getSelectedData(),\n                s = self.getVisibleSchema(),\n                l = sel.length,\n                xi,\n                yi = y - 1;\n            sel.forEach(function (row, index) {\n                if (index === l) { return; }\n                if (row.length === 0) { return; }\n                row.forEach(function (col) {\n                    if (!s[col]) { return; }\n                    self.data[index][s[col].name] = null;\n                });\n            });\n            sel.forEach(function (row, index) {\n                yi += 1;\n                xi = x - 1;\n                row.forEach(function (col, cidx) {\n                    xi += 1;\n                    if (col === -1\n                            || !s[xi]\n                            || !s[col]\n                            || self.data.length - 1 < yi\n                            || yi < 0) { return; }\n                    self.data[yi][s[xi].name] = d[index][s[col].name];\n                });\n            });\n        };\n        /**\n         * Checks if a given column is visible.\n         * @memberof canvasDatagrid\n         * @name isColumnVisible\n         * @method\n         * @returns {boolean} When true, the column is visible.\n         * @param {number} columnIndex Column index.\n         */\n        self.isColumnVisible = function (columnIndex) {\n            return self.visibleCells.filter(function (c) {\n                return c.columnIndex === columnIndex;\n            }).length > 0;\n        };\n        /**\n         * Checks if a given row is visible.\n         * @memberof canvasDatagrid\n         * @name isRowVisible\n         * @method\n         * @returns {boolean} When true, the row is visible.\n         * @param {number} rowIndex Row index.\n         */\n        self.isRowVisible = function (rowIndex) {\n            return self.visibleCells.filter(function (c) {\n                return c.rowIndex === rowIndex;\n            }).length > 0;\n        };\n        /**\n         * Gets the cell at columnIndex and rowIndex.\n         * @memberof canvasDatagrid\n         * @name getVisibleCellByIndex\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} x Column index.\n         * @param {number} y Row index.\n         */\n        self.getVisibleCellByIndex = function (x, y) {\n            return self.visibleCells.filter(function (c) {\n                return c.columnIndex === x && c.rowIndex === y;\n            })[0];\n        };\n        /**\n         * Gets the cell at grid pixel coordinate x and y.  Author's note.  This function ties drawing and events together.  This is a very complex function and is core to the component.\n         * @memberof canvasDatagrid\n         * @name getCellAt\n         * @method\n         * @returns {cell} cell at the selected location.\n         * @param {number} x Number of pixels from the left.\n         * @param {number} y Number of pixels from the top.\n         */\n        self.getCellAt = function (x, y, useTouchScrollZones) {\n            function getBorder(cell) {\n                if (cell.x + cell.width - (self.attributes.borderResizeZone * 0.4) < x && cell.x + cell.width + (self.attributes.borderResizeZone * 0.6) > x) {\n                    return 'r';\n                }\n                if (cell.x - (self.attributes.borderResizeZone * 0.4) < x && cell.x + (self.attributes.borderResizeZone * 0.6) > x) {\n                    return 'l';\n                }\n                if (cell.y + cell.height - (self.attributes.borderResizeZone * 0.4) < y && cell.y + cell.height + (self.attributes.borderResizeZone * 0.6) > y) {\n                    return 'b';\n                }\n                if (cell.y - (self.attributes.borderResizeZone * 0.4) < y && cell.y + (self.attributes.borderResizeZone * 0.6) > y) {\n                    return 't';\n                }\n            }\n            if (!self.visibleCells) { return; }\n            var border,\n                tsz = useTouchScrollZones ? self.attributes.touchScrollZone : 0,\n                moveMode = self.attributes.borderDragBehavior === 'move',\n                i,\n                l = self.visibleCells.length,\n                moveBorder,\n                xBorderBehavior = moveMode ? self.cursorGrab : 'ew-resize',\n                yBorderBehavior = moveMode ? self.cursorGrab : 'ns-resize',\n                cell;\n            if (!self.visibleCells || !self.visibleCells.length) { return; }\n            self.hasFocus = true;\n            if (!(y < self.height\n                && y > 0\n                && x < self.width\n                && x > 0)) {\n                self.hasFocus = false;\n                return {\n                    dragContext: 'inherit',\n                    context: 'inherit'\n                };\n            }\n            for (i = 0; i < l; i += 1) {\n                cell = self.visibleCells[i];\n                if (useTouchScrollZones && /(vertical|horizontal)-scroll-/.test(cell.style)) {\n                    cell.x -= tsz;\n                    cell.y -= tsz;\n                    cell.height += tsz;\n                    cell.width += tsz;\n                }\n                if (cell.x - self.style.cellBorderWidth < x\n                        && cell.x + cell.width + self.style.cellBorderWidth > x\n                        && cell.y - self.style.cellBorderWidth < y\n                        && cell.y + cell.height + self.style.cellBorderWidth > y) {\n                    if (/frozen-row-marker/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'row-resize';\n                        return cell;\n                    }\n                    if (/frozen-column-marker/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'col-resize';\n                        return cell;\n                    }\n                    if (/selection-handle-/.test(cell.style)) {\n                        cell.dragContext = cell.style;\n                        cell.context = 'crosshair';\n                        return cell;\n                    }\n                    if (/vertical-scroll-(bar|box)/.test(cell.style)) {\n                        cell.dragContext = 'vertical-scroll-box';\n                        cell.context = 'vertical-scroll-box';\n                        cell.isScrollBar = true;\n                        cell.isVerticalScrollBar = true;\n                        if (y > self.scrollBox.box.v.y + self.scrollBox.scrollBoxHeight) {\n                            cell.dragContext = 'vertical-scroll-bottom';\n                            cell.context = 'vertical-scroll-bottom';\n                        } else if (y < self.scrollBox.box.v.y) {\n                            cell.dragContext = 'vertical-scroll-top';\n                            cell.context = 'vertical-scroll-top';\n                        }\n                        self.cursor = 'default';\n                        return cell;\n                    }\n                    if (/horizontal-scroll-(bar|box)/.test(cell.style)) {\n                        cell.dragContext = 'horizontal-scroll-box';\n                        cell.context = 'horizontal-scroll-box';\n                        cell.isScrollBar = true;\n                        cell.isHorizontalScrollBar = true;\n                        if (x > self.scrollBox.box.h.x + self.scrollBox.scrollBoxWidth) {\n                            cell.dragContext = 'horizontal-scroll-right';\n                            cell.context = 'horizontal-scroll-right';\n                        } else if (x < self.scrollBox.box.h.x) {\n                            cell.dragContext = 'horizontal-scroll-left';\n                            cell.context = 'horizontal-scroll-left';\n                        }\n                        self.cursor = 'default';\n                        return cell;\n                    }\n                    border = getBorder(cell);\n                    // check if the border of this cell is the border of the selection and if so show move cursor in move mode\n                    moveBorder = moveMode && cell.selectionBorder && cell.selectionBorder.indexOf(border) !== -1;\n                    if (['l', 'r'].indexOf(border) !== -1\n                            && (self.attributes.allowColumnResize || moveBorder)\n                            && ((self.attributes.allowColumnResizeFromCell && cell.isNormal) || !cell.isNormal || moveBorder)\n                            && ((self.attributes.allowRowHeaderResize && (cell.isRowHeader || cell.isCorner)) || !(cell.isRowHeader && cell.isCorner))) {\n                        if (((cell.isColumnHeader || cell.isCorner) || (self.attributes.allowColumnResizeFromCell && cell.isNormal)) && border === 'r') {\n                            cell.context = 'ew-resize';\n                            cell.dragContext = 'ew-resize';\n                            return cell;\n                        }\n                        if (!(cell.isColumnHeader || cell.isCorner) && moveBorder) {\n                            cell.context = xBorderBehavior;\n                            cell.dragContext = border + '-move';\n                            return cell;\n                        }\n                    }\n                    if (['t', 'b'].indexOf(border) !== -1\n                            && cell.rowIndex > -1\n                            && (self.attributes.allowRowResize || moveBorder)\n                            && ((self.attributes.allowRowResizeFromCell && cell.isNormal) || !cell.isNormal || moveBorder)\n                            && !cell.isColumnHeader) {\n                        if (((cell.isRowHeader || cell.isCorner) || (self.attributes.allowRowResizeFromCell && cell.isNormal)) && border === 'b') {\n                            cell.context = 'ns-resize';\n                            cell.dragContext = 'ns-resize';\n                            return cell;\n                        }\n                        if (!(cell.isRowHeader || cell.isCorner) && moveBorder) {\n                            cell.context = yBorderBehavior;\n                            cell.dragContext = border + '-move';\n                            return cell;\n                        }\n                    }\n                    if (cell.style === 'columnHeaderCell') {\n                        cell.context = 'cell';\n                        cell.dragContext = 'column-reorder';\n                        return cell;\n                    }\n                    if (cell.style === 'rowHeaderCell') {\n                        if ((self.attributes.rowGrabZoneSize + (cell.y - self.style.cellBorderWidth) < y)\n                                || !self.attributes.allowRowReordering) {\n                            cell.dragContext = 'cell';\n                            cell.context = 'cell';\n                        } else {\n                            cell.context = self.cursorGrab;\n                            cell.dragContext = 'row-reorder';\n                        }\n                        return cell;\n                    }\n                    if (cell.isGrid) {\n                        self.hasFocus = false;\n                        cell.dragContext = 'cell-grid';\n                        cell.context = 'cell-grid';\n                        return cell;\n                    }\n                    if (cell.style === 'tree-grid') {\n                        self.hasFocus = false;\n                        cell.dragContext = 'tree';\n                        cell.context = 'tree';\n                        return cell;\n                    }\n                    cell.dragContext = 'cell';\n                    cell.context = 'cell';\n                    return cell;\n                }\n            }\n            self.hasFocus = true;\n            self.cursor = 'default';\n            return {\n                dragContext: 'background',\n                context: 'background',\n                style: 'background',\n                isBackground: true\n            };\n        };\n        /**\n         * Gets the bounds of current selection. \n         * @returns {rect} selection.\n         * @memberof canvasDatagrid\n         * @name getSelectionBounds\n         * @method\n         */\n        self.getSelectionBounds = function () {\n            var low = {x: Infinity, y: Infinity},\n                high = {x: -Infinity, y: -Infinity};\n            self.data.forEach(function (row, rowIndex) {\n                var maxCol, minCol;\n                if (self.selections[rowIndex] && self.selections[rowIndex].length) {\n                    low.y = rowIndex < low.y ? rowIndex : low.y;\n                    high.y = rowIndex > high.y ? rowIndex : high.y;\n                    maxCol = Math.max.apply(null, self.selections[rowIndex]);\n                    minCol = Math.min.apply(null, self.selections[rowIndex]);\n                    low.x = minCol < low.x ? minCol : low.x;\n                    high.x = maxCol > high.x ? maxCol : high.x;\n                }\n            });\n            return {\n                top: low.y,\n                left: low.x,\n                bottom: high.y,\n                right: high.x\n            };\n        };\n        /**\n         * Returns an auto generated schema based on data structure.\n         * @memberof canvasDatagrid\n         * @name getSchemaFromData\n         * @method\n         * @tutorial schema\n         * @returns {schema} schema A schema based on the first item in the data array.\n         */\n        self.getSchemaFromData = function () {\n            return Object.keys(self.data[0] || {' ': ''}).map(function mapEachSchemaColumn(key, index) {\n                var type = self.getBestGuessDataType(key),\n                    i = {\n                        name: key,\n                        title: isNaN(parseInt(key, 10)) ? key : self.integerToAlpha(key).toUpperCase(),\n                        index: index,\n                        type: type,\n                        filter: self.filter(type)\n                    };\n                if (key === self.uniqueId) {\n                    i.hidden = true;\n                }\n                if (self.storedSettings && self.storedSettings.visibility[i.name] !== undefined) {\n                    i.hidden = !self.storedSettings.visibility[i.name];\n                }\n                i[self.uniqueId] = self.getSchemaNameHash(key);\n                return i;\n            });\n        };\n        /**\n         * Clears the change log grid.changes that keeps track of changes to the data set.\n         * This does not undo changes or alter data it is simply a convince array to keep\n         * track of changes made to the data since last this method was called.\n         * @memberof canvasDatagrid\n         * @name clearChangeLog\n         * @method\n         */\n        self.clearChangeLog = function () {\n            self.changes = [];\n        };\n        /**\n         * Selects an area of the grid.\n         * @memberof canvasDatagrid\n         * @name selectArea\n         * @method\n         * @param {rect} bounds A rect object representing the selected values.\n         */\n        self.selectArea = function (bounds, ctrl) {\n            self.selectionBounds = bounds || self.selectionBounds;\n            var x, y, s = self.getSchema();\n            if (!ctrl) {\n                self.selections = [];\n            }\n            if (self.selectionBounds.top < -1\n                    || self.selectionBounds.bottom > self.data.length\n                    || self.selectionBounds.left < -1\n                    || self.selectionBounds.right > s.length) {\n                throw new Error('Impossible selection area');\n            }\n            for (x = self.selectionBounds.top; x <= self.selectionBounds.bottom; x += 1) {\n                self.selections[x] = [];\n                for (y = self.selectionBounds.left; y <= self.selectionBounds.right; y += 1) {\n                    if (self.selections[x].indexOf(y) === -1) {\n                        self.selections[x].push(y);\n                    }\n                }\n            }\n            self.dispatchEvent('selectionchanged', {\n                selectedData: self.getSelectedData(),\n                selections: self.selections,\n                selectionBounds: self.selectionBounds\n            });\n        };\n        /**\n         * Returns the maximum text width for a given column by column name.\n         * @memberof canvasDatagrid\n         * @name findColumnMaxTextLength\n         * @method\n         * @returns {number} The number of pixels wide the maximum width value in the selected column.\n         * @param {string} name The name of the column to calculate the value's width of.\n         */\n        self.findColumnMaxTextLength = function (name) {\n            var m = -Infinity;\n            if (name === 'cornerCell') {\n                self.ctx.font = self.style.rowHeaderCellFont;\n                return self.ctx.measureText((self.data.length + (self.attributes.showNewRow ? 1 : 0)).toString()).width\n                    + self.style.autosizePadding + self.style.autosizeHeaderCellPadding\n                    + self.style.rowHeaderCellPaddingRight\n                    + self.style.rowHeaderCellPaddingLeft\n                    + (self.attributes.tree ? self.style.treeArrowWidth\n                        + self.style.treeArrowMarginLeft + self.style.treeArrowMarginRight : 0);\n            }\n            self.getSchema().forEach(function (col) {\n                if (col.name !== name) { return; }\n                self.ctx.font = self.style.columnHeaderCellFont;\n                var t = self.ctx.measureText(col.title || col.name).width\n                    + self.style.headerCellPaddingRight\n                    + self.style.headerCellPaddingLeft;\n                m = t > m ? t : m;\n            });\n            self.data.forEach(function (row) {\n                self.ctx.font = self.style.cellFont;\n                var t = self.ctx.measureText(row[name]).width\n                    + self.style.cellPaddingRight\n                    + self.style.cellPaddingLeft + self.style.cellAutoResizePadding;\n                m = t > m ? t : m;\n            });\n            return m;\n        };\n        /**\n         * Gets the total width of all header columns.\n         * @memberof canvasDatagrid\n         * @name getHeaderWidth\n         * @method\n         */\n        self.getHeaderWidth = function () {\n            return self.getVisibleSchema().reduce(function (total, header) {\n                return total + (header.width || self.style.cellWidth);\n            }, 0);\n        };\n        self.formatters.string = function cellFormatterString(e) {\n            return e.cell.value !== undefined ? e.cell.value : '';\n        };\n        self.formatters.rowHeaderCell = self.formatters.string;\n        self.formatters.headerCell = self.formatters.string;\n        self.formatters.number = self.formatters.string;\n        self.formatters.int = self.formatters.string;\n        self.formatters.html = self.formatters.string;\n        self.sorters.string = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (a[columnName] === undefined || a[columnName] === null) {\n                    return 1;\n                }\n                if (b[columnName] === undefined || b[columnName] === null) {\n                    return 0;\n                }\n                if (asc) {\n                    if (!a[columnName].localeCompare) { return 1; }\n                    return a[columnName].localeCompare(b[columnName]);\n                }\n                if (!b[columnName].localeCompare) { return 1; }\n                return b[columnName].localeCompare(a[columnName]);\n            };\n        };\n        self.sorters.number = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (asc) {\n                    return a[columnName] - b[columnName];\n                }\n                return b[columnName] - a[columnName];\n            };\n        };\n        self.sorters.date = function (columnName, direction) {\n            var asc = direction === 'asc';\n            return function (a, b) {\n                if (asc) {\n                    return new Date(a[columnName]).getTime()\n                        - new Date(b[columnName]).getTime();\n                }\n                return new Date(b[columnName]).getTime()\n                        - new Date(a[columnName]).getTime();\n            };\n        };\n    };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/publicMethods.js\n// module id = 9\n// module chunks = 0"],"sourceRoot":""}