{"version":3,"sources":["webpack:///./node_modules/devextreme/data/odata/query_adapter.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/util/util.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/devextreme/data/data_source.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./src/shared/customStoreFactory.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/devextreme/data/odata/utils.js","webpack:///./node_modules/builtin-status-codes/browser.js","webpack:///./node_modules/devextreme/data/proxy_url_formatter.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/stream-http/lib/request.js","webpack:///./node_modules/@devexpress/dx-core/dist/dx-core.es.js","webpack:///./node_modules/@devexpress/dx-vue-core/dist/dx-vue-core.es.js","webpack:///./node_modules/@devexpress/dx-grid-core/dist/dx-grid-core.es.js","webpack:///./node_modules/@devexpress/dx-vue-grid/dist/dx-vue-grid.es.js","webpack:///./node_modules/@devexpress/dx-vue-grid-bootstrap4/dist/dx-vue-grid-bootstrap4.es.js","webpack:///./node_modules/stream-http/index.js","webpack:///./node_modules/stream-http/lib/capability.js","webpack:///./node_modules/querystring-es3/index.js","webpack:///./node_modules/devextreme/data/odata/store.js","webpack:///./node_modules/stream-http/lib/response.js","webpack:///./node_modules/devextreme/data/odata/mixins.js","webpack:///./node_modules/util/support/isBufferBrowser.js","webpack:///./node_modules/to-arraybuffer/index.js","webpack:///./node_modules/querystring-es3/encode.js"],"names":["typeUtils","iteratorUtils","config","extend","queryAdapters","odataUtils","serializePropName","errors","dataUtils","isFunction","DEFAULT_PROTOCOL_VERSION","compileCriteria","protocolVersion","forceLowerCase","fieldTypes","createBinaryOperationFormatter","op","prop","val","createStringFuncFormatter","reverse","bag","indexOf","toLowerCase","push","join","formatters","startswith","endswith","formattersV2","contains","notcontains","formattersV4","compileBinary","criteria","normalizeBinaryCriterion","formatter","Error","fieldName","value","convertPrimitiveValue","serializeValue","compileUnary","crit","compileCore","compileGroup","groupOperator","nextGroupOperator","each","index","criterion","Array","isArray","length","isConjunctiveOperator","this","isUnaryOperation","version","types","filterToLower","isDefined","oDataFilterToLower","createODataQueryAdapter","queryOptions","_select","_skip","_take","_countQuery","_sorting","_criteria","_expand","expand","_oDataVersion","hasSlice","hasFunction","i","requestData","result","$orderby","$skip","$top","$select","generateSelect","$expand","generateExpand","$filter","requireTotalCount","$inlinecount","$count","tryLiftSelect","tasks","selectIndex","name","args","nextTask","optimize","exec","url","sendRequest","params","beforeSend","jsonp","withCredentials","countOnly","deserializeDates","isPaged","isFinite","multiSort","rules","rule","getter","desc","slice","skipCount","takeCount","filter","call","arguments","select","expr","count","odata","exports","punycode","util","Url","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","protocolPattern","portPattern","simplePathPattern","delims","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","isObject","u","obj","isString","prototype","source","relative","TypeError","queryIndex","splitter","uSplit","split","slashRegex","replace","rest","trim","simplePath","substr","proto","lowerProto","match","atSign","hostEnd","hec","lastIndexOf","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","j","k","charCodeAt","validParts","notHost","bit","unshift","toASCII","p","h","ae","esc","encodeURIComponent","escape","qm","s","Object","keys","stringify","charAt","rel","tkeys","tk","tkey","rkeys","rk","rkey","v","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","splice","isAbsolute","root","nodeType","module","freeGlobal","global","window","self","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","baseMinusTMin","floor","Math","stringFromCharCode","String","fromCharCode","error","type","RangeError","map","array","fn","mapDomain","string","parts","labels","encoded","ucs2decode","extra","output","counter","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","decode","input","out","basic","oldi","w","t","baseMinusT","inputLength","n","bias","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","toUnicode","test","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","f","objects","inspect","len","str","x","Number","JSON","_","deprecate","msg","process","noDeprecation","apply","warned","deprecated","throwDeprecation","traceDeprecation","console","trace","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","arrayToHash","forEach","idx","recurseTimes","constructor","ret","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","RegExp","toString","isDate","Date","braces","toUTCString","formatArray","key","formatProperty","reduceToSingleString","simple","isNumber","hasOwnProperty","get","set","line","reduce","prev","cur","numLinesEst","ar","arg","isSymbol","re","objectToString","d","e","isPrimitive","o","pad","debuglog","NODE_DEBUG","toUpperCase","pid","isBuffer","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","log","inherits","origin","add","kCustomPromisifiedSymbol","Symbol","undefined","callbackifyOnRejected","reason","cb","newReason","callbackify","original","callbackified","maybeCb","then","nextTick","rej","setPrototypeOf","getPrototypeOf","defineProperties","promisify","defineProperty","enumerable","writable","configurable","promiseResolve","promiseReject","promise","Promise","reject","err","custom","DataSource","default","target","$","JQuery","customStoreFactory","customStore","loadUrl","totalCountUrl","insertUrl","updateUrl","removeUrl","model","_sendRequest","deferred","Deferred","requestSettings","kim","myrouter","router","cache","dataType","contentType","headers","authHeader","async","success","data","Success","Value","Messages","Message","jqXHR","textStatus","errorThrown","status","alert","ajax","load","loadOptions","filterOptions","tosinglearray","sortOptions","sort","skip","take","newModel","totalCount","def","done","fail","insert","values","update","remove","init","id","arrayObject","destination","pushtoarray","item","addModelParam","modelName","clearModelParam","clearAllModelParams","webpackPolyfill","paths","children","_typeof","iterator","Class","_Guid","isPlainObject","grep","GUID_REGEX","VERBOSE_DATE_REGEX","ISO8601_DATE_REGEX","JSON_VERBOSE_MIME_TYPE","makeArray","hasDot","text","right","formatISO8601","date","skipZeroTime","skipTimezone","isZeroTime","getMilliseconds","padLeft2","getFullYear","parseISO8601","isoString","getTimezoneOffset","chunks","setFullYear","setMonth","setDate","setHours","setMinutes","setSeconds","fractional","setMilliseconds","isAbsoluteUrl","toAbsoluteUrl","basePath","relativePath","baseParts","stripParams","relativeParts","param","ajaxOptionsForRequest","request","options","method","payload","timeout","isGet","useJsonp","ajaxData","formatPayload","qs","$format","accepts","json","xhrFields","ajaxOptions","always","transformOptions","tuple","interpretJsonFormat","nextUrl","message","XHR_ERROR_UNLOAD","nextData","formatDotNetError","errorObj","currentError","innererror","internalexception","errorFromResponse","response","httpStatus","errorData","requestOptions","errorMessageFromXhr","responseText","errorDetails","customCode","code","interpretVerboseJsonFormat","interpretLightJsonFormat","transformTypes","results","__next","parseInt","__count","EdmLiteral","inherit","ctor","_value","valueOf","canBeGuid","$1","$2","serializeDate","serializeString","propName","serializeValueV4","serializeValueV2","serializeKey","keyConverters","Int32","Int64","Guid","Boolean","Single","Decimal","converter","oDataVersion","generatorV2","generatorV4","formatCore","selectValue","expandValue","parseTree","exprs","stepper","parseCore","exprParts","node","domAdapter","getWindow","callOnce","DXPROXY_HOST","urlMapping","getUrlParser","a","createElement","props","normalizePath","parseUrl","urlParser","extractProxyAppId","location","isProxyUsed","formatProxyUrl","localUrl","urlData","proxyUrlPart","resultUrl","formatLocalUrl","proxyUrl","sep","eq","regexp","maxKeys","kstr","vstr","xs","stream","toArrayBuffer","IncomingMessage","rStates","readyStates","decideMode","preferBinary","useFetch","capability","fetch","mozchunkedarraybuffer","msstream","arraybuffer","vbArray","ClientRequest","Writable","_opts","_body","_headers","setHeader","Buffer","mode","abortController","overrideMimeType","_mode","_fetchTimer","on","_onFinish","statusValid","xhr","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","body","blobConstructor","Blob","buffer","headersList","keyName","signal","controller","AbortController","_fetchAbortController","requestTimeout","setTimeout","emit","abort","credentials","_fetchResponse","_connect","clearTimeout","_xhr","XMLHttpRequest","open","responseType","ontimeout","setRequestHeader","_response","onreadystatechange","readyState","LOADING","DONE","_onXHRProgress","onprogress","onerror","send","_write","chunk","encoding","destroy","end","flushHeaders","setNoDelay","setSocketKeepAlive","__read","r","next","__spread","b","aPosition","position","bPosition","min","insertPlugin","newItem","nextItemIndex","findIndex","targetIndex","alreadyExists","removePlugin","itemIndex","arr","getDependencyError","pluginName","dependencyName","PluginHost","gettersCache","knownKeysCache","validationRequired","plugins","subscriptions","Set","ensureDependencies","defined","knownOptionals","Map","plugin","container","has","dependencies","dependency","optional","registerPlugin","cleanPluginsCache","unregisterPlugin","knownKeys","postfix","from","endsWith","acc","collect","upTo","_this","upToIndex","pluginIndex","registerSubscription","subscription","unregisterSubscription","delete","broadcast","event","shallowEqual","objA","objB","keysA","keysB","hasOwn","valA","valB","processPattern","pattern","getMessagesFormatter","messages","PLUGIN_HOST_CONTEXT","POSITION_CONTEXT","TEMPLATE_HOST_CONTEXT","RERENDER_TEMPLATE_EVENT","UPDATE_CONNECTION_EVENT","toConsumableArray","assign","arr2","PluginIndexerContext","Function","required","provide","render","$slots","PluginIndexer","inject","child","componentOptions","childPosition","calculatedPosition","attrs","DxTemplatePlaceholder","inheritAttrs","templateHost","computedParams","computedTemplates","pluginHost","templates","created","_this2","$forceUpdate","beforeMount","computed","that","$attrs","$listeners","$scopedSlots","_this3","template","predicate","content","destroyed","DxPluginHost","beforeCreate","DxPlugin","beforeUpdate","beforeDestroy","getAvailableGetters","getGetterValue","getterName","trackedDependencies","getters","Proxy","boxedGetter","ownKeys","prevTrackedDependencies","getAvailableActions","getAction","actionName","actions","DxAction","action","_getAvailableGetters","nextParams","newParams","nextAction","GLOBAL_SHIFT","globalGetterId","DxGetter","globalId","internalId","generateId","lastComputed","lastTrackedDependencies","lastResult","unwatch","_undefined","_x","$watch","newValue","immediate","methods","watch","globalTemplateId","DxTemplate","updated","DxTemplateConnector","updateConnection","GRID_GROUP_TYPE","GRID_GROUP_CHECK","warnIfRowIdUndefined","getRowId","row","warn","rowIdGetter","rows","map_1","rowIndex","defaultGetCellValue","columnName","cellValueGetter","getCellValue","columns","useFastAccessor","column","changeColumnSorting","state","_a","direction","keepOther","sortIndex","sorting","nextSorting","columnSortingIndex","columnSorting","newColumnSorting","newIndexFallback","newIndex","__assign","unique","getColumnSortingDirection","getPersistentSortedColumns","columnExtensions","sortingEnabled","sortItem","calculateKeepOther","persistentSortedColumns","NODE_CHECK","rowsToTree","getRowLevelKey","levels","levelKey","levelIndex","level","treeToRows","tree","changeColumnFilter","filters","filterIndex","nextState","getColumnFilterConfig","filterExpression","expression","selfFilterExpr","operator","operators","or","predicates","and","operationPredicates","notContains","startsWith","equal","notEqual","greaterThan","greaterThanOrEqual","lessThan","lessThanOrEqual","defaultFilterPredicate","operation","filterTree","filteredChildren","filterHierarchicalRows","getCollapsedRows","collapsedRowsMeta","filteredTree","isNode","collapsedRows","filteredCollapsedRows","buildPredicate","initialFilterExpression","getColumnPredicate","getSimplePredicate","customPredicate","getOperatorPredicate","build","getPredicate","filteredRows","filteredCollapsedRowsGetter","unwrappedFilteredRows","GROUP_KEY_SEPARATOR","applyColumnGrouping","grouping","groupIndex","nextGrouping","groupingIndex","g","changeColumnGrouping","_b","expandedGroups","ungroupedColumnIndex","group","filteredExpandedGroups","toggleExpandedGroups","groupKey","groupKeyIndex","adjustSortIndex","max","columnGrouping","groupingPanelItems","draftGrouping","items","find","c","draft","some","startEditRows","prevEditingRowIds","rowIds","stopEditRows","rowIdSet","addRow","addedRows","changeAddedRow","rowId","change","cancelAddedRows","indexSet","changeRow","prevRowChanges","prevChange","cancelChanges","deleteRows","deletedRowIds","cancelDeletedRows","changedRowsByIds","changes","addedRowsByIds","defaultCreateRowChange","createRowChangeGetter","createRowChange","columnExtension","TABLE_DATA_TYPE","TABLE_NODATA_TYPE","TABLE_FLEX_TYPE","TABLE_EDIT_COMMAND_TYPE","TABLE_ADDED_TYPE","TABLE_EDIT_TYPE","TABLE_HEADING_TYPE","isHeadingEditCommandsTableCell","tableRow","tableColumn","isEditCommandsTableCell","tableColumnsWithEditing","tableColumns","width","isAddedTableRow","isEditTableRow","TABLE_FILTER_TYPE","DEFAULT_FILTER_OPERATIONS","isFilterTableCell","isFilterTableRow","getColumnFilterOperations","getAvailableFilterOperations","isFilterValueEmpty","tableHeaderRowsWithFilter","headerRows","rowHeight","height","TABLE_GROUP_TYPE","getGroupIndexByColumn","isGroupTableCell","groupedBy","isGroupIndentTableCell","rowGroupIndex","columnGroupIndex","isGroupTableRow","tableColumnsWithDraftGrouping","showColumnWhenGrouped","columnGroupingExists","columnDraftGroupingExists","tableColumnsWithGrouping","indentColumnWidth","groupedColumn","tableRowsWithGrouping","tableRows","isGroupRow","compoundKey","tableGroupCellColSpanGetter","getTableCellColSpan","isHeadingTableCell","isHeadingTableRow","tableRowsWithHeading","TABLE_SELECT_TYPE","isSelectTableCell","isSelectAllTableCell","tableColumnsWithSelection","selectionColumnWidth","isDataTableCell","isHeaderStubTableCell","isDataTableRow","isNoDataTableRow","isNoDataTableCell","getColumnExtension","extension","getColumnExtensionValueGetter","extensionName","defaultValue","extensionValue","tableColumnsWithDataRows","align","wordWrapEnabled","tableRowsWithDataRows","isRemoteRowsLoading","dataIndex","tableCellColSpanGetter","visibleTableColumns","hiddenColumnNames","tableDataColumnsExist","toggleColumn","hiddenColumn","isTreeTableCell","forColumnName","GridCore","POSITIVE_INFINITY","NEGATIVE_INFINITY","rootComponent","Root","DxGrid","functional","context","nestRE","babelHelperVueJsxMergeProps","objs","aa","bb","nestedKey","temp","mergeFn","objectWithoutProperties","RowPlaceholder","sliceIterator","_arr","_n","_d","_e","_s","_i","$props","CellPlaceholder","colSpan","rowSpan","_ref","DxTable","layoutComponent","tableComponent","headComponent","bodyComponent","containerComponent","cellComponent","rowComponent","stubRowComponent","stubCellComponent","stubHeaderCellComponent","noDataRowComponent","noDataCellComponent","Layout","Cell","Row","NoDataRow","NoDataCell","StubRow","StubCell","StubHeaderCell","getMessage","tableColumnsComputed","_ref2","_ref3","_ref3$getters","tableHeaderRows","bodyRows","tableBodyRows","getCellColSpan","_ref4","listeners","_ref5","_ref6","_ref6$attrs","_ref7","_ref8","_ref9","_ref10","_ref11","_ref12","slots","_ref13","_ref14","_ref15","_ref16","pluginDependencies","DxTableHeaderRow","showSortingControls","showGroupingControls","HeaderCell","HeaderRow","_ref2$attrs","_ref4$getters","isColumnSortingEnabled","isColumnGroupingEnabled","_ref4$actions","changeColumnSorting$$1","changeColumnGrouping$$1","atLeastOneDataColumn","groupingEnabled","sortingDirection","slot","TableLayout","minColumnWidth","getColumns","isFixedWidth","minWidth","ColumnGroup","getRowStyle","RowLayout","getColSpan","RowsBlockLayout","blockComponent","Block","StaticTableLayout","Table","Container","filterExpressionValue","pluginDependencies$2","DxIntegratedFiltering","rowsComputed","filterExpression$$1","defaultPredicate","pluginDependencies$3","prevGrouping","prevGroupingIndex","columnExtensionValueGetter$1","pluginDependencies$6","tableBodyRowsComputed$1","showColumnWhenGroupedGetter","showColumnsWhenGrouped","showWhenGrouped","columnExtensionValueGetter$2","pluginDependencies$d","pluginDependencies$g","columnExtensionValueGetter$3","GridRoot","DxGrid$1","components","DxRoot","MINIMAL_COLUMN_WIDTH","TableLayout$1","TableContainer","use","backgroundColor","mounted","checkStyles","document","getElementsByTagName","_window$getComputedSt","getComputedStyle","TableHead","TableBody","TableRow","TableCell","TableNoDataCell","className","TableStubRow","TableHeaderStubCell","TableStubCell","defaultMessages","noData","DxTable$1","DxContainer","DxTableHead","DxTableBody","DxRow","DxCell","DxNoDataCell","DxNoDataRow","DxStubCell","DxStubHeaderCell","DxStubRow","SortingIndicator","disabled","classes","invisible","ENTER_KEY_CODE","SPACE_KEY_CODE","SortingControl","handleMouseDown","currentTarget","outline","handleBlur","handleClick","emitChange","handleKeyDown","isActionKeyDown","keyCode","cancelSortingRelatedKey","metaKey","ctrlKey","preventDefault","$emit","shiftKey","tabIndex","GroupingControl","invertedAlign","stopPropagation","TableHeaderCell","isCellInteractive","columnTitle","title","scope","before","bind","DxTableHeaderRow$1","offsetX","offsetY","Popover","visible","handleDocumentClick","$el","setElementTranslate","_target$getBoundingCl","getBoundingClientRect","targetHeight","targetWidth","targetLeft","left","_container","popoverWidth","offsetWidth","popoverRight","abs","transform","addEventListener","removeEventListener","popover","ENTER_KEY_CODE$1","SPACE_KEY_CODE$1","isActionKey","ENTER_KEY_CODE$2","SPACE_KEY_CODE$2","expanded","fireToggle","SelectionControl","checked","indeterminate","applyIndeterminate","$refs","onChange","domProps","ref","handleMouseDown$1","handleBlur$1","statusCodes","http","defaultProtocol","req","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","writableStream","WritableStream","ArrayBuffer","getXHR","XDomainRequest","checkTypeSupport","haveArrayBuffer","haveSlice","VBArray","proxyUrlFormatter","Store","mixins","deferredUtils","when","ANONYMOUS_KEY_NAME","expandKeyType","keyType","mergeFieldTypesWithKeyType","field","ODataStore","callBase","_extractServiceOptions","keyTypeIsString","_legacyAnonymousKey","_fieldTypes","_updateMethod","_customLoadOptions","_byKeyImpl","extraOptions","_version","_byKeyUrl","createQuery","adapter","_beforeSend","errorHandler","_errorHandler","_jsonp","_withCredentials","_deserializeDates","urlOverride","_url","_filterToLower","customQueryParams","escapeServiceOperationParams","formatFunctionInvocationUrl","_insertImpl","_requireKey","serverResponse","useLegacyStoreResult","keyOf","_updateImpl","_removeImpl","_convertKey","useOriginalHost","baseUrl","convertedKey","include","SharedMethods","UNSENT","OPENED","HEADERS_RECEIVED","fetchTimer","Readable","rawHeaders","trailers","rawTrailers","statusCode","statusMessage","statusText","write","_resumeFetch","close","pipeTo","catch","reader","getReader","read","_pos","responseURL","getAllResponseHeaders","matches","_charset","mimeType","charsetMatch","_read","responseBody","toArray","newData","Uint8Array","MSStreamReader","byteLength","onload","readAsArrayBuffer","stringUtils","copy","fill","readUInt8","buf","byteOffset","arrayCopy","stringifyPrimitive","objectKeys","ks","res"],"mappings":"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","file":"js/chunk-30210140.54bc38f2.js","sourcesContent":["/**\r\n * DevExtreme (data/odata/query_adapter.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nvar typeUtils = require(\"../../core/utils/type\"),\r\n    iteratorUtils = require(\"../../core/utils/iterator\"),\r\n    config = require(\"../../core/config\"),\r\n    extend = require(\"../../core/utils/extend\").extend,\r\n    queryAdapters = require(\"../query_adapters\"),\r\n    odataUtils = require(\"./utils\"),\r\n    serializePropName = odataUtils.serializePropName,\r\n    errors = require(\"../errors\").errors,\r\n    dataUtils = require(\"../utils\"),\r\n    isFunction = typeUtils.isFunction;\r\nvar DEFAULT_PROTOCOL_VERSION = 2;\r\nvar compileCriteria = function() {\r\n    var protocolVersion, forceLowerCase, fieldTypes;\r\n    var createBinaryOperationFormatter = function(op) {\r\n        return function(prop, val) {\r\n            return prop + \" \" + op + \" \" + val\r\n        }\r\n    };\r\n    var createStringFuncFormatter = function(op, reverse) {\r\n        return function(prop, val) {\r\n            var bag = [op, \"(\"];\r\n            if (forceLowerCase) {\r\n                prop = prop.indexOf(\"tolower(\") === -1 ? \"tolower(\" + prop + \")\" : prop;\r\n                val = val.toLowerCase()\r\n            }\r\n            if (reverse) {\r\n                bag.push(val, \",\", prop)\r\n            } else {\r\n                bag.push(prop, \",\", val)\r\n            }\r\n            bag.push(\")\");\r\n            return bag.join(\"\")\r\n        }\r\n    };\r\n    var formatters = {\r\n        \"=\": createBinaryOperationFormatter(\"eq\"),\r\n        \"<>\": createBinaryOperationFormatter(\"ne\"),\r\n        \">\": createBinaryOperationFormatter(\"gt\"),\r\n        \">=\": createBinaryOperationFormatter(\"ge\"),\r\n        \"<\": createBinaryOperationFormatter(\"lt\"),\r\n        \"<=\": createBinaryOperationFormatter(\"le\"),\r\n        startswith: createStringFuncFormatter(\"startswith\"),\r\n        endswith: createStringFuncFormatter(\"endswith\")\r\n    };\r\n    var formattersV2 = extend({}, formatters, {\r\n        contains: createStringFuncFormatter(\"substringof\", true),\r\n        notcontains: createStringFuncFormatter(\"not substringof\", true)\r\n    });\r\n    var formattersV4 = extend({}, formatters, {\r\n        contains: createStringFuncFormatter(\"contains\"),\r\n        notcontains: createStringFuncFormatter(\"not contains\")\r\n    });\r\n    var compileBinary = function(criteria) {\r\n        criteria = dataUtils.normalizeBinaryCriterion(criteria);\r\n        var op = criteria[1],\r\n            formatters = 4 === protocolVersion ? formattersV4 : formattersV2,\r\n            formatter = formatters[op.toLowerCase()];\r\n        if (!formatter) {\r\n            throw errors.Error(\"E4003\", op)\r\n        }\r\n        var fieldName = criteria[0],\r\n            value = criteria[2];\r\n        if (fieldTypes && fieldTypes[fieldName]) {\r\n            value = odataUtils.convertPrimitiveValue(fieldTypes[fieldName], value)\r\n        }\r\n        return formatter(serializePropName(fieldName), odataUtils.serializeValue(value, protocolVersion))\r\n    };\r\n    var compileUnary = function(criteria) {\r\n        var op = criteria[0],\r\n            crit = compileCore(criteria[1]);\r\n        if (\"!\" === op) {\r\n            return \"not (\" + crit + \")\"\r\n        }\r\n        throw errors.Error(\"E4003\", op)\r\n    };\r\n    var compileGroup = function(criteria) {\r\n        var groupOperator, nextGroupOperator, bag = [];\r\n        iteratorUtils.each(criteria, function(index, criterion) {\r\n            if (Array.isArray(criterion)) {\r\n                if (bag.length > 1 && groupOperator !== nextGroupOperator) {\r\n                    throw new errors.Error(\"E4019\")\r\n                }\r\n                bag.push(\"(\" + compileCore(criterion) + \")\");\r\n                groupOperator = nextGroupOperator;\r\n                nextGroupOperator = \"and\"\r\n            } else {\r\n                nextGroupOperator = dataUtils.isConjunctiveOperator(this) ? \"and\" : \"or\"\r\n            }\r\n        });\r\n        return bag.join(\" \" + groupOperator + \" \")\r\n    };\r\n    var compileCore = function(criteria) {\r\n        if (Array.isArray(criteria[0])) {\r\n            return compileGroup(criteria)\r\n        }\r\n        if (dataUtils.isUnaryOperation(criteria)) {\r\n            return compileUnary(criteria)\r\n        }\r\n        return compileBinary(criteria)\r\n    };\r\n    return function(criteria, version, types, filterToLower) {\r\n        fieldTypes = types;\r\n        forceLowerCase = typeUtils.isDefined(filterToLower) ? filterToLower : config().oDataFilterToLower;\r\n        protocolVersion = version;\r\n        return compileCore(criteria)\r\n    }\r\n}();\r\nvar createODataQueryAdapter = function(queryOptions) {\r\n    var _select, _skip, _take, _countQuery, _sorting = [],\r\n        _criteria = [],\r\n        _expand = queryOptions.expand,\r\n        _oDataVersion = queryOptions.version || DEFAULT_PROTOCOL_VERSION;\r\n    var hasSlice = function() {\r\n        return _skip || void 0 !== _take\r\n    };\r\n    var hasFunction = function hasFunction(criterion) {\r\n        for (var i = 0; i < criterion.length; i++) {\r\n            if (isFunction(criterion[i])) {\r\n                return true\r\n            }\r\n            if (Array.isArray(criterion[i]) && hasFunction(criterion[i])) {\r\n                return true\r\n            }\r\n        }\r\n        return false\r\n    };\r\n    var requestData = function() {\r\n        var result = {};\r\n        if (!_countQuery) {\r\n            if (_sorting.length) {\r\n                result.$orderby = _sorting.join(\",\")\r\n            }\r\n            if (_skip) {\r\n                result.$skip = _skip\r\n            }\r\n            if (void 0 !== _take) {\r\n                result.$top = _take\r\n            }\r\n            result.$select = odataUtils.generateSelect(_oDataVersion, _select) || void 0;\r\n            result.$expand = odataUtils.generateExpand(_oDataVersion, _expand, _select) || void 0\r\n        }\r\n        if (_criteria.length) {\r\n            var criteria = _criteria.length < 2 ? _criteria[0] : _criteria,\r\n                fieldTypes = queryOptions && queryOptions.fieldTypes,\r\n                filterToLower = queryOptions && queryOptions.filterToLower;\r\n            result.$filter = compileCriteria(criteria, _oDataVersion, fieldTypes, filterToLower)\r\n        }\r\n        if (_countQuery) {\r\n            result.$top = 0\r\n        }\r\n        if (queryOptions.requireTotalCount || _countQuery) {\r\n            if (4 !== _oDataVersion) {\r\n                result.$inlinecount = \"allpages\"\r\n            } else {\r\n                result.$count = \"true\"\r\n            }\r\n        }\r\n        return result\r\n    };\r\n\r\n    function tryLiftSelect(tasks) {\r\n        var selectIndex = -1;\r\n        for (var i = 0; i < tasks.length; i++) {\r\n            if (\"select\" === tasks[i].name) {\r\n                selectIndex = i;\r\n                break\r\n            }\r\n        }\r\n        if (selectIndex < 0 || !isFunction(tasks[selectIndex].args[0])) {\r\n            return\r\n        }\r\n        var nextTask = tasks[1 + selectIndex];\r\n        if (!nextTask || \"slice\" !== nextTask.name) {\r\n            return\r\n        }\r\n        tasks[1 + selectIndex] = tasks[selectIndex];\r\n        tasks[selectIndex] = nextTask\r\n    }\r\n    return {\r\n        optimize: function(tasks) {\r\n            tryLiftSelect(tasks)\r\n        },\r\n        exec: function(url) {\r\n            return odataUtils.sendRequest(_oDataVersion, {\r\n                url: url,\r\n                params: extend(requestData(), queryOptions && queryOptions.params)\r\n            }, {\r\n                beforeSend: queryOptions.beforeSend,\r\n                jsonp: queryOptions.jsonp,\r\n                withCredentials: queryOptions.withCredentials,\r\n                countOnly: _countQuery,\r\n                deserializeDates: queryOptions.deserializeDates,\r\n                fieldTypes: queryOptions.fieldTypes,\r\n                isPaged: isFinite(_take)\r\n            })\r\n        },\r\n        multiSort: function(args) {\r\n            var rules;\r\n            if (hasSlice()) {\r\n                return false\r\n            }\r\n            for (var i = 0; i < args.length; i++) {\r\n                var rule, getter = args[i][0],\r\n                    desc = !!args[i][1];\r\n                if (\"string\" !== typeof getter) {\r\n                    return false\r\n                }\r\n                rule = serializePropName(getter);\r\n                if (desc) {\r\n                    rule += \" desc\"\r\n                }\r\n                rules = rules || [];\r\n                rules.push(rule)\r\n            }\r\n            _sorting = rules\r\n        },\r\n        slice: function(skipCount, takeCount) {\r\n            if (hasSlice()) {\r\n                return false\r\n            }\r\n            _skip = skipCount;\r\n            _take = takeCount\r\n        },\r\n        filter: function(criterion) {\r\n            if (hasSlice()) {\r\n                return false\r\n            }\r\n            if (!Array.isArray(criterion)) {\r\n                criterion = [].slice.call(arguments)\r\n            }\r\n            if (hasFunction(criterion)) {\r\n                return false\r\n            }\r\n            if (_criteria.length) {\r\n                _criteria.push(\"and\")\r\n            }\r\n            _criteria.push(criterion)\r\n        },\r\n        select: function(expr) {\r\n            if (_select || isFunction(expr)) {\r\n                return false\r\n            }\r\n            if (!Array.isArray(expr)) {\r\n                expr = [].slice.call(arguments)\r\n            }\r\n            _select = expr\r\n        },\r\n        count: function() {\r\n            _countQuery = true\r\n        }\r\n    }\r\n};\r\nqueryAdapters.odata = createODataQueryAdapter;\r\nexports.odata = createODataQueryAdapter;\r\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","/**\r\n * DevExtreme (data/data_source.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nmodule.exports = require(\"./data_source/data_source\").DataSource;\r\nmodule.exports.default = module.exports;\r\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","\nimport JQuery from 'jquery'\nimport { authHeader} from \"../_helpers\";\nimport router from '../router/index'\n\n\n\n  let $ = JQuery\n\nexport function dummyfunktiondervirker()\n{\n  alert('dette er en test');\n}\n\nexport function customStoreFactory() {\n        var customStore = {\n          key: '',\n\n          url: '',\n          loadUrl: '/', // default base url for GET (load)\n          totalCountUrl: '/', // default base url for GET (totalCount)\n          insertUrl: '/', // default base url for POST (insert)\n          updateUrl: '/', // default base url for PUT (update)\n          removeUrl: '/', // default base url for DELETE (remove)\n          model: {},\n          _sendRequest: function (type, url, params) {\n            var deferred = new $.Deferred();\n            var requestSettings = {\n              url: url,\n              type: type,\n              kim:\"ewwew\",\n              myrouter:router,\n              cache: false,\n              dataType: 'json',\n              contentType: 'application/json; charset=utf-8',\n              headers: authHeader(),\n\n              async: true,\n              success: function (data) {\n                if (data.Success)\n                  deferred.resolve(data.Value);\n                else\n                {\n\n                deferred.reject(data.Messages[0].Message);\n                }\n\n\n              },\n              error: function (jqXHR, textStatus, errorThrown) {\n                if (jqXHR.status==401)\n                {\n                  // unauthorized access\n                  //alert(\"unauthorized access\");\n\n\n                  this.myrouter.push({ name: \"Login\" });\n                }\n                else if (jqXHR.status==404)\n                {\n                  // unauthorized access\n                  alert(\"Page not found\");\n\n\n                  this.myrouter.push({ name: \"Login\" });\n                }\n                else\n                {\n                  alert(textStatus);\n\n                }\n\n                deferred.reject();\n              }\n            };\n            if (params) {\n              if (type == 'DELETE') {\n                if (requestSettings.url[requestSettings.url.length - 1] != '/')\n                  requestSettings.url += '/';\n                requestSettings.url += params.toString();\n              }\n              else\n                requestSettings.data = params;\n            }\n            $.ajax(requestSettings);\n            return deferred;\n          },\n          load: function (loadOptions) {\n            var params = {\n              filterOptions: loadOptions.filter ? customStore.tosinglearray(loadOptions.filter) : null,   //Getting filter options\n              sortOptions: loadOptions.sort,  //Getting sort options\n              //skip and take are used for paging\n              skip: loadOptions.skip, //A number of records that should be skipped\n              take: loadOptions.take //A number of records that should be taken\n            };\n            var newModel = $.extend({}, customStore.model);\n            newModel['options'] = params;\n            return customStore._sendRequest('GET', customStore.loadUrl, JSON.stringify(newModel));\n          },\n          totalCount: function (loadOptions) {\n            var params = {\n              filterOptions: loadOptions.filter ? customStore.tosinglearray(loadOptions.filter) : null   //Getting filter options\n            };\n            var newModel = $.extend({}, customStore.model);\n            newModel['options'] = params;\n            var def = $.Deferred();\n            customStore._sendRequest('POST', customStore.totalCountUrl, JSON.stringify(newModel)).done(function (result) {\n              def.resolve(result.totalCount);\n            })\n              .fail(function (jqXHR, textStatus, errorThrown) {\n\n                def.reject();\n              });\n            return def.promise();\n          },\n          insert: function (values) {\n            return customStore._sendRequest('POST', customStore.insertUrl, JSON.stringify(values));\n          },\n          update: function (key, values) {\n            var params = $.extend({}, values);\n            params[customStore.key] = key;\n            return customStore._sendRequest('PUT', customStore.updateUrl, JSON.stringify(params));\n          },\n          remove: function (key) {\n            return customStore._sendRequest('DELETE', customStore.removeUrl, key);\n          },\n          init: function (id, loadUrl, totalCountUrl, insertUrl, updateUrl, removeUrl) {\n            this.myrouter=router;\n            this.key = id;\n            if (insertUrl === undefined && updateUrl === undefined && removeUrl === undefined)\n              this.url = loadUrl;\n            this.loadUrl = loadUrl;\n            this.totalCountUrl = loadUrl;\n            this.insertUrl = loadUrl;\n            this.updateUrl = loadUrl;\n            this.removeUrl = loadUrl;\n            if (totalCountUrl != null)\n              this.totalCountUrl = totalCountUrl;\n            if (insertUrl != null)\n              this.insertUrl = insertUrl;\n            if (updateUrl != null)\n              this.updateUrl = updateUrl;\n            if (removeUrl != null)\n              this.removeUrl = removeUrl;\n          },\n          tosinglearray: function (arrayObject) {\n            var destination = [];\n            //destination.push('(');\n            customStore.pushtoarray(arrayObject, destination);\n            //destination.push(')');\n            return destination;\n          },\n          pushtoarray: function (arrayObject, destination) {\n            $.each(arrayObject, function (i, item) {\n              if (typeof (item) == 'object' && item != null && item.length && item.length >= 1) {\n                destination.push('(');\n                customStore.pushtoarray(item, destination);\n                destination.push(')');\n              }\n              else\n                destination.push(item);\n            });\n          },\n          addModelParam: function (modelName, model) {\n            customStore.model[modelName] = model;\n          },\n          clearModelParam: function (modelName) {\n            customStore.model[modelName] = null;\n          },\n          clearAllModelParams: function () {\n            customStore.model = {};\n          }\n        };\n        return customStore;\n      };\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/**\r\n * DevExtreme (data/odata/utils.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nvar _typeof = \"function\" === typeof Symbol && \"symbol\" === typeof Symbol.iterator ? function(obj) {\r\n    return typeof obj\r\n} : function(obj) {\r\n    return obj && \"function\" === typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj\r\n};\r\nvar Class = require(\"../../core/class\"),\r\n    extend = require(\"../../core/utils/extend\").extend,\r\n    typeUtils = require(\"../../core/utils/type\"),\r\n    iteratorUtils = require(\"../../core/utils/iterator\"),\r\n    each = require(\"../../core/utils/iterator\").each,\r\n    ajax = require(\"../../core/utils/ajax\"),\r\n    _Guid = require(\"../../core/guid\"),\r\n    isDefined = typeUtils.isDefined,\r\n    isPlainObject = typeUtils.isPlainObject,\r\n    grep = require(\"../../core/utils/common\").grep,\r\n    Deferred = require(\"../../core/utils/deferred\").Deferred,\r\n    errors = require(\"../errors\").errors,\r\n    dataUtils = require(\"../utils\");\r\nvar GUID_REGEX = /^(\\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\\}{0,1})$/;\r\nvar VERBOSE_DATE_REGEX = /^\\/Date\\((-?\\d+)((\\+|-)?(\\d+)?)\\)\\/$/;\r\nvar ISO8601_DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[-+]{1}\\d{2}(:?)(\\d{2})?)?$/;\r\nvar JSON_VERBOSE_MIME_TYPE = \"application/json;odata=verbose\";\r\nvar makeArray = function(value) {\r\n    return \"string\" === typeUtils.type(value) ? value.split() : value\r\n};\r\nvar hasDot = function(x) {\r\n    return /\\./.test(x)\r\n};\r\nvar pad = function(text, length, right) {\r\n    text = String(text);\r\n    while (text.length < length) {\r\n        text = right ? text + \"0\" : \"0\" + text\r\n    }\r\n    return text\r\n};\r\n\r\nfunction formatISO8601(date, skipZeroTime, skipTimezone) {\r\n    var bag = [];\r\n    var isZeroTime = function() {\r\n        return date.getHours() + date.getMinutes() + date.getSeconds() + date.getMilliseconds() < 1\r\n    };\r\n    var padLeft2 = function(text) {\r\n        return pad(text, 2)\r\n    };\r\n    bag.push(date.getFullYear());\r\n    bag.push(\"-\");\r\n    bag.push(padLeft2(date.getMonth() + 1));\r\n    bag.push(\"-\");\r\n    bag.push(padLeft2(date.getDate()));\r\n    if (!(skipZeroTime && isZeroTime())) {\r\n        bag.push(\"T\");\r\n        bag.push(padLeft2(date.getHours()));\r\n        bag.push(\":\");\r\n        bag.push(padLeft2(date.getMinutes()));\r\n        bag.push(\":\");\r\n        bag.push(padLeft2(date.getSeconds()));\r\n        if (date.getMilliseconds()) {\r\n            bag.push(\".\");\r\n            bag.push(pad(date.getMilliseconds(), 3))\r\n        }\r\n        if (!skipTimezone) {\r\n            bag.push(\"Z\")\r\n        }\r\n    }\r\n    return bag.join(\"\")\r\n}\r\n\r\nfunction parseISO8601(isoString) {\r\n    var result = new Date(60 * new Date(0).getTimezoneOffset() * 1e3),\r\n        chunks = isoString.replace(\"Z\", \"\").split(\"T\"),\r\n        date = /(\\d{4})-(\\d{2})-(\\d{2})/.exec(chunks[0]),\r\n        time = /(\\d{2}):(\\d{2}):(\\d{2})\\.?(\\d{0,7})?/.exec(chunks[1]);\r\n    result.setFullYear(Number(date[1]));\r\n    result.setMonth(Number(date[2]) - 1);\r\n    result.setDate(Number(date[3]));\r\n    if (Array.isArray(time) && time.length) {\r\n        result.setHours(Number(time[1]));\r\n        result.setMinutes(Number(time[2]));\r\n        result.setSeconds(Number(time[3]));\r\n        var fractional = (time[4] || \"\").slice(0, 3);\r\n        fractional = pad(fractional, 3, true);\r\n        result.setMilliseconds(Number(fractional))\r\n    }\r\n    return result\r\n}\r\n\r\nfunction isAbsoluteUrl(url) {\r\n    return /^(?:[a-z]+:)?\\/\\//i.test(url)\r\n}\r\n\r\nfunction toAbsoluteUrl(basePath, relativePath) {\r\n    var part;\r\n    var baseParts = stripParams(basePath).split(\"/\");\r\n    var relativeParts = relativePath.split(\"/\");\r\n\r\n    function stripParams(url) {\r\n        var index = url.indexOf(\"?\");\r\n        if (index > -1) {\r\n            return url.substr(0, index)\r\n        }\r\n        return url\r\n    }\r\n    baseParts.pop();\r\n    while (relativeParts.length) {\r\n        part = relativeParts.shift();\r\n        if (\"..\" === part) {\r\n            baseParts.pop()\r\n        } else {\r\n            baseParts.push(part)\r\n        }\r\n    }\r\n    return baseParts.join(\"/\")\r\n}\r\nvar param = function(params) {\r\n    var result = [];\r\n    for (var name in params) {\r\n        result.push(name + \"=\" + params[name])\r\n    }\r\n    return result.join(\"&\")\r\n};\r\nvar ajaxOptionsForRequest = function(protocolVersion, request, options) {\r\n    request = extend({\r\n        async: true,\r\n        method: \"get\",\r\n        url: \"\",\r\n        params: {},\r\n        payload: null,\r\n        headers: {},\r\n        timeout: 3e4\r\n    }, request);\r\n    options = options || {};\r\n    var beforeSend = options.beforeSend;\r\n    if (beforeSend) {\r\n        beforeSend(request)\r\n    }\r\n    var method = (request.method || \"get\").toLowerCase(),\r\n        isGet = \"get\" === method,\r\n        useJsonp = isGet && options.jsonp,\r\n        params = extend({}, request.params),\r\n        ajaxData = isGet ? params : formatPayload(request.payload),\r\n        qs = !isGet && param(params),\r\n        url = request.url,\r\n        contentType = !isGet && JSON_VERBOSE_MIME_TYPE;\r\n    if (qs) {\r\n        url += (url.indexOf(\"?\") > -1 ? \"&\" : \"?\") + qs\r\n    }\r\n    if (useJsonp) {\r\n        ajaxData.$format = \"json\"\r\n    }\r\n    return {\r\n        url: url,\r\n        data: ajaxData,\r\n        dataType: useJsonp ? \"jsonp\" : \"json\",\r\n        jsonp: useJsonp && \"$callback\",\r\n        method: method,\r\n        async: request.async,\r\n        timeout: request.timeout,\r\n        headers: request.headers,\r\n        contentType: contentType,\r\n        accepts: {\r\n            json: [JSON_VERBOSE_MIME_TYPE, \"text/plain\"].join()\r\n        },\r\n        xhrFields: {\r\n            withCredentials: options.withCredentials\r\n        }\r\n    };\r\n\r\n    function formatPayload(payload) {\r\n        return JSON.stringify(payload, function(key, value) {\r\n            if (!(this[key] instanceof Date)) {\r\n                return value\r\n            }\r\n            value = formatISO8601(this[key]);\r\n            switch (protocolVersion) {\r\n                case 2:\r\n                    return value.substr(0, value.length - 1);\r\n                case 3:\r\n                case 4:\r\n                    return value;\r\n                default:\r\n                    throw errors.Error(\"E4002\")\r\n            }\r\n        })\r\n    }\r\n};\r\nvar sendRequest = function sendRequest(protocolVersion, request, options) {\r\n    var d = new Deferred;\r\n    var ajaxOptions = ajaxOptionsForRequest(protocolVersion, request, options);\r\n    ajax.sendRequest(ajaxOptions).always(function(obj, textStatus) {\r\n        var extra, transformOptions = {\r\n                deserializeDates: options.deserializeDates,\r\n                fieldTypes: options.fieldTypes\r\n            },\r\n            tuple = interpretJsonFormat(obj, textStatus, transformOptions, ajaxOptions),\r\n            error = tuple.error,\r\n            data = tuple.data,\r\n            nextUrl = tuple.nextUrl;\r\n        if (error) {\r\n            if (error.message !== dataUtils.XHR_ERROR_UNLOAD) {\r\n                d.reject(error)\r\n            }\r\n        } else {\r\n            if (options.countOnly) {\r\n                if (isFinite(tuple.count)) {\r\n                    d.resolve(tuple.count)\r\n                } else {\r\n                    d.reject(new errors.Error(\"E4018\"))\r\n                }\r\n            } else {\r\n                if (nextUrl && !options.isPaged) {\r\n                    if (!isAbsoluteUrl(nextUrl)) {\r\n                        nextUrl = toAbsoluteUrl(ajaxOptions.url, nextUrl)\r\n                    }\r\n                    sendRequest(protocolVersion, {\r\n                        url: nextUrl\r\n                    }, options).fail(d.reject).done(function(nextData) {\r\n                        d.resolve(data.concat(nextData))\r\n                    })\r\n                } else {\r\n                    if (isFinite(tuple.count)) {\r\n                        extra = {\r\n                            totalCount: tuple.count\r\n                        }\r\n                    }\r\n                    d.resolve(data, extra)\r\n                }\r\n            }\r\n        }\r\n    });\r\n    return d.promise()\r\n};\r\nvar formatDotNetError = function(errorObj) {\r\n    var message, currentError = errorObj;\r\n    if (\"message\" in errorObj) {\r\n        if (errorObj.message.value) {\r\n            message = errorObj.message.value\r\n        } else {\r\n            message = errorObj.message\r\n        }\r\n    }\r\n    while (currentError = currentError.innererror || currentError.internalexception) {\r\n        message = currentError.message;\r\n        if (currentError.internalexception && message.indexOf(\"inner exception\") === -1) {\r\n            break\r\n        }\r\n    }\r\n    return message\r\n};\r\nvar errorFromResponse = function(obj, textStatus, ajaxOptions) {\r\n    if (\"nocontent\" === textStatus) {\r\n        return null\r\n    }\r\n    var message = \"Unknown error\",\r\n        response = obj,\r\n        httpStatus = 200,\r\n        errorData = {\r\n            requestOptions: ajaxOptions\r\n        };\r\n    if (\"success\" !== textStatus) {\r\n        httpStatus = obj.status;\r\n        message = dataUtils.errorMessageFromXhr(obj, textStatus);\r\n        try {\r\n            response = JSON.parse(obj.responseText)\r\n        } catch (x) {}\r\n    }\r\n    var errorObj = response && (response.then && response || response.error || response[\"odata.error\"] || response[\"@odata.error\"]);\r\n    if (errorObj) {\r\n        message = formatDotNetError(errorObj) || message;\r\n        errorData.errorDetails = errorObj;\r\n        if (200 === httpStatus) {\r\n            httpStatus = 500\r\n        }\r\n        var customCode = Number(errorObj.code);\r\n        if (isFinite(customCode) && customCode >= 400) {\r\n            httpStatus = customCode\r\n        }\r\n    }\r\n    if (httpStatus >= 400 || 0 === httpStatus) {\r\n        errorData.httpStatus = httpStatus;\r\n        return extend(Error(message), errorData)\r\n    }\r\n    return null\r\n};\r\nvar interpretJsonFormat = function(obj, textStatus, transformOptions, ajaxOptions) {\r\n    var value, error = errorFromResponse(obj, textStatus, ajaxOptions);\r\n    if (error) {\r\n        return {\r\n            error: error\r\n        }\r\n    }\r\n    if (!isPlainObject(obj)) {\r\n        return {\r\n            data: obj\r\n        }\r\n    }\r\n    if (\"d\" in obj && (Array.isArray(obj.d) || typeUtils.isObject(obj.d))) {\r\n        value = interpretVerboseJsonFormat(obj, textStatus)\r\n    } else {\r\n        value = interpretLightJsonFormat(obj, textStatus)\r\n    }\r\n    transformTypes(value, transformOptions);\r\n    return value\r\n};\r\nvar interpretVerboseJsonFormat = function(obj) {\r\n    var data = obj.d;\r\n    if (!isDefined(data)) {\r\n        return {\r\n            error: Error(\"Malformed or unsupported JSON response received\")\r\n        }\r\n    }\r\n    if (isDefined(data.results)) {\r\n        data = data.results\r\n    }\r\n    return {\r\n        data: data,\r\n        nextUrl: obj.d.__next,\r\n        count: parseInt(obj.d.__count, 10)\r\n    }\r\n};\r\nvar interpretLightJsonFormat = function(obj) {\r\n    var data = obj;\r\n    if (isDefined(data.value)) {\r\n        data = data.value\r\n    }\r\n    return {\r\n        data: data,\r\n        nextUrl: obj[\"@odata.nextLink\"],\r\n        count: parseInt(obj[\"@odata.count\"], 10)\r\n    }\r\n};\r\nvar EdmLiteral = Class.inherit({\r\n    ctor: function(value) {\r\n        this._value = value\r\n    },\r\n    valueOf: function() {\r\n        return this._value\r\n    }\r\n});\r\nvar transformTypes = function transformTypes(obj, options) {\r\n    options = options || {};\r\n    each(obj, function(key, value) {\r\n        if (null !== value && \"object\" === (\"undefined\" === typeof value ? \"undefined\" : _typeof(value))) {\r\n            if (\"results\" in value) {\r\n                obj[key] = value.results\r\n            }\r\n            transformTypes(obj[key], options)\r\n        } else {\r\n            if (\"string\" === typeof value) {\r\n                var fieldTypes = options.fieldTypes,\r\n                    canBeGuid = !fieldTypes || \"String\" !== fieldTypes[key];\r\n                if (canBeGuid && GUID_REGEX.test(value)) {\r\n                    obj[key] = new _Guid(value)\r\n                }\r\n                if (false !== options.deserializeDates) {\r\n                    if (value.match(VERBOSE_DATE_REGEX)) {\r\n                        var date = new Date(Number(RegExp.$1) + 60 * RegExp.$2 * 1e3);\r\n                        obj[key] = new Date(date.valueOf() + 60 * date.getTimezoneOffset() * 1e3)\r\n                    } else {\r\n                        if (ISO8601_DATE_REGEX.test(value)) {\r\n                            obj[key] = new Date(parseISO8601(obj[key]).valueOf())\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    })\r\n};\r\nvar serializeDate = function(date) {\r\n    return \"datetime'\" + formatISO8601(date, true, true) + \"'\"\r\n};\r\nvar serializeString = function(value) {\r\n    return \"'\" + value.replace(/'/g, \"''\") + \"'\"\r\n};\r\nvar serializePropName = function(propName) {\r\n    if (propName instanceof EdmLiteral) {\r\n        return propName.valueOf()\r\n    }\r\n    return propName.replace(/\\./g, \"/\")\r\n};\r\nvar serializeValueV4 = function serializeValueV4(value) {\r\n    if (value instanceof Date) {\r\n        return formatISO8601(value, false, false)\r\n    }\r\n    if (value instanceof _Guid) {\r\n        return value.valueOf()\r\n    }\r\n    if (Array.isArray(value)) {\r\n        return \"[\" + value.map(function(item) {\r\n            return serializeValueV4(item)\r\n        }).join(\",\") + \"]\"\r\n    }\r\n    return serializeValueV2(value)\r\n};\r\nvar serializeValueV2 = function(value) {\r\n    if (value instanceof Date) {\r\n        return serializeDate(value)\r\n    }\r\n    if (value instanceof _Guid) {\r\n        return \"guid'\" + value + \"'\"\r\n    }\r\n    if (value instanceof EdmLiteral) {\r\n        return value.valueOf()\r\n    }\r\n    if (\"string\" === typeof value) {\r\n        return serializeString(value)\r\n    }\r\n    return String(value)\r\n};\r\nvar serializeValue = function(value, protocolVersion) {\r\n    switch (protocolVersion) {\r\n        case 2:\r\n        case 3:\r\n            return serializeValueV2(value);\r\n        case 4:\r\n            return serializeValueV4(value);\r\n        default:\r\n            throw errors.Error(\"E4002\")\r\n    }\r\n};\r\nvar serializeKey = function(key, protocolVersion) {\r\n    if (isPlainObject(key)) {\r\n        var parts = [];\r\n        each(key, function(k, v) {\r\n            parts.push(serializePropName(k) + \"=\" + serializeValue(v, protocolVersion))\r\n        });\r\n        return parts.join()\r\n    }\r\n    return serializeValue(key, protocolVersion)\r\n};\r\nvar keyConverters = {\r\n    String: function(value) {\r\n        return value + \"\"\r\n    },\r\n    Int32: function(value) {\r\n        return Math.floor(value)\r\n    },\r\n    Int64: function(value) {\r\n        if (value instanceof EdmLiteral) {\r\n            return value\r\n        }\r\n        return new EdmLiteral(value + \"L\")\r\n    },\r\n    Guid: function(value) {\r\n        if (value instanceof _Guid) {\r\n            return value\r\n        }\r\n        return new _Guid(value)\r\n    },\r\n    Boolean: function(value) {\r\n        return !!value\r\n    },\r\n    Single: function(value) {\r\n        if (value instanceof EdmLiteral) {\r\n            return value\r\n        }\r\n        return new EdmLiteral(value + \"f\")\r\n    },\r\n    Decimal: function(value) {\r\n        if (value instanceof EdmLiteral) {\r\n            return value\r\n        }\r\n        return new EdmLiteral(value + \"m\")\r\n    }\r\n};\r\nvar convertPrimitiveValue = function(type, value) {\r\n    if (null === value) {\r\n        return null\r\n    }\r\n    var converter = keyConverters[type];\r\n    if (!converter) {\r\n        throw errors.Error(\"E4014\", type)\r\n    }\r\n    return converter(value)\r\n};\r\nvar generateSelect = function(oDataVersion, select) {\r\n    if (!select) {\r\n        return\r\n    }\r\n    if (oDataVersion < 4) {\r\n        return serializePropName(select.join())\r\n    }\r\n    return grep(select, hasDot, true).join()\r\n};\r\nvar generateExpand = function(oDataVersion, expand, select) {\r\n    var generatorV2 = function() {\r\n        var hash = {};\r\n        if (expand) {\r\n            iteratorUtils.each(makeArray(expand), function() {\r\n                hash[serializePropName(this)] = 1\r\n            })\r\n        }\r\n        if (select) {\r\n            iteratorUtils.each(makeArray(select), function() {\r\n                var path = this.split(\".\");\r\n                if (path.length < 2) {\r\n                    return\r\n                }\r\n                path.pop();\r\n                hash[serializePropName(path.join(\".\"))] = 1\r\n            })\r\n        }\r\n        return iteratorUtils.map(hash, function(k, v) {\r\n            return v\r\n        }).join()\r\n    };\r\n    var generatorV4 = function() {\r\n        var format = function(hash) {\r\n            var formatCore = function formatCore(hash) {\r\n                var result = \"\",\r\n                    selectValue = [],\r\n                    expandValue = [];\r\n                iteratorUtils.each(hash, function(key, value) {\r\n                    if (Array.isArray(value)) {\r\n                        [].push.apply(selectValue, value)\r\n                    }\r\n                    if (isPlainObject(value)) {\r\n                        expandValue.push(key + formatCore(value))\r\n                    }\r\n                });\r\n                if (selectValue.length || expandValue.length) {\r\n                    result += \"(\";\r\n                    if (selectValue.length) {\r\n                        result += \"$select=\" + iteratorUtils.map(selectValue, serializePropName).join()\r\n                    }\r\n                    if (expandValue.length) {\r\n                        if (selectValue.length) {\r\n                            result += \";\"\r\n                        }\r\n                        result += \"$expand=\" + iteratorUtils.map(expandValue, serializePropName).join()\r\n                    }\r\n                    result += \")\"\r\n                }\r\n                return result\r\n            };\r\n            var result = [];\r\n            iteratorUtils.each(hash, function(key, value) {\r\n                result.push(key + formatCore(value))\r\n            });\r\n            return result.join()\r\n        };\r\n        var parseTree = function(exprs, root, stepper) {\r\n            var parseCore = function parseCore(exprParts, root, stepper) {\r\n                var result = stepper(root, exprParts.shift(), exprParts);\r\n                if (false === result) {\r\n                    return\r\n                }\r\n                parseCore(exprParts, result, stepper)\r\n            };\r\n            iteratorUtils.each(exprs, function(_, x) {\r\n                parseCore(x.split(\".\"), root, stepper)\r\n            })\r\n        };\r\n        var hash = {};\r\n        if (expand || select) {\r\n            if (expand) {\r\n                parseTree(makeArray(expand), hash, function(node, key, path) {\r\n                    node[key] = node[key] || {};\r\n                    if (!path.length) {\r\n                        return false\r\n                    }\r\n                    return node[key]\r\n                })\r\n            }\r\n            if (select) {\r\n                parseTree(grep(makeArray(select), hasDot), hash, function(node, key, path) {\r\n                    if (!path.length) {\r\n                        node[key] = node[key] || [];\r\n                        node[key].push(key);\r\n                        return false\r\n                    }\r\n                    return node[key] = node[key] || {}\r\n                })\r\n            }\r\n            return format(hash)\r\n        }\r\n    };\r\n    if (oDataVersion < 4) {\r\n        return generatorV2()\r\n    }\r\n    return generatorV4()\r\n};\r\nexports.sendRequest = sendRequest;\r\nexports.serializePropName = serializePropName;\r\nexports.serializeValue = serializeValue;\r\nexports.serializeKey = serializeKey;\r\nexports.keyConverters = keyConverters;\r\nexports.convertPrimitiveValue = convertPrimitiveValue;\r\nexports.generateExpand = generateExpand;\r\nexports.generateSelect = generateSelect;\r\nexports.EdmLiteral = EdmLiteral;\r\n","module.exports = {\n  \"100\": \"Continue\",\n  \"101\": \"Switching Protocols\",\n  \"102\": \"Processing\",\n  \"200\": \"OK\",\n  \"201\": \"Created\",\n  \"202\": \"Accepted\",\n  \"203\": \"Non-Authoritative Information\",\n  \"204\": \"No Content\",\n  \"205\": \"Reset Content\",\n  \"206\": \"Partial Content\",\n  \"207\": \"Multi-Status\",\n  \"208\": \"Already Reported\",\n  \"226\": \"IM Used\",\n  \"300\": \"Multiple Choices\",\n  \"301\": \"Moved Permanently\",\n  \"302\": \"Found\",\n  \"303\": \"See Other\",\n  \"304\": \"Not Modified\",\n  \"305\": \"Use Proxy\",\n  \"307\": \"Temporary Redirect\",\n  \"308\": \"Permanent Redirect\",\n  \"400\": \"Bad Request\",\n  \"401\": \"Unauthorized\",\n  \"402\": \"Payment Required\",\n  \"403\": \"Forbidden\",\n  \"404\": \"Not Found\",\n  \"405\": \"Method Not Allowed\",\n  \"406\": \"Not Acceptable\",\n  \"407\": \"Proxy Authentication Required\",\n  \"408\": \"Request Timeout\",\n  \"409\": \"Conflict\",\n  \"410\": \"Gone\",\n  \"411\": \"Length Required\",\n  \"412\": \"Precondition Failed\",\n  \"413\": \"Payload Too Large\",\n  \"414\": \"URI Too Long\",\n  \"415\": \"Unsupported Media Type\",\n  \"416\": \"Range Not Satisfiable\",\n  \"417\": \"Expectation Failed\",\n  \"418\": \"I'm a teapot\",\n  \"421\": \"Misdirected Request\",\n  \"422\": \"Unprocessable Entity\",\n  \"423\": \"Locked\",\n  \"424\": \"Failed Dependency\",\n  \"425\": \"Unordered Collection\",\n  \"426\": \"Upgrade Required\",\n  \"428\": \"Precondition Required\",\n  \"429\": \"Too Many Requests\",\n  \"431\": \"Request Header Fields Too Large\",\n  \"451\": \"Unavailable For Legal Reasons\",\n  \"500\": \"Internal Server Error\",\n  \"501\": \"Not Implemented\",\n  \"502\": \"Bad Gateway\",\n  \"503\": \"Service Unavailable\",\n  \"504\": \"Gateway Timeout\",\n  \"505\": \"HTTP Version Not Supported\",\n  \"506\": \"Variant Also Negotiates\",\n  \"507\": \"Insufficient Storage\",\n  \"508\": \"Loop Detected\",\n  \"509\": \"Bandwidth Limit Exceeded\",\n  \"510\": \"Not Extended\",\n  \"511\": \"Network Authentication Required\"\n}\n","/**\r\n * DevExtreme (data/proxy_url_formatter.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nvar each = require(\"../core/utils/iterator\").each,\r\n    domAdapter = require(\"../core/dom_adapter\"),\r\n    window = require(\"../core/utils/window\").getWindow(),\r\n    callOnce = require(\"../core/utils/call_once\"),\r\n    DXPROXY_HOST = \"dxproxy.devexpress.com:8000\",\r\n    urlMapping = {};\r\nvar getUrlParser = callOnce(function() {\r\n    var a = domAdapter.createElement(\"a\"),\r\n        props = [\"protocol\", \"hostname\", \"port\", \"pathname\", \"search\", \"hash\"];\r\n    var normalizePath = function(value) {\r\n        if (\"/\" !== value.charAt(0)) {\r\n            value = \"/\" + value\r\n        }\r\n        return value\r\n    };\r\n    return function(url) {\r\n        a.href = url;\r\n        var result = {};\r\n        each(props, function() {\r\n            result[this] = a[this]\r\n        });\r\n        result.pathname = normalizePath(result.pathname);\r\n        return result\r\n    }\r\n});\r\nvar parseUrl = function(url) {\r\n    var urlParser = getUrlParser();\r\n    return urlParser(url)\r\n};\r\nvar extractProxyAppId = function() {\r\n    return window.location.pathname.split(\"/\")[1]\r\n};\r\nmodule.exports = {\r\n    parseUrl: parseUrl,\r\n    isProxyUsed: function() {\r\n        return window.location.host === DXPROXY_HOST\r\n    },\r\n    formatProxyUrl: function(localUrl) {\r\n        var urlData = parseUrl(localUrl);\r\n        if (!/^(localhost$|127\\.)/i.test(urlData.hostname)) {\r\n            return localUrl\r\n        }\r\n        var proxyUrlPart = DXPROXY_HOST + \"/\" + extractProxyAppId() + \"_\" + urlData.port;\r\n        urlMapping[proxyUrlPart] = urlData.hostname + \":\" + urlData.port;\r\n        var resultUrl = \"http://\" + proxyUrlPart + urlData.pathname + urlData.search;\r\n        return resultUrl\r\n    },\r\n    formatLocalUrl: function(proxyUrl) {\r\n        if (proxyUrl.indexOf(DXPROXY_HOST) < 0) {\r\n            return proxyUrl\r\n        }\r\n        var resultUrl = proxyUrl;\r\n        for (var proxyUrlPart in urlMapping) {\r\n            if (Object.prototype.hasOwnProperty.call(urlMapping, proxyUrlPart)) {\r\n                if (proxyUrl.indexOf(proxyUrlPart) >= 0) {\r\n                    resultUrl = proxyUrl.replace(proxyUrlPart, urlMapping[proxyUrlPart]);\r\n                    break\r\n                }\r\n            }\r\n        }\r\n        return resultUrl\r\n    }\r\n};\r\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\nvar toArrayBuffer = require('to-arraybuffer')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else if (capability.vbArray && preferBinary) {\n\t\treturn 'text:vbarray'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n\t\tif (capability.arraybuffer) {\n\t\t\tbody = toArrayBuffer(Buffer.concat(self._body))\n\t\t} else if (capability.blobConstructor) {\n\t\t\tbody = new global.Blob(self._body.map(function (buffer) {\n\t\t\t\treturn toArrayBuffer(buffer)\n\t\t\t}), {\n\t\t\t\ttype: (headersObj['content-type'] || {}).value || ''\n\t\t\t})\n\t\t} else {\n\t\t\t// get utf8 string\n\t\t\tbody = Buffer.concat(self._body).toString()\n\t\t}\n\t}\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tvar fetchTimer = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tglobal.clearTimeout(self._fetchTimer)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode.split(':')[0]\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress()\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {\n\tvar self = this\n\tself._destroyed = true\n\tglobal.clearTimeout(self._fetchTimer)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setTimeout = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","/**\n * Bundle of @devexpress/dx-core\n * Generated: 2019-08-23\n * Version: 1.11.2\n * License: https://js.devexpress.com/Licensing\n */\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nfunction __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\n\nvar DELAY = 200;\r\nvar compare = function (a, b) {\r\n    var aPosition = a.position();\r\n    var bPosition = b.position();\r\n    for (var i = 0; i < Math.min(aPosition.length, bPosition.length); i += 1) {\r\n        if (aPosition[i] < bPosition[i])\r\n            return -1;\r\n        if (aPosition[i] > bPosition[i])\r\n            return 1;\r\n    }\r\n    return aPosition.length - bPosition.length;\r\n};\r\n/** @internal */\r\nvar insertPlugin = function (array, newItem) {\r\n    var result = array.slice();\r\n    var nextItemIndex = array.findIndex(function (item) { return compare(newItem, item) <= 0; });\r\n    var targetIndex = nextItemIndex < 0 ? array.length : nextItemIndex;\r\n    var alreadyExists = (targetIndex >= 0 && targetIndex < array.length)\r\n        && compare(newItem, array[targetIndex]) === 0;\r\n    result.splice(targetIndex, alreadyExists ? 1 : 0, newItem);\r\n    return result;\r\n};\r\n/** @internal */\r\nvar removePlugin = function (array, item) {\r\n    var itemIndex = array.indexOf(item);\r\n    return itemIndex >= 0 ? __spread(array.slice(0, itemIndex), array.slice(itemIndex + 1)) : array;\r\n};\r\n/** @internal */\r\nvar createClickHandlers = function (click, dblClick) {\r\n    var timeoutId;\r\n    var events = {};\r\n    if (click) {\r\n        events.onClick = function (e) {\r\n            if (!timeoutId) {\r\n                timeoutId = setTimeout(function () {\r\n                    clearTimeout(timeoutId);\r\n                    click(e);\r\n                }, DELAY);\r\n            }\r\n        };\r\n    }\r\n    if (dblClick) {\r\n        events.onDoubleClick = function (e) {\r\n            clearTimeout(timeoutId);\r\n            dblClick(e);\r\n        };\r\n    }\r\n    return events;\r\n};\r\n/** @internal */\r\nvar slice = function (arr) { return Array.prototype.slice.call(arr); }; // slice can be renamed to copy as well\r\n/* globals window:true */\r\n/** @internal */\r\nvar isEdgeBrowser = function () { return /Edge/.test(window.navigator.userAgent); };\n\nvar getDependencyError = function (pluginName, dependencyName) { return new Error(\"The '\" + pluginName + \"' plugin requires '\" + dependencyName + \"' to be defined before it.\"); };\r\n/** @internal */\r\nvar PluginHost = /*#__PURE__*/ (function () {\r\n    function PluginHost() {\r\n        this.gettersCache = {};\r\n        this.knownKeysCache = {};\r\n        this.validationRequired = true;\r\n        this.plugins = [];\r\n        this.subscriptions = new Set();\r\n    }\r\n    PluginHost.prototype.ensureDependencies = function () {\r\n        var defined = new Set();\r\n        var knownOptionals = new Map();\r\n        this.plugins\r\n            .filter(function (plugin) { return plugin.container; })\r\n            .forEach(function (plugin) {\r\n            var pluginName = plugin.name || '';\r\n            if (knownOptionals.has(pluginName)) {\r\n                throw (getDependencyError(knownOptionals.get(pluginName), pluginName));\r\n            }\r\n            (plugin.dependencies || [])\r\n                .forEach(function (dependency) {\r\n                if (defined.has(dependency.name))\r\n                    return;\r\n                if (dependency.optional) {\r\n                    if (!knownOptionals.has(dependency.name)) {\r\n                        knownOptionals.set(dependency.name, pluginName);\r\n                    }\r\n                    return;\r\n                }\r\n                throw (getDependencyError(pluginName, dependency.name));\r\n            });\r\n            defined.add(pluginName);\r\n        });\r\n    };\r\n    PluginHost.prototype.registerPlugin = function (plugin) {\r\n        this.plugins = insertPlugin(this.plugins, plugin);\r\n        this.cleanPluginsCache();\r\n    };\r\n    PluginHost.prototype.unregisterPlugin = function (plugin) {\r\n        this.plugins = removePlugin(this.plugins, plugin);\r\n        this.cleanPluginsCache();\r\n    };\r\n    PluginHost.prototype.knownKeys = function (postfix) {\r\n        if (!this.knownKeysCache[postfix]) {\r\n            this.knownKeysCache[postfix] = Array.from(this.plugins\r\n                .map(function (plugin) { return Object.keys(plugin); })\r\n                .map(function (keys) { return keys.filter(function (key) { return key.endsWith(postfix); })[0]; })\r\n                .filter(function (key) { return !!key; })\r\n                .reduce(function (acc, key) { return acc.add(key); }, new Set()))\r\n                .map(function (key) { return key.replace(postfix, ''); });\r\n        }\r\n        return this.knownKeysCache[postfix];\r\n    };\r\n    PluginHost.prototype.collect = function (key, upTo) {\r\n        var _this = this;\r\n        if (this.validationRequired) {\r\n            this.ensureDependencies();\r\n            this.validationRequired = false;\r\n        }\r\n        if (!this.gettersCache[key]) {\r\n            this.gettersCache[key] = this.plugins.map(function (plugin) { return plugin[key]; }).filter(function (plugin) { return !!plugin; });\r\n        }\r\n        if (!upTo)\r\n            return this.gettersCache[key];\r\n        var upToIndex = this.plugins.indexOf(upTo);\r\n        return this.gettersCache[key].filter(function (getter) {\r\n            var pluginIndex = _this.plugins.findIndex(function (plugin) { return plugin[key] === getter; });\r\n            return pluginIndex < upToIndex;\r\n        });\r\n    };\r\n    PluginHost.prototype.get = function (key, upTo) {\r\n        var plugins = this.collect(key, upTo);\r\n        if (!plugins.length)\r\n            return undefined;\r\n        var result = plugins[0]();\r\n        plugins.slice(1).forEach(function (plugin) {\r\n            result = plugin(result);\r\n        });\r\n        return result;\r\n    };\r\n    PluginHost.prototype.registerSubscription = function (subscription) {\r\n        this.subscriptions.add(subscription);\r\n    };\r\n    PluginHost.prototype.unregisterSubscription = function (subscription) {\r\n        this.subscriptions.delete(subscription);\r\n    };\r\n    PluginHost.prototype.broadcast = function (event, message) {\r\n        this.subscriptions.forEach(function (subscription) { return subscription[event] && subscription[event](message); });\r\n    };\r\n    PluginHost.prototype.cleanPluginsCache = function () {\r\n        this.validationRequired = true;\r\n        this.gettersCache = {};\r\n        this.knownKeysCache = {};\r\n    };\r\n    return PluginHost;\r\n}());\n\n/** @internal */\r\nvar EventEmitter = /*#__PURE__*/ (function () {\r\n    function EventEmitter() {\r\n        this.handlers = [];\r\n    }\r\n    EventEmitter.prototype.emit = function (e) {\r\n        this.handlers.forEach(function (handler) { return handler(e); });\r\n    };\r\n    EventEmitter.prototype.subscribe = function (handler) {\r\n        this.handlers.push(handler);\r\n    };\r\n    EventEmitter.prototype.unsubscribe = function (handler) {\r\n        this.handlers.splice(this.handlers.indexOf(handler), 1);\r\n    };\r\n    return EventEmitter;\r\n}());\n\n/** @internal */\r\nvar shallowEqual = function (objA, objB) {\r\n    if (objA === objB) {\r\n        return true;\r\n    }\r\n    var keysA = Object.keys(objA);\r\n    var keysB = Object.keys(objB);\r\n    if (keysA.length !== keysB.length) {\r\n        return false;\r\n    }\r\n    // Test for A's keys different from B.\r\n    var hasOwn = Object.prototype.hasOwnProperty;\r\n    // tslint:disable-next-line: prefer-for-of\r\n    for (var i = 0; i < keysA.length; i += 1) {\r\n        if (!hasOwn.call(objB, keysA[i])\r\n            || objA[keysA[i]] !== objB[keysA[i]]) {\r\n            return false;\r\n        }\r\n        var valA = objA[keysA[i]];\r\n        var valB = objB[keysA[i]];\r\n        if (valA !== valB) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n};\r\n/** @internal */\r\nvar argumentsShallowEqual = function (prev, next) {\r\n    if (prev === null || next === null || prev.length !== next.length) {\r\n        return false;\r\n    }\r\n    for (var i = 0; i < prev.length; i += 1) {\r\n        if (prev[i] !== next[i]) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n};\n\n/** @internal */\r\nvar memoize = function (func) {\r\n    var lastArgs = null;\r\n    var lastResult = null;\r\n    return function () {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        if (lastArgs === null || !argumentsShallowEqual(lastArgs, args)) {\r\n            lastResult = func.apply(void 0, __spread(args));\r\n        }\r\n        lastArgs = args;\r\n        return lastResult;\r\n    };\r\n};\n\n/** @internal */\r\nvar easeInQuad = function (t) { return t * t; };\r\n/** @internal */\r\nvar easeOutQuad = function (t) { return t * (2 - t); };\r\n/** @internal */\r\nvar easeInOutQuad = function (t) { return (t < 0.5\r\n    ? 2 * t * t\r\n    : -1 + ((4 - (2 * t)) * t)); };\r\n/** @internal */\r\nvar easeInCubic = function (t) { return t * t * t; };\r\n/** @internal */\r\nvar easeOutCubic = function (t) { return ((t - 1) * (t - 1) * (t - 1)) + 1; };\r\n/** @internal */\r\nvar easeInOutCubic = function (t) { return (t < 0.5\r\n    ? 4 * t * t * t\r\n    : ((t - 1) * ((2 * t) - 2) * ((2 * t) - 2)) + 1); };\r\n/** @internal */\r\nvar easeInQuart = function (t) { return t * t * t * t; };\r\n/** @internal */\r\nvar easeOutQuart = function (t) { return 1 - ((t - 1) * (t - 1) * (t - 1) * (t - 1)); };\r\n/** @internal */\r\nvar easeInOutQuart = function (t) { return (t < 0.5\r\n    ? 8 * t * t * t * t\r\n    : 1 - (8 * (t - 1) * (t - 1) * (t - 1) * (t - 1))); };\r\n/** @internal */\r\nvar easeInQuint = function (t) { return t * t * t * t * t; };\r\n/** @internal */\r\nvar easeOutQuint = function (t) { return 1 + ((t - 1) * (t - 1) * (t - 1) * (t - 1) * (t - 1)); };\r\n/** @internal */\r\nvar easeInOutQuint = function (t) { return (t < 0.5\r\n    ? 16 * t * t * t * t * t\r\n    : 1 + (16 * (t - 1) * (t - 1) * (t - 1) * (t - 1) * (t - 1))); };\n\nvar processPattern = function (pattern, params) { return Object.keys(params).reduce(function (msg, key) { return msg.replace(\"{\" + key + \"}\", params[key]); }, pattern); };\r\n/** @internal */\r\nvar getMessagesFormatter = function (messages) { return function (key, params) {\r\n    var message = messages[key];\r\n    if (typeof message === 'function') {\r\n        return message(params);\r\n    }\r\n    if (params) {\r\n        return processPattern(message, params);\r\n    }\r\n    return message;\r\n}; };\n\nexport { EventEmitter, PluginHost, argumentsShallowEqual, createClickHandlers, easeInCubic, easeInOutCubic, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInQuad, easeInQuart, easeInQuint, easeOutCubic, easeOutQuad, easeOutQuart, easeOutQuint, getMessagesFormatter, isEdgeBrowser, memoize, shallowEqual, slice };\n//# sourceMappingURL=dx-core.es.js.map\n","/**\n * Bundle of @devexpress/dx-vue-core\n * Generated: 2018-11-07\n * Version: 1.9.0\n * License: https://js.devexpress.com/Licensing\n */\n\nimport { PluginHost, shallowEqual } from '@devexpress/dx-core';\n\nvar PLUGIN_HOST_CONTEXT = Symbol('pluginHost');\nvar POSITION_CONTEXT = Symbol('position');\nvar TEMPLATE_HOST_CONTEXT = Symbol('templateHost');\n\nvar RERENDER_TEMPLATE_EVENT = Symbol('rerenderTemplate');\nvar UPDATE_CONNECTION_EVENT = Symbol('updateConnection');\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\nvar PluginIndexerContext = {\n  name: 'PluginIndexerContext',\n  props: {\n    position: {\n      type: Function,\n      required: true\n    }\n  },\n  provide: function provide() {\n    return defineProperty({}, POSITION_CONTEXT, this.position);\n  },\n  render: function render() {\n    return this.$slots.default && this.$slots.default[0];\n  }\n};\n\nvar PluginIndexer = {\n  name: 'PluginIndexer',\n  inject: {\n    position: {\n      from: POSITION_CONTEXT,\n      default: undefined\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var position = this.position;\n\n\n    return h('div', [this.$slots.default.map(function (child, index) {\n      if (!child.componentOptions) return child;\n\n      var childPosition = function childPosition() {\n        var calculatedPosition = position && position() || [];\n        return [].concat(toConsumableArray(calculatedPosition), [index]);\n      };\n\n      return h(\n        PluginIndexerContext,\n        {\n          attrs: { position: childPosition }\n        },\n        [child]\n      );\n    })]);\n  }\n};\n\nvar DxTemplatePlaceholder = {\n  name: 'DxTemplatePlaceholder',\n  inheritAttrs: false,\n  props: {\n    name: {\n      type: String\n    }\n  },\n  provide: function provide() {\n    var _this = this;\n\n    var templateHost = {};\n    Object.defineProperty(templateHost, 'params', {\n      enumerable: true,\n      get: function get$$1() {\n        return _this.computedParams;\n      }\n    });\n    Object.defineProperty(templateHost, 'templates', {\n      enumerable: true,\n      get: function get$$1() {\n        return _this.computedTemplates.slice(1);\n      }\n    });\n    return defineProperty({}, TEMPLATE_HOST_CONTEXT, templateHost);\n  },\n\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT },\n    templateHost: {\n      from: TEMPLATE_HOST_CONTEXT,\n      default: { templates: [], params: undefined }\n    }\n  },\n  created: function created() {\n    var _this2 = this;\n\n    this.subscription = defineProperty({}, RERENDER_TEMPLATE_EVENT, function (id) {\n      if (_this2.computedTemplates[0] && _this2.computedTemplates[0].id === id) {\n        _this2.$forceUpdate();\n      }\n    });\n  },\n  beforeMount: function beforeMount() {\n    this.pluginHost.registerSubscription(this.subscription);\n  },\n\n  computed: {\n    computedParams: function computedParams() {\n      var that = this;\n      return !Object.keys(this.$attrs).length && !Object.keys(this.$listeners).length ? this.templateHost.params : {\n        get attrs() {\n          return that.$attrs;\n        },\n        get listeners() {\n          return that.$listeners;\n        },\n        get slots() {\n          return that.$slots;\n        },\n        get scopedSlots() {\n          return that.$scopedSlots;\n        }\n      };\n    },\n    computedTemplates: function computedTemplates() {\n      var _this3 = this;\n\n      return this.name ? this.pluginHost.collect(this.name + 'Template').filter(function (template) {\n        return template.predicate(_this3.computedParams);\n      }).reverse() : this.templateHost.templates;\n    }\n  },\n  render: function render() {\n    var template = this.computedTemplates[0];\n\n    var content = template ? template.children() : null;\n    if (content && typeof content === 'function') {\n      content = content(this.computedParams);\n    }\n    if (this.$scopedSlots.default) {\n      content = this.$scopedSlots.default(content);\n    }\n    return content && content.length ? content[0] : content;\n  },\n  destroyed: function destroyed() {\n    this.pluginHost.unregisterSubscription(this.subscription);\n  }\n};\n\nvar DxPluginHost = {\n  name: 'DxPluginHost',\n  beforeCreate: function beforeCreate() {\n    this.pluginHost = new PluginHost();\n  },\n  provide: function provide() {\n    return defineProperty({}, PLUGIN_HOST_CONTEXT, this.pluginHost);\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h('div', [h(PluginIndexer, [this.$slots.default]), h(DxTemplatePlaceholder, {\n      attrs: { name: 'root' }\n    })]);\n  }\n};\n\nvar DxPlugin = {\n  name: 'DxPlugin',\n  props: {\n    name: {\n      type: String,\n      default: ''\n    },\n    dependencies: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    }\n  },\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT },\n    position: { from: POSITION_CONTEXT }\n  },\n  beforeMount: function beforeMount() {\n    var pluginHost = this.pluginHost,\n        position = this.position,\n        name = this.name,\n        dependencies = this.dependencies;\n\n\n    this.plugin = {\n      position: position,\n      name: name,\n      dependencies: dependencies,\n      container: true\n    };\n    pluginHost.registerPlugin(this.plugin);\n  },\n  beforeUpdate: function beforeUpdate() {\n    this.pluginHost.ensureDependencies();\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.pluginHost.unregisterPlugin(this.plugin);\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(PluginIndexer, [this.$slots.default]);\n  }\n};\n\nvar getAvailableGetters = function getAvailableGetters(pluginHost) {\n  var getGetterValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (getterName) {\n    return pluginHost.get(getterName + 'Getter');\n  };\n\n  var trackedDependencies = {};\n\n  var getters = void 0;\n  if (typeof Proxy !== 'undefined') {\n    getters = new Proxy({}, {\n      get: function get$$1(target, prop) {\n        if (typeof prop !== 'string') return undefined;\n        var boxedGetter = getGetterValue(prop);\n        trackedDependencies[prop] = boxedGetter && boxedGetter.id;\n        return boxedGetter && boxedGetter.value;\n      },\n      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, prop) {\n        return { configurable: true, enumerable: true, value: this.get(target, prop) };\n      },\n      ownKeys: function ownKeys() {\n        return pluginHost.knownKeys('Getter');\n      }\n    });\n  } else {\n    getters = pluginHost.knownKeys('Getter').reduce(function (acc, getterName) {\n      Object.defineProperty(acc, getterName, {\n        get: function get$$1() {\n          var boxedGetter = getGetterValue(getterName);\n          trackedDependencies[getterName] = boxedGetter && boxedGetter.id;\n          return boxedGetter && boxedGetter.value;\n        }\n      });\n      return acc;\n    }, {});\n  }\n\n  return { getters: getters, trackedDependencies: trackedDependencies };\n};\n\nvar isTrackedDependenciesChanged = function isTrackedDependenciesChanged(pluginHost, prevTrackedDependencies) {\n  var getGetterValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (getterName) {\n    return pluginHost.get(getterName + 'Getter');\n  };\n\n  var trackedDependencies = Object.keys(prevTrackedDependencies).reduce(function (acc, getterName) {\n    var boxedGetter = getGetterValue(getterName);\n    return Object.assign(acc, defineProperty({}, getterName, boxedGetter && boxedGetter.id));\n  }, {});\n  return !shallowEqual(prevTrackedDependencies, trackedDependencies);\n};\n\nvar getAvailableActions = function getAvailableActions(pluginHost) {\n  var getAction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (actionName) {\n    return pluginHost.collect(actionName + 'Action').slice().reverse()[0];\n  };\n\n  var actions = void 0;\n  if (typeof Proxy !== 'undefined') {\n    actions = new Proxy({}, {\n      get: function get$$1(target, prop) {\n        if (typeof prop !== 'string') return undefined;\n        return getAction(prop);\n      },\n      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, prop) {\n        return { configurable: true, enumerable: true, value: this.get(target, prop) };\n      },\n      ownKeys: function ownKeys() {\n        return pluginHost.knownKeys('Action');\n      }\n    });\n  } else {\n    actions = pluginHost.knownKeys('Action').reduce(function (acc, actionName) {\n      Object.defineProperty(acc, actionName, {\n        get: function get$$1() {\n          return getAction(actionName);\n        }\n      });\n      return acc;\n    }, {});\n  }\n  return actions;\n};\n\nvar DxAction = {\n  name: 'DxAction',\n  props: {\n    name: {\n      type: String,\n      required: true\n    },\n    action: {\n      type: Function,\n      required: true\n    }\n  },\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT },\n    position: { from: POSITION_CONTEXT }\n  },\n  beforeMount: function beforeMount() {\n    var _this = this;\n\n    var pluginHost = this.pluginHost,\n        name = this.name;\n\n\n    this.plugin = defineProperty({\n      position: function position() {\n        return _this.position();\n      }\n    }, name + 'Action', function undefined(params) {\n      var action = _this.action;\n\n      var _getAvailableGetters = getAvailableGetters(pluginHost, function (getterName) {\n        return pluginHost.get(getterName + 'Getter', _this.plugin);\n      }),\n          getters = _getAvailableGetters.getters;\n\n      var nextParams = params;\n      var actions = getAvailableActions(pluginHost, function (actionName) {\n        return actionName === name ? function (newParams) {\n          nextParams = newParams;\n        } : pluginHost.collect(actionName + 'Action', _this.plugin).slice().reverse()[0];\n      });\n      action(params, getters, actions);\n      var nextAction = pluginHost.collect(name + 'Action', _this.plugin).slice().reverse()[0];\n      if (nextAction) {\n        nextAction(nextParams);\n      }\n    });\n\n    pluginHost.registerPlugin(this.plugin);\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.pluginHost.unregisterPlugin(this.plugin);\n  },\n  render: function render() {\n    return null;\n  }\n};\n\nvar GLOBAL_SHIFT = 0xffff;\n\nvar globalGetterId = 0;\nvar DxGetter = {\n  name: 'DxGetter',\n  props: {\n    name: {\n      type: String,\n      required: true\n    },\n    value: null,\n    computed: {\n      type: Function,\n      default: undefined\n    }\n  },\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT },\n    position: { from: POSITION_CONTEXT }\n  },\n  created: function created() {\n    this.globalId = globalGetterId;\n    globalGetterId += 1;\n    this.internalId = 0;\n    this.generateId();\n  },\n  beforeMount: function beforeMount() {\n    var _this = this;\n\n    var pluginHost = this.pluginHost,\n        name = this.name;\n\n\n    var lastComputed = void 0;\n    var lastTrackedDependencies = {};\n    var lastResult = void 0;\n    var unwatch = void 0;\n\n    this.plugin = defineProperty({\n      position: function position() {\n        return _this.position();\n      }\n    }, name + 'Getter', function (_undefined) {\n      function undefined(_x) {\n        return _undefined.apply(this, arguments);\n      }\n\n      undefined.toString = function () {\n        return _undefined.toString();\n      };\n\n      return undefined;\n    }(function (original) {\n      var value = _this.value,\n          computed = _this.computed;\n\n      if (computed === undefined) return { id: _this.id, value: value };\n\n      var getGetterValue = function getGetterValue(getterName) {\n        return getterName === name ? original : pluginHost.get(getterName + 'Getter', _this.plugin);\n      };\n\n      if (computed === lastComputed && !isTrackedDependenciesChanged(pluginHost, lastTrackedDependencies, getGetterValue)) {\n        return { id: _this.id, value: lastResult };\n      }\n\n      var _getAvailableGetters = getAvailableGetters(pluginHost, getGetterValue),\n          getters = _getAvailableGetters.getters,\n          trackedDependencies = _getAvailableGetters.trackedDependencies;\n\n      var actions = getAvailableActions(pluginHost);\n\n      lastComputed = computed;\n      lastTrackedDependencies = trackedDependencies;\n      if (unwatch) unwatch();\n      unwatch = _this.$watch(function () {\n        return computed(getters, actions);\n      }, function (newValue) {\n        _this.generateId();\n        lastResult = newValue;\n      }, { immediate: true });\n      return { id: _this.id, value: lastResult };\n    }));\n\n    pluginHost.registerPlugin(this.plugin);\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.pluginHost.unregisterPlugin(this.plugin);\n  },\n  render: function render() {\n    return null;\n  },\n\n  methods: {\n    generateId: function generateId() {\n      this.internalId = this.internalId + 1 < GLOBAL_SHIFT ? this.internalId + 1 : 0;\n      // eslint-disable-next-line no-bitwise\n      this.id = (this.globalId << GLOBAL_SHIFT) + this.internalId;\n    }\n  },\n  watch: {\n    value: function value() {\n      this.generateId();\n      this.pluginHost.broadcast(UPDATE_CONNECTION_EVENT);\n    }\n  }\n};\n\nvar globalTemplateId = 0;\nvar DxTemplate = {\n  name: 'DxTemplate',\n  props: {\n    name: {\n      type: String,\n      required: true\n    },\n    predicate: {\n      type: Function\n    }\n  },\n  beforeCreate: function beforeCreate() {\n    globalTemplateId += 1;\n    this.id = globalTemplateId;\n  },\n\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT },\n    position: { from: POSITION_CONTEXT }\n  },\n  created: function created() {\n    var _this = this;\n\n    this.plugin = defineProperty({\n      position: function position() {\n        return _this.position();\n      }\n    }, this.name + 'Template', {\n      id: this.id,\n      predicate: function predicate(params) {\n        return _this.predicate ? _this.predicate(params) : true;\n      },\n      children: function children() {\n        return _this.$scopedSlots.default || _this.$slots.default;\n      }\n    });\n  },\n  beforeMount: function beforeMount() {\n    this.pluginHost.registerPlugin(this.plugin);\n  },\n  render: function render() {\n    return null;\n  },\n  updated: function updated() {\n    this.pluginHost.broadcast(RERENDER_TEMPLATE_EVENT, this.id);\n  },\n  destroyed: function destroyed() {\n    this.pluginHost.unregisterPlugin(this.plugin);\n  }\n};\n\nvar DxTemplateConnector = {\n  name: 'DxTemplateConnector',\n  inject: {\n    pluginHost: { from: PLUGIN_HOST_CONTEXT }\n  },\n  beforeMount: function beforeMount() {\n    var _this = this;\n\n    this.trackedDependencies = {};\n    this.subscription = defineProperty({}, UPDATE_CONNECTION_EVENT, function () {\n      return _this.updateConnection();\n    });\n    this.pluginHost.registerSubscription(this.subscription);\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.pluginHost.unregisterSubscription(this.subscription);\n  },\n\n  methods: {\n    updateConnection: function updateConnection() {\n      if (isTrackedDependenciesChanged(this.pluginHost, this.trackedDependencies)) {\n        this.$forceUpdate();\n      }\n    }\n  },\n  render: function render() {\n    var _getAvailableGetters = getAvailableGetters(this.pluginHost),\n        getters = _getAvailableGetters.getters,\n        trackedDependencies = _getAvailableGetters.trackedDependencies;\n\n    this.trackedDependencies = trackedDependencies;\n    var actions = getAvailableActions(this.pluginHost);\n\n    return this.$scopedSlots.default({ getters: getters, actions: actions });\n  }\n};\n\nvar styles = {\n  root: {\n    position: 'relative'\n  },\n  triggers: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    height: '100%',\n    width: '100%',\n    overflow: 'hidden',\n    zIndex: -1,\n    visibility: 'hidden',\n    opacity: 0\n  },\n  expand: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    height: '100%',\n    width: '100%',\n    overflow: 'auto'\n  },\n  contract: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    height: '100%',\n    width: '100%',\n    overflow: 'auto'\n  },\n  contractTrigger: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    width: '200%',\n    height: '200%'\n  }\n};\n\nvar DxSizer = {\n  name: 'DxSizer',\n  inheritAttrs: false,\n  data: function data() {\n    return {\n      width: 0,\n      height: 0\n    };\n  },\n  mounted: function mounted() {\n    this.setupListeners();\n  },\n\n  methods: {\n    setupListeners: function setupListeners() {\n      var size = { height: this.$refs.root.offsetHeight, width: this.$refs.root.offsetWidth };\n\n      this.$refs.contract.scrollTop = size.height;\n      this.$refs.contract.scrollLeft = size.width;\n\n      this.$refs.expandTrigger.style.width = size.width + 1 + 'px';\n      this.$refs.expandTrigger.style.height = size.height + 1 + 'px';\n      this.$refs.expand.scrollTop = 1;\n      this.$refs.expand.scrollLeft = 1;\n\n      if (this.width === size.width && this.height === size.height) return;\n\n      this.width = size.width;\n      this.height = size.height;\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var width = this.width,\n        height = this.height;\n\n    return h(\n      'div',\n      {\n        ref: 'root',\n        style: styles.root\n      },\n      [width && height && this.$scopedSlots.default({ width: width, height: height }), h(\n        'div',\n        { style: styles.triggers },\n        [h(\n          'div',\n          {\n            ref: 'expand',\n            style: styles.expand,\n            on: {\n              'scroll': this.setupListeners\n            }\n          },\n          [h('div', {\n            ref: 'expandTrigger'\n          })]\n        ), h(\n          'div',\n          {\n            ref: 'contract',\n            style: styles.contract,\n            on: {\n              'scroll': this.setupListeners\n            }\n          },\n          [h('div', {\n            style: styles.contractTrigger\n          })]\n        )]\n      )]\n    );\n  }\n};\n\nvar DxRefHolder = {\n  name: 'DxRefHolder',\n  inheritAttrs: false,\n  render: function render() {\n    return this.$slots.default[0];\n  }\n};\n\nvar createRenderComponent = function createRenderComponent(Component, initialAdditionalProps) {\n  var storedAdditionalProps = initialAdditionalProps;\n  var components = new Set();\n\n  var RenderComponent = {\n    name: 'RenderComponent',\n    inheritAttrs: false,\n    beforeMount: function beforeMount() {\n      components.add(this);\n    },\n    beforeDestroy: function beforeDestroy() {\n      components.delete(this);\n    },\n    render: function render() {\n      var h = arguments[0];\n\n      return h(Component, { attrs: _extends({}, this.$attrs, storedAdditionalProps), on: _extends({}, this.$listeners) });\n    }\n  };\n\n  return {\n    component: RenderComponent,\n    update: function update(additionalProps) {\n      storedAdditionalProps = additionalProps;\n      Array.from(components.values()).forEach(function (component) {\n        return component.$forceUpdate();\n      });\n    }\n  };\n};\n\nexport { DxPluginHost, DxPlugin, DxAction, DxGetter, DxTemplate, DxTemplatePlaceholder, DxTemplateConnector, DxSizer, DxRefHolder, createRenderComponent };\n//# sourceMappingURL=dx-vue-core.es.js.map\n","/**\n * Bundle of @devexpress/dx-grid-core\n * Generated: 2019-08-23\n * Version: 1.11.2\n * License: https://js.devexpress.com/Licensing\n */\n\nimport { slice, easeOutCubic } from '@devexpress/dx-core';\n\nvar GRID_GROUP_TYPE = Symbol('group');\r\nvar GRID_GROUP_CHECK = Symbol(GRID_GROUP_TYPE.toString() + \"_check\");\r\nvar GRID_GROUP_LEVEL_KEY = Symbol(GRID_GROUP_TYPE.toString() + \"_levelKey\");\r\nvar GRID_GROUP_COLLAPSED_ROWS = Symbol(GRID_GROUP_TYPE.toString() + \"_collapsedRows\");\n\nvar warnIfRowIdUndefined = function (getRowId) { return function (row) {\r\n    var result = getRowId(row);\r\n    if (!row[GRID_GROUP_CHECK] && result === undefined) {\r\n        // tslint:disable-next-line: no-console\r\n        console.warn('The row id is undefined. Check the getRowId function. The row is', row);\r\n    }\r\n    return result;\r\n}; };\r\nvar rowIdGetter = function (getRowId, rows) {\r\n    if (!getRowId) {\r\n        var map_1 = new Map(rows.map(function (row, rowIndex) { return [row, rowIndex]; }));\r\n        return function (row) { return map_1.get(row); };\r\n    }\r\n    return warnIfRowIdUndefined(getRowId);\r\n};\r\nvar defaultGetCellValue = function (row, columnName) { return row[columnName]; };\r\nvar cellValueGetter = function (getCellValue, columns) {\r\n    if (getCellValue === void 0) { getCellValue = defaultGetCellValue; }\r\n    var useFastAccessor = true;\r\n    var map = columns.reduce(function (acc, column) {\r\n        if (column.getCellValue) {\r\n            useFastAccessor = false;\r\n            acc[column.name] = column.getCellValue;\r\n        }\r\n        return acc;\r\n    }, {});\r\n    if (useFastAccessor) {\r\n        return getCellValue;\r\n    }\r\n    return function (row, columnName) { return (map[columnName]\r\n        ? map[columnName](row, columnName)\r\n        : getCellValue(row, columnName)); };\r\n};\n\nvar changeColumnSorting = function (state, _a) {\r\n    var columnName = _a.columnName, direction = _a.direction, keepOther = _a.keepOther, sortIndex = _a.sortIndex;\r\n    var sorting = state.sorting;\r\n    var nextSorting = [];\r\n    if (keepOther === true) {\r\n        nextSorting = sorting;\r\n    }\r\n    if (Array.isArray(keepOther)) {\r\n        nextSorting = slice(sorting)\r\n            .filter(function (s) {\r\n            return keepOther.indexOf(s.columnName) > -1;\r\n        });\r\n    }\r\n    var columnSortingIndex = sorting.findIndex(function (s) { return s.columnName === columnName; });\r\n    var columnSorting = sorting[columnSortingIndex];\r\n    var newColumnSorting = {\r\n        columnName: columnName,\r\n        direction: direction\r\n            || (!columnSorting || columnSorting.direction === 'desc' ? 'asc' : 'desc'),\r\n    };\r\n    if (columnSortingIndex > -1) {\r\n        nextSorting = slice(nextSorting);\r\n        nextSorting.splice(columnSortingIndex, 1);\r\n    }\r\n    if (direction !== null) {\r\n        var newIndexFallback = columnSortingIndex > -1 ? columnSortingIndex : nextSorting.length;\r\n        var newIndex = sortIndex !== undefined ? sortIndex : newIndexFallback;\r\n        nextSorting = slice(nextSorting);\r\n        nextSorting.splice(newIndex, 0, newColumnSorting);\r\n    }\r\n    return {\r\n        sorting: nextSorting,\r\n    };\r\n};\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\nfunction __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nfunction __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\n\nvar unique = function (arr) { return __spread(Array.from(new Set(arr))); };\r\nvar getColumnSortingDirection = function (sorting, columnName) {\r\n    var columnSorting = sorting.filter(function (s) { return s.columnName === columnName; })[0];\r\n    return columnSorting ? columnSorting.direction : null;\r\n};\r\nvar getPersistentSortedColumns = function (sorting, columnExtensions) {\r\n    if (columnExtensions === void 0) { columnExtensions = []; }\r\n    return columnExtensions.reduce(function (acc, _a) {\r\n        var columnName = _a.columnName, sortingEnabled = _a.sortingEnabled;\r\n        if (sortingEnabled === false) {\r\n            if (sorting.findIndex(function (sortItem) { return sortItem.columnName === columnName; }) > -1) {\r\n                acc.push(columnName);\r\n            }\r\n        }\r\n        return acc;\r\n    }, []);\r\n};\r\nvar calculateKeepOther = function (sorting, keepOther, persistentSortedColumns) {\r\n    if (persistentSortedColumns === void 0) { persistentSortedColumns = []; }\r\n    if (!persistentSortedColumns.length)\r\n        return keepOther;\r\n    if (!keepOther)\r\n        return persistentSortedColumns;\r\n    return Array.isArray(keepOther)\r\n        ? unique(__spread(keepOther, persistentSortedColumns))\r\n        : unique(__spread(sorting.map(function (item) { return item.columnName; }), persistentSortedColumns));\r\n};\n\n/* eslint-disable no-plusplus, no-param-reassign, no-use-before-define, no-constant-condition */\r\n/* tslint:disable no-increment-decrement */\r\nvar merge = function (array, auxiliary, lo, mid, hi, compare) {\r\n    var i = lo;\r\n    var j = mid + 1;\r\n    var k = lo;\r\n    while (true) {\r\n        var cmp = compare(array[i], array[j]);\r\n        if (cmp <= 0) {\r\n            auxiliary[k++] = array[i++];\r\n            if (i > mid) {\r\n                do {\r\n                    auxiliary[k++] = array[j++];\r\n                } while (j <= hi);\r\n                break;\r\n            }\r\n        }\r\n        else {\r\n            auxiliary[k++] = array[j++];\r\n            if (j > hi) {\r\n                do {\r\n                    auxiliary[k++] = array[i++];\r\n                } while (i <= mid);\r\n                break;\r\n            }\r\n        }\r\n    }\r\n};\r\nvar sortArrayToAuxiliary = function (array, auxiliary, lo, hi, compare) {\r\n    if (hi < lo)\r\n        return;\r\n    if (hi === lo) {\r\n        auxiliary[lo] = array[lo];\r\n        return;\r\n    }\r\n    var mid = Math.floor(lo + ((hi - lo) / 2));\r\n    sortAuxiliaryToArray(array, auxiliary, lo, mid, compare);\r\n    sortAuxiliaryToArray(array, auxiliary, mid + 1, hi, compare);\r\n    merge(array, auxiliary, lo, mid, hi, compare);\r\n};\r\nvar sortAuxiliaryToArray = function (array, auxiliary, lo, hi, compare) {\r\n    if (hi <= lo)\r\n        return;\r\n    var mid = Math.floor(lo + ((hi - lo) / 2));\r\n    sortArrayToAuxiliary(array, auxiliary, lo, mid, compare);\r\n    sortArrayToAuxiliary(array, auxiliary, mid + 1, hi, compare);\r\n    merge(auxiliary, array, lo, mid, hi, compare);\r\n};\r\nvar mergeSort = (function (array, compare) {\r\n    if (compare === void 0) { compare = function (a, b) {\r\n        if (a < b)\r\n            return -1;\r\n        if (a > b)\r\n            return 1;\r\n        return 0;\r\n    }; }\r\n    var result = slice(array);\r\n    var auxiliary = slice(array);\r\n    sortAuxiliaryToArray(result, auxiliary, 0, result.length - 1, compare);\r\n    return result;\r\n});\n\nvar NODE_CHECK = Symbol('node');\r\nvar rowsToTree = function (rows, getRowLevelKey) {\r\n    if (!rows.length)\r\n        return rows;\r\n    var levels = [{ children: [] }];\r\n    rows.forEach(function (row) {\r\n        var _a;\r\n        var levelKey = getRowLevelKey(row);\r\n        if (levelKey) {\r\n            var levelIndex = levels.slice(1)\r\n                .findIndex(function (level) { return getRowLevelKey(level.root) === levelKey; }) + 1;\r\n            if (levelIndex > 0) {\r\n                levels.splice(levelIndex, levels.length - levelIndex);\r\n            }\r\n            var node = (_a = {}, _a[NODE_CHECK] = true, _a.root = row, _a.children = [], _a);\r\n            levels[levels.length - 1].children.push(node);\r\n            levels.push(node);\r\n        }\r\n        else {\r\n            levels[levels.length - 1].children.push(row);\r\n        }\r\n    });\r\n    return levels[0].children;\r\n};\r\nvar treeToRows = function (tree, rows) {\r\n    if (rows === void 0) { rows = []; }\r\n    if (!tree.length)\r\n        return tree;\r\n    return tree.reduce(function (acc, node) {\r\n        if (node[NODE_CHECK]) {\r\n            acc.push(node.root);\r\n            treeToRows(node.children, rows);\r\n        }\r\n        else {\r\n            acc.push(node);\r\n        }\r\n        return acc;\r\n    }, rows);\r\n};\n\nvar defaultCompare = function (a, b) {\r\n    if (a === b)\r\n        return 0;\r\n    if (a === null) {\r\n        return b === undefined ? -1 : 1;\r\n    }\r\n    if (a === undefined) {\r\n        return 1;\r\n    }\r\n    if (b === null || b === undefined) {\r\n        return -1;\r\n    }\r\n    return a < b ? -1 : 1;\r\n};\r\nvar createCompare = function (sorting, getColumnCompare, getComparableValue) { return sorting.reduceRight(function (prevCompare, columnSorting) {\r\n    var columnName = columnSorting.columnName;\r\n    var inverse = columnSorting.direction === 'desc';\r\n    var columnCompare = (getColumnCompare && getColumnCompare(columnName)) || defaultCompare;\r\n    return function (aRow, bRow) {\r\n        var a = getComparableValue(aRow, columnName);\r\n        var b = getComparableValue(bRow, columnName);\r\n        var result = columnCompare(a, b);\r\n        if (result !== 0) {\r\n            return inverse ? -result : result;\r\n        }\r\n        return prevCompare(aRow, bRow);\r\n    };\r\n}, function () {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return 0;\r\n}); };\r\nvar sortTree = function (tree, compare) {\r\n    var sortedTree = tree.map(function (node) {\r\n        if (node[NODE_CHECK]) {\r\n            return __assign({}, node, { children: sortTree(node.children, compare) });\r\n        }\r\n        return node;\r\n    });\r\n    return mergeSort(sortedTree, function (a, b) { return compare(a[NODE_CHECK] ? a.root : a, b[NODE_CHECK] ? b.root : b); });\r\n};\r\nvar sortHierarchicalRows = function (rows, compare, getRowLevelKey) {\r\n    var tree = rowsToTree(rows, getRowLevelKey);\r\n    var sortedTree = sortTree(tree, compare);\r\n    return treeToRows(sortedTree);\r\n};\r\nvar sortedRows = function (rows, sorting, getCellValue, getColumnCompare, isGroupRow, getRowLevelKey) {\r\n    if (!sorting.length || !rows.length)\r\n        return rows;\r\n    var compare;\r\n    if (!getRowLevelKey) {\r\n        compare = createCompare(sorting, getColumnCompare, getCellValue);\r\n        return mergeSort(rows.slice(), compare);\r\n    }\r\n    compare = createCompare(sorting, getColumnCompare, function (row, columnName) {\r\n        if (isGroupRow && isGroupRow(row)) {\r\n            if (row.groupedBy === columnName) {\r\n                return row.value;\r\n            }\r\n            return undefined;\r\n        }\r\n        return getCellValue(row, columnName);\r\n    });\r\n    return sortHierarchicalRows(rows, compare, getRowLevelKey);\r\n};\n\nvar changeColumnFilter = function (filters, _a) {\r\n    var columnName = _a.columnName, config = _a.config;\r\n    var filterIndex = filters.findIndex(function (f) { return f.columnName === columnName; });\r\n    var nextState = slice(filters);\r\n    if (config) {\r\n        var filter = __assign({ columnName: columnName }, config);\r\n        if (filterIndex > -1) {\r\n            nextState.splice(filterIndex, 1, filter);\r\n        }\r\n        else {\r\n            nextState.push(filter);\r\n        }\r\n    }\r\n    else if (filterIndex > -1) {\r\n        nextState.splice(filterIndex, 1);\r\n    }\r\n    return nextState;\r\n};\n\nvar getColumnFilterConfig = function (filters, columnName) { return (filters.length && filters.filter(function (s) { return s.columnName === columnName; })[0] || null); };\n\nvar filterExpression = function (filters, expression) {\r\n    // tslint:disable-next-line: no-object-literal-type-assertion\r\n    var selfFilterExpr = { filters: filters, operator: 'and' };\r\n    if (!expression) {\r\n        return selfFilterExpr;\r\n    }\r\n    return {\r\n        operator: 'and',\r\n        filters: [expression, selfFilterExpr],\r\n    };\r\n};\n\nvar operators = {\r\n    or: function (predicates) { return function (row) { return (predicates.reduce(function (acc, predicate) { return acc || predicate(row); }, false)); }; },\r\n    and: function (predicates) { return function (row) { return (predicates.reduce(function (acc, predicate) { return acc && predicate(row); }, true)); }; },\r\n};\r\nvar toLowerCase = function (value) { return String(value).toLowerCase(); };\r\nvar operationPredicates = {\r\n    contains: function (value, filter) { return toLowerCase(value)\r\n        .indexOf(toLowerCase(filter.value)) > -1; },\r\n    notContains: function (value, filter) { return toLowerCase(value)\r\n        .indexOf(toLowerCase(filter.value)) === -1; },\r\n    startsWith: function (value, filter) { return toLowerCase(value)\r\n        .startsWith(toLowerCase(filter.value)); },\r\n    endsWith: function (value, filter) { return toLowerCase(value)\r\n        .endsWith(toLowerCase(filter.value)); },\r\n    equal: function (value, filter) { return String(value) === String(filter.value); },\r\n    notEqual: function (value, filter) { return String(value) !== String(filter.value); },\r\n    greaterThan: function (value, filter) { return value > filter.value; },\r\n    greaterThanOrEqual: function (value, filter) { return value >= filter.value; },\r\n    lessThan: function (value, filter) { return value < filter.value; },\r\n    lessThanOrEqual: function (value, filter) { return value <= filter.value; },\r\n};\r\nvar defaultFilterPredicate = function (value, filter) {\r\n    var operation = filter.operation || 'contains';\r\n    return operationPredicates[operation](value, filter);\r\n};\r\nvar filterTree = function (tree, predicate) { return tree.reduce(function (acc, node) {\r\n    if (node[NODE_CHECK]) {\r\n        var filteredChildren = filterTree(node.children, predicate);\r\n        if (filteredChildren.length > 0) {\r\n            acc.push(__assign({}, node, { children: filteredChildren }));\r\n            return acc;\r\n        }\r\n        if (predicate(node.root, true)) {\r\n            acc.push(node.root);\r\n            return acc;\r\n        }\r\n        return acc;\r\n    }\r\n    if (predicate(node)) {\r\n        acc.push(node);\r\n        return acc;\r\n    }\r\n    return acc;\r\n}, []); };\r\nvar filterHierarchicalRows = function (rows, predicate, getRowLevelKey, getCollapsedRows) {\r\n    var tree = rowsToTree(rows, getRowLevelKey);\r\n    var collapsedRowsMeta = [];\r\n    var filteredTree = filterTree(tree, function (row, isNode) {\r\n        if (isNode) {\r\n            var collapsedRows = getCollapsedRows && getCollapsedRows(row);\r\n            if (collapsedRows && collapsedRows.length) {\r\n                var filteredCollapsedRows = collapsedRows.filter(predicate);\r\n                collapsedRowsMeta.push([row, filteredCollapsedRows]);\r\n                return !!filteredCollapsedRows.length || predicate(row);\r\n            }\r\n            if (predicate(row)) {\r\n                collapsedRowsMeta.push([row, []]);\r\n                return true;\r\n            }\r\n            return false;\r\n        }\r\n        return predicate(row);\r\n    });\r\n    return { rows: treeToRows(filteredTree), collapsedRowsMeta: new Map(collapsedRowsMeta) };\r\n};\r\nvar buildPredicate = function (initialFilterExpression, getCellValue, getColumnPredicate) {\r\n    var getSimplePredicate = function (filter) {\r\n        var columnName = filter.columnName;\r\n        var customPredicate = getColumnPredicate && getColumnPredicate(columnName);\r\n        var predicate = customPredicate || defaultFilterPredicate;\r\n        return function (row) { return predicate(getCellValue(row, columnName), filter, row); };\r\n    };\r\n    var getOperatorPredicate = function (filterExpression) {\r\n        var build = operators[toLowerCase(filterExpression.operator)];\r\n        return build && build(filterExpression.filters.map(getPredicate));\r\n    };\r\n    var getPredicate = function (filterExpression) { return (getOperatorPredicate(filterExpression)\r\n        || getSimplePredicate(filterExpression)); };\r\n    return getPredicate(initialFilterExpression);\r\n};\r\nvar filteredRows = function (rows, filterExpression, getCellValue, getColumnPredicate, getRowLevelKey, getCollapsedRows) {\r\n    if (!(filterExpression && Object.keys(filterExpression).length && rows.length)) {\r\n        // tslint:disable-next-line:no-object-literal-type-assertion\r\n        return { rows: rows };\r\n    }\r\n    var predicate = buildPredicate(filterExpression, getCellValue, getColumnPredicate);\r\n    return getRowLevelKey\r\n        ? filterHierarchicalRows(rows, predicate, getRowLevelKey, getCollapsedRows)\r\n        : { rows: rows.filter(predicate) };\r\n};\r\nvar filteredCollapsedRowsGetter = function (_a) {\r\n    var collapsedRowsMeta = _a.collapsedRowsMeta;\r\n    return function (row) { return collapsedRowsMeta && collapsedRowsMeta.get(row); };\r\n};\r\nvar unwrappedFilteredRows = function (_a) {\r\n    var rows = _a.rows;\r\n    return rows;\r\n};\n\nvar GROUP_KEY_SEPARATOR = '|';\n\nvar applyColumnGrouping = function (grouping, _a) {\r\n    var columnName = _a.columnName, groupIndex = _a.groupIndex;\r\n    var nextGrouping = grouping;\r\n    var groupingIndex = nextGrouping.findIndex(function (g) { return g.columnName === columnName; });\r\n    var targetIndex = groupIndex;\r\n    if (groupingIndex > -1) {\r\n        nextGrouping = slice(grouping);\r\n        nextGrouping.splice(groupingIndex, 1);\r\n    }\r\n    else if (groupIndex === undefined) {\r\n        targetIndex = nextGrouping.length;\r\n    }\r\n    if (targetIndex > -1) {\r\n        nextGrouping = slice(nextGrouping);\r\n        nextGrouping.splice(targetIndex, 0, {\r\n            columnName: columnName,\r\n        });\r\n    }\r\n    return nextGrouping;\r\n};\r\nvar changeColumnGrouping = function (_a, _b) {\r\n    var grouping = _a.grouping, expandedGroups = _a.expandedGroups;\r\n    var columnName = _b.columnName, groupIndex = _b.groupIndex;\r\n    var nextGrouping = applyColumnGrouping(grouping, { columnName: columnName, groupIndex: groupIndex });\r\n    var ungroupedColumnIndex = grouping.findIndex(function (group, index) { return !nextGrouping[index] || group.columnName !== nextGrouping[index].columnName; });\r\n    if (ungroupedColumnIndex === -1) {\r\n        return {\r\n            grouping: nextGrouping,\r\n        };\r\n    }\r\n    var filteredExpandedGroups = expandedGroups.filter(function (group) { return group.split(GROUP_KEY_SEPARATOR).length <= ungroupedColumnIndex; });\r\n    if (filteredExpandedGroups.length === expandedGroups.length) {\r\n        return {\r\n            grouping: nextGrouping,\r\n        };\r\n    }\r\n    return {\r\n        grouping: nextGrouping,\r\n        expandedGroups: filteredExpandedGroups,\r\n    };\r\n};\r\nvar toggleExpandedGroups = function (state, _a) {\r\n    var groupKey = _a.groupKey;\r\n    var expandedGroups = slice(state.expandedGroups);\r\n    var groupKeyIndex = expandedGroups.indexOf(groupKey);\r\n    if (groupKeyIndex > -1) {\r\n        expandedGroups.splice(groupKeyIndex, 1);\r\n    }\r\n    else {\r\n        expandedGroups.push(groupKey);\r\n    }\r\n    return {\r\n        expandedGroups: expandedGroups,\r\n    };\r\n};\r\nvar draftColumnGrouping = function (_a, _b) {\r\n    var grouping = _a.grouping, draftGrouping = _a.draftGrouping;\r\n    var columnName = _b.columnName, groupIndex = _b.groupIndex;\r\n    return ({\r\n        draftGrouping: applyColumnGrouping(draftGrouping || grouping, { columnName: columnName, groupIndex: groupIndex }),\r\n    });\r\n};\r\nvar cancelColumnGroupingDraft = function () { return ({\r\n    draftGrouping: null,\r\n}); };\n\nvar adjustSortIndex = function (groupingIndex, grouping, sorting) { return Math.max(grouping.slice(0, groupingIndex).reduce(function (acc, columnGrouping) {\r\n    var columnSortingIndex = sorting.findIndex(function (columnSorting) { return columnSorting.columnName === columnGrouping.columnName; });\r\n    return (columnSortingIndex === -1 ? acc - 1 : acc);\r\n}, groupingIndex), 0); };\n\nvar groupRowChecker = function (row) { return row[GRID_GROUP_CHECK]; };\r\nvar groupRowLevelKeyGetter = function (row) { return (row ? row[GRID_GROUP_LEVEL_KEY] : undefined); };\r\nvar defaultColumnCriteria = function (value) { return ({\r\n    value: value,\r\n    key: String(value),\r\n}); };\r\nvar groupedRows = function (rows, grouping, getCellValue, getColumnCriteria, keyPrefix) {\r\n    if (keyPrefix === void 0) { keyPrefix = ''; }\r\n    if (!grouping.length)\r\n        return rows;\r\n    var columnName = grouping[0].columnName;\r\n    var groupCriteria = (getColumnCriteria && getColumnCriteria(columnName))\r\n        || defaultColumnCriteria;\r\n    var groups = new Map();\r\n    rows.forEach(function (row) {\r\n        var rawValue = getCellValue(row, columnName);\r\n        var _a = groupCriteria(rawValue, row), key = _a.key, value = _a.value;\r\n        var sameKeyItems = groups.get(key);\r\n        if (!sameKeyItems) {\r\n            var groupingValue = value === rawValue ? value : value || key;\r\n            groups.set(key, [groupingValue, key, [row]]);\r\n        }\r\n        else {\r\n            sameKeyItems[2].push(row);\r\n        }\r\n    });\r\n    var groupedBy = grouping[0].columnName;\r\n    var nestedGrouping = grouping.slice(1);\r\n    return __spread(groups.values()).reduce(function (acc, _a) {\r\n        var _b;\r\n        var _c = __read(_a, 3), value = _c[0], key = _c[1], items = _c[2];\r\n        var compoundKey = \"\" + keyPrefix + key;\r\n        acc.push((_b = {\r\n                groupedBy: groupedBy,\r\n                compoundKey: compoundKey,\r\n                key: key,\r\n                value: value\r\n            },\r\n            _b[GRID_GROUP_CHECK] = true,\r\n            _b[GRID_GROUP_LEVEL_KEY] = GRID_GROUP_TYPE.toString() + \"_\" + groupedBy,\r\n            _b));\r\n        acc.push.apply(acc, __spread(groupedRows(items, nestedGrouping, getCellValue, getColumnCriteria, \"\" + compoundKey + GROUP_KEY_SEPARATOR)));\r\n        return acc;\r\n    }, []);\r\n};\r\nvar expandedGroupRows = function (rows, grouping, expandedGroups) {\r\n    if (!grouping.length)\r\n        return rows;\r\n    var groupingColumnNames = grouping.map(function (columnGrouping) { return columnGrouping.columnName; });\r\n    var expandedGroupsSet = new Set(expandedGroups);\r\n    var currentGroupExpanded = true;\r\n    var currentGroupLevel = 0;\r\n    return rows.reduce(function (acc, row) {\r\n        var _a;\r\n        if (!row[GRID_GROUP_CHECK]) {\r\n            if (currentGroupExpanded) {\r\n                acc.push(row);\r\n            }\r\n            else {\r\n                acc[acc.length - 1][GRID_GROUP_COLLAPSED_ROWS].push(row);\r\n            }\r\n            return acc;\r\n        }\r\n        var groupLevel = groupingColumnNames.indexOf(row.groupedBy);\r\n        if (groupLevel > currentGroupLevel && !currentGroupExpanded) {\r\n            return acc;\r\n        }\r\n        currentGroupExpanded = expandedGroupsSet.has(row.compoundKey);\r\n        currentGroupLevel = groupLevel;\r\n        if (currentGroupExpanded) {\r\n            acc.push(row);\r\n        }\r\n        else {\r\n            acc.push(__assign({}, row, (_a = {}, _a[GRID_GROUP_COLLAPSED_ROWS] = [], _a)));\r\n        }\r\n        return acc;\r\n    }, []);\r\n};\r\nvar groupCollapsedRowsGetter = function (getCollapsedRows) { return function (row) { return (row[GRID_GROUP_COLLAPSED_ROWS] || (getCollapsedRows && getCollapsedRows(row))); }; };\n\nvar customGroupedRows = function (currentRows, grouping, getChildGroups, rootRows, keyPrefix) {\r\n    if (rootRows === void 0) { rootRows = currentRows; }\r\n    if (keyPrefix === void 0) { keyPrefix = ''; }\r\n    if (!currentRows || !currentRows.length)\r\n        return [];\r\n    if (!grouping.length)\r\n        return currentRows;\r\n    var groupedBy = grouping[0].columnName;\r\n    var nestedGrouping = grouping.slice(1);\r\n    return getChildGroups(currentRows, grouping[0], rootRows)\r\n        .reduce(function (acc, _a) {\r\n        var _b;\r\n        var key = _a.key, _c = _a.value, value = _c === void 0 ? key : _c, childRows = _a.childRows;\r\n        var compoundKey = \"\" + keyPrefix + key;\r\n        acc.push((_b = {\r\n                groupedBy: groupedBy,\r\n                compoundKey: compoundKey,\r\n                key: key,\r\n                value: value\r\n            },\r\n            _b[GRID_GROUP_CHECK] = true,\r\n            _b[GRID_GROUP_LEVEL_KEY] = GRID_GROUP_TYPE.toString() + \"_\" + groupedBy,\r\n            _b));\r\n        acc.push.apply(acc, __spread(customGroupedRows(childRows, nestedGrouping, getChildGroups, rootRows, \"\" + compoundKey + GROUP_KEY_SEPARATOR)));\r\n        return acc;\r\n    }, []);\r\n};\r\nvar customGroupingRowIdGetter = function (getRowId, rows) {\r\n    var firstRow = rows.find(function (row) { return !row[GRID_GROUP_CHECK]; });\r\n    if (!firstRow || getRowId(firstRow) !== undefined) {\r\n        return getRowId;\r\n    }\r\n    var map = new Map(rows\r\n        .filter(function (row) { return !row[GRID_GROUP_CHECK]; })\r\n        .map(function (row, rowIndex) { return [row, rowIndex]; }));\r\n    return function (row) { return map.get(row); };\r\n};\n\nvar groupingPanelItems = function (columns, grouping, draftGrouping) {\r\n    var items = draftGrouping.map(function (_a) {\r\n        var columnName = _a.columnName;\r\n        return ({\r\n            column: columns.find(function (c) { return c.name === columnName; }),\r\n            draft: !grouping.some(function (columnGrouping) { return columnGrouping.columnName === columnName; }),\r\n        });\r\n    });\r\n    grouping.forEach(function (_a, index) {\r\n        var columnName = _a.columnName;\r\n        if (draftGrouping.some(function (columnGrouping) { return columnGrouping.columnName === columnName; }))\r\n            return;\r\n        items.splice(index, 0, {\r\n            column: columns.find(function (c) { return c.name === columnName; }),\r\n            draft: true,\r\n        });\r\n    });\r\n    return items;\r\n};\n\nvar setCurrentPage = function (prevPage, page) { return page; };\r\nvar setPageSize = function (prevPageSize, size) { return size; };\n\nvar clamp = function (value, max) { return (Math.max(Math.min(value, max), 0)); };\n\n// tslint:disable-next-line:max-line-length\r\nvar PAGE_HEADERS_OVERFLOW_ERROR = 'Max row level exceeds the page size. Consider increasing the page size.';\r\nvar paginatedRows = function (rows, pageSize, page) { return (pageSize\r\n    ? rows.slice(pageSize * page, pageSize * (page + 1))\r\n    : rows); };\r\nvar rowsWithPageHeaders = function (rows, pageSize, getRowLevelKey) {\r\n    if (!pageSize || !getRowLevelKey)\r\n        return rows;\r\n    var result = rows.slice();\r\n    var headerRows = [];\r\n    var currentIndex = 0;\r\n    var _loop_1 = function () {\r\n        var row = result[currentIndex];\r\n        var levelKey = getRowLevelKey(row);\r\n        if (levelKey) {\r\n            var headerIndex = headerRows.findIndex(function (headerRow) { return getRowLevelKey(headerRow) === levelKey; });\r\n            // tslint:disable-next-line:prefer-conditional-expression\r\n            if (headerIndex === -1) {\r\n                headerRows = __spread(headerRows, [row]);\r\n            }\r\n            else {\r\n                headerRows = __spread(headerRows.slice(0, headerIndex), [row]);\r\n            }\r\n            if (headerRows.length >= pageSize) {\r\n                throw new Error(PAGE_HEADERS_OVERFLOW_ERROR);\r\n            }\r\n        }\r\n        var indexInPage = currentIndex % pageSize;\r\n        if (indexInPage < headerRows.length && row !== headerRows[indexInPage]) {\r\n            result = __spread(result.slice(0, currentIndex), [\r\n                headerRows[indexInPage]\r\n            ], result.slice(currentIndex));\r\n        }\r\n        currentIndex += 1;\r\n    };\r\n    while (result.length > currentIndex) {\r\n        _loop_1();\r\n    }\r\n    return result;\r\n};\r\nvar rowCount = function (rows) { return rows.length; };\r\nvar pageCount = function (count, pageSize) { return (pageSize ? Math.ceil(count / pageSize) : 1); };\r\nvar currentPage = function (page, totalCount, pageSize, setCurrentPage) {\r\n    var totalPages = pageCount(totalCount, pageSize);\r\n    var adjustedCurrentPage = clamp(page, totalPages - 1);\r\n    if (page !== adjustedCurrentPage) {\r\n        setTimeout(function () { return setCurrentPage(adjustedCurrentPage); });\r\n    }\r\n    return adjustedCurrentPage;\r\n};\n\nvar firstRowOnPage = function (currentPage, pageSize, totalCount) {\r\n    if (totalCount === 0) {\r\n        return 0;\r\n    }\r\n    return pageSize ? (currentPage * pageSize) + 1 : 1;\r\n};\r\nvar lastRowOnPage = function (currentPage, pageSize, totalRowCount) {\r\n    var result = totalRowCount;\r\n    if (pageSize) {\r\n        var index = (currentPage + 1) * pageSize;\r\n        result = index > totalRowCount ? totalRowCount : index;\r\n    }\r\n    return result;\r\n};\r\nvar calculateStartPage = function (currentPage, maxButtonCount, totalPageCount) { return (Math.max(Math.min(currentPage - Math.floor(maxButtonCount / 2), (totalPageCount - maxButtonCount) + 1), 1)); };\n\nvar toggle = function (source, items, state) {\r\n    var itemsSet = new Set(items);\r\n    var sourceState = state;\r\n    if (sourceState === undefined) {\r\n        var availableSelection = source.filter(function (item) { return itemsSet.has(item); });\r\n        sourceState = availableSelection.length !== itemsSet.size;\r\n    }\r\n    if (sourceState) {\r\n        var sourceSet_1 = new Set(source);\r\n        return __spread(source, items.filter(function (item) { return !sourceSet_1.has(item); }));\r\n    }\r\n    return source.filter(function (item) { return !itemsSet.has(item); });\r\n};\n\nvar toggleSelection = function (selection, _a) {\r\n    var rowIds = _a.rowIds, state = _a.state;\r\n    return toggle(selection, rowIds, state);\r\n};\n\nvar rowsWithAvailableToSelect = function (rows, getRowId, isGroupRow) {\r\n    var dataRows = rows;\r\n    if (isGroupRow) {\r\n        dataRows = dataRows.filter(function (row) { return !isGroupRow(row); });\r\n    }\r\n    return { rows: rows, availableToSelect: dataRows.map(function (row) { return getRowId(row); }) };\r\n};\r\nvar someSelected = function (_a, selection) {\r\n    var availableToSelect = _a.availableToSelect;\r\n    var selectionSet = new Set(selection);\r\n    return availableToSelect.length !== 0 && selectionSet.size !== 0\r\n        && availableToSelect.some(function (elem) { return selectionSet.has(elem); })\r\n        && availableToSelect.some(function (elem) { return !selectionSet.has(elem); });\r\n};\r\nvar allSelected = function (_a, selection) {\r\n    var availableToSelect = _a.availableToSelect;\r\n    var selectionSet = new Set(selection);\r\n    return selectionSet.size !== 0 && availableToSelect.length !== 0\r\n        && !availableToSelect.some(function (elem) { return !selectionSet.has(elem); });\r\n};\r\nvar unwrapSelectedRows = function (_a) {\r\n    var rows = _a.rows;\r\n    return rows;\r\n};\n\nvar startEditRows = function (prevEditingRowIds, _a) {\r\n    var rowIds = _a.rowIds;\r\n    return __spread(prevEditingRowIds, rowIds);\r\n};\r\nvar stopEditRows = function (prevEditingRowIds, _a) {\r\n    var rowIds = _a.rowIds;\r\n    var rowIdSet = new Set(rowIds);\r\n    return prevEditingRowIds.filter(function (id) { return !rowIdSet.has(id); });\r\n};\r\nvar addRow = function (addedRows, _a) {\r\n    var row = (_a === void 0 ? { row: {} } : _a).row;\r\n    return __spread(addedRows, [row]);\r\n};\r\nvar changeAddedRow = function (addedRows, _a) {\r\n    var rowId = _a.rowId, change = _a.change;\r\n    var result = addedRows.slice();\r\n    result[rowId] = __assign({}, result[rowId], change);\r\n    return result;\r\n};\r\nvar cancelAddedRows = function (addedRows, _a) {\r\n    var rowIds = _a.rowIds;\r\n    var result = [];\r\n    var indexSet = new Set(rowIds);\r\n    addedRows.forEach(function (row, index) {\r\n        if (!indexSet.has(index)) {\r\n            result.push(row);\r\n        }\r\n    });\r\n    return result;\r\n};\r\nvar changeRow = function (prevRowChanges, _a) {\r\n    var _b;\r\n    var rowId = _a.rowId, change = _a.change;\r\n    var prevChange = prevRowChanges[rowId] || {};\r\n    return __assign({}, prevRowChanges, (_b = {}, _b[rowId] = __assign({}, prevChange, change), _b));\r\n};\r\nvar cancelChanges = function (prevRowChanges, _a) {\r\n    var rowIds = _a.rowIds;\r\n    var result = __assign({}, prevRowChanges);\r\n    rowIds.forEach(function (rowId) {\r\n        delete result[rowId];\r\n    });\r\n    return result;\r\n};\r\nvar deleteRows = function (deletedRowIds, _a) {\r\n    var rowIds = _a.rowIds;\r\n    return __spread(deletedRowIds, rowIds);\r\n};\r\nvar cancelDeletedRows = function (deletedRowIds, _a) {\r\n    var rowIds = _a.rowIds;\r\n    var rowIdSet = new Set(rowIds);\r\n    return deletedRowIds.filter(function (rowId) { return !rowIdSet.has(rowId); });\r\n};\n\nvar changedRowsByIds = function (changes, rowIds) {\r\n    var result = {};\r\n    rowIds.forEach(function (rowId) {\r\n        result[rowId] = changes[rowId];\r\n    });\r\n    return result;\r\n};\r\nvar addedRowsByIds = function (addedRows, rowIds) {\r\n    var rowIdSet = new Set(rowIds);\r\n    var result = [];\r\n    addedRows.forEach(function (row, index) {\r\n        if (rowIdSet.has(index)) {\r\n            result.push(row);\r\n        }\r\n    });\r\n    return result;\r\n};\r\nvar defaultCreateRowChange = function (row, value, columnName) {\r\n    var _a;\r\n    return (_a = {}, _a[columnName] = value, _a);\r\n};\r\nvar createRowChangeGetter = function (createRowChange, columnExtensions) {\r\n    if (createRowChange === void 0) { createRowChange = defaultCreateRowChange; }\r\n    if (columnExtensions === void 0) { columnExtensions = []; }\r\n    var map = columnExtensions.reduce(function (acc, columnExtension) {\r\n        if (columnExtension.createRowChange) {\r\n            acc[columnExtension.columnName] = columnExtension.createRowChange;\r\n        }\r\n        return acc;\r\n    }, {});\r\n    return function (row, value, columnName) {\r\n        if (map[columnName]) {\r\n            return map[columnName](row, value, columnName);\r\n        }\r\n        return createRowChange(row, value, columnName);\r\n    };\r\n};\n\nvar getRowChange = function (rowChanges, rowId) { return rowChanges[rowId] || {}; };\n\nvar TABLE_REORDERING_TYPE = Symbol('reordering');\n\nvar changeColumnOrder = function (order, _a) {\r\n    var sourceColumnName = _a.sourceColumnName, targetColumnName = _a.targetColumnName;\r\n    var sourceColumnIndex = order.indexOf(sourceColumnName);\r\n    var targetColumnIndex = order.indexOf(targetColumnName);\r\n    var newOrder = slice(order);\r\n    newOrder.splice(sourceColumnIndex, 1);\r\n    newOrder.splice(targetColumnIndex, 0, sourceColumnName);\r\n    return newOrder;\r\n};\n\nvar TABLE_DATA_TYPE = Symbol('data');\r\nvar TABLE_NODATA_TYPE = Symbol('nodata');\r\nvar TABLE_FLEX_TYPE = Symbol('flex');\n\nvar orderedColumns = function (tableColumns, order) { return mergeSort(tableColumns, function (a, b) {\r\n    if (a.type !== TABLE_DATA_TYPE || b.type !== TABLE_DATA_TYPE)\r\n        return 0;\r\n    var aPos = order.indexOf(a.column.name);\r\n    var bPos = order.indexOf(b.column.name);\r\n    return aPos - bPos;\r\n}); };\r\nvar tableHeaderRowsWithReordering = function (tableHeaderRows) { return __spread(tableHeaderRows, [\r\n    {\r\n        key: TABLE_REORDERING_TYPE.toString(),\r\n        type: TABLE_REORDERING_TYPE,\r\n        height: 0,\r\n    },\r\n]); };\r\nvar draftOrder = function (order, sourceColumnIndex, targetColumnIndex) {\r\n    if (sourceColumnIndex === -1\r\n        || targetColumnIndex === -1\r\n        || sourceColumnIndex === targetColumnIndex) {\r\n        return order;\r\n    }\r\n    var result = slice(order);\r\n    var sourceColumn = order[sourceColumnIndex];\r\n    result.splice(sourceColumnIndex, 1);\r\n    result.splice(targetColumnIndex, 0, sourceColumn);\r\n    return result;\r\n};\n\nvar UNSET_COLUMN_WIDTH_ERROR = [\r\n    'The \"$1\" column\\'s width is not specified.',\r\n    'The TableColumnResizing plugin requires that all columns have the specified width.',\r\n].join('\\n');\r\nvar specifyWidths = function (tableColumns, widths, onAbsence) {\r\n    if (!widths.length)\r\n        return tableColumns;\r\n    return tableColumns\r\n        .reduce(function (acc, tableColumn) {\r\n        if (tableColumn.type === TABLE_DATA_TYPE) {\r\n            var columnName_1 = tableColumn.column.name;\r\n            var column = widths.find(function (el) { return el.columnName === columnName_1; });\r\n            var width = column && column.width;\r\n            if (width === undefined) {\r\n                onAbsence(columnName_1);\r\n                acc.push(tableColumn);\r\n            }\r\n            else {\r\n                acc.push(__assign({}, tableColumn, { width: width }));\r\n            }\r\n        }\r\n        else {\r\n            acc.push(tableColumn);\r\n        }\r\n        return acc;\r\n    }, []);\r\n};\r\nvar tableColumnsWithWidths = function (tableColumns, columnWidths) { return specifyWidths(tableColumns, columnWidths, function (columnName) {\r\n    throw new Error(UNSET_COLUMN_WIDTH_ERROR.replace('$1', columnName));\r\n}); };\r\nvar tableColumnsWithDraftWidths = function (tableColumns, draftColumnWidths) { return specifyWidths(tableColumns, draftColumnWidths, function () { }); };\n\nvar changeTableColumnWidth = function (state, _a) {\r\n    var columnName = _a.columnName, shift = _a.shift, minColumnWidth = _a.minColumnWidth;\r\n    var columnWidths = state.columnWidths;\r\n    var nextColumnWidth = slice(columnWidths);\r\n    var index = nextColumnWidth.findIndex(function (elem) { return elem.columnName === columnName; });\r\n    var updatedColumn = nextColumnWidth[index];\r\n    var size = Math.max(minColumnWidth, updatedColumn.width + shift);\r\n    nextColumnWidth.splice(index, 1, { columnName: columnName, width: size });\r\n    return {\r\n        columnWidths: nextColumnWidth,\r\n    };\r\n};\r\nvar draftTableColumnWidth = function (state, _a) {\r\n    var columnName = _a.columnName, shift = _a.shift, minColumnWidth = _a.minColumnWidth;\r\n    var columnWidths = state.columnWidths;\r\n    var updatedColumn = columnWidths.find(function (elem) { return elem.columnName === columnName; });\r\n    var size = Math.max(minColumnWidth, updatedColumn.width + shift);\r\n    return {\r\n        draftColumnWidths: [{ columnName: updatedColumn.columnName, width: size }],\r\n    };\r\n};\r\nvar cancelTableColumnWidthDraft = function () { return ({\r\n    draftColumnWidths: [],\r\n}); };\n\nvar TABLE_EDIT_COMMAND_TYPE = Symbol('editCommand');\n\nvar TABLE_ADDED_TYPE = Symbol('added');\r\nvar TABLE_EDIT_TYPE = Symbol('edit');\n\nvar TABLE_HEADING_TYPE = Symbol('heading');\n\nvar isHeadingEditCommandsTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_HEADING_TYPE && tableColumn.type === TABLE_EDIT_COMMAND_TYPE; };\r\nvar isEditCommandsTableCell = function (tableRow, tableColumn) { return (tableRow.type === TABLE_DATA_TYPE || tableRow.type === TABLE_ADDED_TYPE\r\n    || tableRow.type === TABLE_EDIT_TYPE) && tableColumn.type === TABLE_EDIT_COMMAND_TYPE; };\n\nvar tableColumnsWithEditing = function (tableColumns, width) { return __spread([\r\n    { width: width, key: TABLE_EDIT_COMMAND_TYPE.toString(), type: TABLE_EDIT_COMMAND_TYPE }\r\n], tableColumns); };\n\nvar isEditTableCell = function (tableRow, tableColumn) { return (tableRow.type === TABLE_ADDED_TYPE || tableRow.type === TABLE_EDIT_TYPE)\r\n    && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isAddedTableRow = function (tableRow) { return tableRow.type === TABLE_ADDED_TYPE; };\r\nvar isEditTableRow = function (tableRow) { return tableRow.type === TABLE_EDIT_TYPE; };\n\nvar tableRowsWithEditing = function (tableRows, editingRowIds, addedRows, rowHeight) {\r\n    var rowIds = new Set(editingRowIds);\r\n    var editedTableRows = tableRows\r\n        .map(function (tableRow) { return (tableRow.type === TABLE_DATA_TYPE && rowIds.has(tableRow.rowId)\r\n        ? __assign({}, tableRow, { type: TABLE_EDIT_TYPE, height: rowHeight }) : tableRow); });\r\n    var addedTableRows = addedRows\r\n        .map(function (row, rowIndex) { return ({\r\n        row: row,\r\n        key: TABLE_ADDED_TYPE.toString() + \"_\" + rowIndex,\r\n        type: TABLE_ADDED_TYPE,\r\n        rowId: rowIndex,\r\n        height: rowHeight,\r\n    }); });\r\n    return __spread(slice(addedTableRows).reverse(), editedTableRows);\r\n};\n\nvar TABLE_FILTER_TYPE = Symbol('filter');\r\nvar DEFAULT_FILTER_OPERATIONS = [\r\n    'contains',\r\n    'notContains',\r\n    'startsWith',\r\n    'endsWith',\r\n    'equal',\r\n    'notEqual',\r\n];\n\nvar isFilterTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_FILTER_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isFilterTableRow = function (tableRow) { return tableRow.type === TABLE_FILTER_TYPE; };\r\nvar getColumnFilterOperations = function (getAvailableFilterOperations, columnName) { return (getAvailableFilterOperations && getAvailableFilterOperations(columnName))\r\n    || DEFAULT_FILTER_OPERATIONS; };\r\nvar isFilterValueEmpty = function (value) { return value === undefined || !String(value).length; };\r\nvar getSelectedFilterOperation = function (filterOperations, columnName, columnFilter, columnFilterOperations) {\r\n    if (columnFilter && columnFilter.operation) {\r\n        return columnFilter.operation;\r\n    }\r\n    if (filterOperations[columnName]) {\r\n        return filterOperations[columnName];\r\n    }\r\n    return columnFilterOperations[0];\r\n};\n\nvar tableHeaderRowsWithFilter = function (headerRows, rowHeight) { return __spread(headerRows, [\r\n    { key: TABLE_FILTER_TYPE.toString(), type: TABLE_FILTER_TYPE, height: rowHeight }\r\n]); };\n\nvar TABLE_GROUP_TYPE = Symbol('group');\n\nvar getGroupIndexByColumn = function (grouping, tableColumn) { return grouping.findIndex(function (columnGrouping) { return !!tableColumn.column && columnGrouping.columnName === tableColumn.column.name; }); };\r\nvar isGroupTableCell = function (tableRow, tableColumn) { return !!(tableRow.type === TABLE_GROUP_TYPE && tableColumn.type === TABLE_GROUP_TYPE\r\n    && tableColumn.column\r\n    && tableColumn.column.name === tableRow.row.groupedBy); };\r\nvar isGroupIndentTableCell = function (tableRow, tableColumn, grouping) {\r\n    if (tableRow.type !== TABLE_GROUP_TYPE || tableColumn.type !== TABLE_GROUP_TYPE)\r\n        return false;\r\n    if (tableColumn.column && tableRow.row.groupedBy === tableColumn.column.name)\r\n        return false;\r\n    var rowGroupIndex = grouping.findIndex(function (columnGrouping) { return columnGrouping.columnName === tableRow.row.groupedBy; });\r\n    var columnGroupIndex = getGroupIndexByColumn(grouping, tableColumn);\r\n    return columnGroupIndex < rowGroupIndex;\r\n};\r\nvar isGroupTableRow = function (tableRow) { return tableRow.type === TABLE_GROUP_TYPE; };\r\nvar calculateGroupCellIndent = function (tableColumn, grouping, indentWidth) { return (indentWidth * getGroupIndexByColumn(grouping, tableColumn)); };\n\nvar tableColumnsWithDraftGrouping = function (tableColumns, grouping, draftGrouping, showColumnWhenGrouped) { return tableColumns\r\n    .reduce(function (acc, tableColumn) {\r\n    if (tableColumn.type !== TABLE_DATA_TYPE) {\r\n        acc.push(tableColumn);\r\n        return acc;\r\n    }\r\n    var columnName = tableColumn.column && tableColumn.column.name || '';\r\n    var columnGroupingExists = grouping\r\n        .some(function (columnGrouping) { return columnGrouping.columnName === columnName; });\r\n    var columnDraftGroupingExists = draftGrouping\r\n        .some(function (columnGrouping) { return columnGrouping.columnName === columnName; });\r\n    if ((!columnGroupingExists && !columnDraftGroupingExists)\r\n        || showColumnWhenGrouped(columnName)) {\r\n        acc.push(tableColumn);\r\n    }\r\n    else if ((!columnGroupingExists && columnDraftGroupingExists)\r\n        || (columnGroupingExists && !columnDraftGroupingExists)) {\r\n        acc.push(__assign({}, tableColumn, { draft: true }));\r\n    }\r\n    return acc;\r\n    // tslint:disable-next-line: prefer-array-literal\r\n}, []); };\r\nvar tableColumnsWithGrouping = function (columns, tableColumns, grouping, draftGrouping, indentColumnWidth, showColumnWhenGrouped) { return __spread(grouping.map(function (columnGrouping) {\r\n    var groupedColumn = columns.find(function (column) { return column.name === columnGrouping.columnName; });\r\n    return {\r\n        key: TABLE_GROUP_TYPE.toString() + \"_\" + groupedColumn.name,\r\n        type: TABLE_GROUP_TYPE,\r\n        column: groupedColumn,\r\n        width: indentColumnWidth,\r\n    };\r\n}), tableColumnsWithDraftGrouping(tableColumns, grouping, draftGrouping, showColumnWhenGrouped)); };\r\nvar tableRowsWithGrouping = function (tableRows, isGroupRow) { return tableRows.map(function (tableRow) {\r\n    if (tableRow.type !== TABLE_DATA_TYPE || !isGroupRow(tableRow.row)) {\r\n        return tableRow;\r\n    }\r\n    return __assign({}, tableRow, { key: TABLE_GROUP_TYPE.toString() + \"_\" + tableRow.row.compoundKey, type: TABLE_GROUP_TYPE });\r\n}); };\r\nvar tableGroupCellColSpanGetter = function (getTableCellColSpan) { return function (params) {\r\n    var tableRow = params.tableRow, tableColumns = params.tableColumns, tableColumn = params.tableColumn;\r\n    if (tableRow.type === TABLE_GROUP_TYPE && tableColumn.type === TABLE_GROUP_TYPE\r\n        && tableRow.row.groupedBy === tableColumn.column.name) {\r\n        return tableColumns.length - tableColumns.indexOf(tableColumn);\r\n    }\r\n    return getTableCellColSpan(params);\r\n}; };\n\nvar isHeadingTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_HEADING_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isHeadingTableRow = function (tableRow) { return (tableRow.type === TABLE_HEADING_TYPE); };\r\nvar findChainByColumnIndex = function (chains, columnIndex) { return (chains.find(function (chain) { return (chain.start <= columnIndex && columnIndex < chain.start + chain.columns.length); })); };\r\nvar splitHeaderColumnChains = function (tableColumnChains, tableColumns, shouldSplitChain, extendChainProps) { return (tableColumnChains.map(function (row, rowIndex) { return row\r\n    .reduce(function (acc, chain) {\r\n    var currentChain = null;\r\n    chain.columns.forEach(function (col) {\r\n        var column = tableColumns.find(function (c) { return c.key === col.key; });\r\n        var isNewGroup = shouldSplitChain(currentChain, column, rowIndex);\r\n        if (isNewGroup) {\r\n            var start = currentChain\r\n                ? (currentChain.start + currentChain.columns.length)\r\n                : chain.start;\r\n            acc.push(__assign({}, chain, extendChainProps(column), { start: start, columns: [] }));\r\n            currentChain = acc[acc.length - 1];\r\n        }\r\n        currentChain.columns.push(column);\r\n    });\r\n    return acc;\r\n}, []); })); };\r\nvar generateSimpleChains = function (rows, columns) { return (rows.map(function () { return ([{\r\n        columns: columns,\r\n        start: 0,\r\n    }]); })); };\n\nvar tableRowsWithHeading = function (headerRows) { return __spread([\r\n    { key: TABLE_HEADING_TYPE.toString(), type: TABLE_HEADING_TYPE }\r\n], headerRows); };\n\nvar TABLE_BAND_TYPE = Symbol('band');\r\nvar BAND_GROUP_CELL = 'bandGroupCell';\r\nvar BAND_HEADER_CELL = 'bandHeaderCell';\r\nvar BAND_EMPTY_CELL = 'bandEmptyCell';\r\nvar BAND_DUPLICATE_RENDER = 'bandDuplicateRender';\n\nvar isBandedTableRow = function (tableRow) { return (tableRow.type === TABLE_BAND_TYPE); };\r\nvar isBandedOrHeaderRow = function (tableRow) { return isBandedTableRow(tableRow)\r\n    || tableRow.type === TABLE_HEADING_TYPE; };\r\nvar isNoDataColumn = function (columnType) { return columnType !== TABLE_DATA_TYPE; };\r\nvar getColumnMeta = function (columnName, bands, tableRowLevel, level, title, result) {\r\n    if (level === void 0) { level = 0; }\r\n    if (title === void 0) { title = null; }\r\n    if (result === void 0) { result = null; }\r\n    return bands.reduce(function (acc, column) {\r\n        if (column.columnName === columnName) {\r\n            return __assign({}, acc, { title: title, level: level });\r\n        }\r\n        if (column.children !== undefined) {\r\n            return getColumnMeta(columnName, column.children, tableRowLevel, level + 1, level > tableRowLevel ? title : column.title, acc);\r\n        }\r\n        return acc;\r\n    }, result || { level: level, title: title });\r\n};\r\nvar getBandComponent = function (_a, tableHeaderRows, tableColumns, columnBands, tableHeaderColumnChains) {\r\n    var currentTableColumn = _a.tableColumn, tableRow = _a.tableRow, rowSpan = _a.rowSpan;\r\n    if (rowSpan)\r\n        return { type: BAND_DUPLICATE_RENDER, payload: null };\r\n    var maxLevel = tableHeaderRows.filter(function (column) { return column.type === TABLE_BAND_TYPE; }).length + 1;\r\n    var level = tableRow.level;\r\n    var currentRowLevel = level === undefined\r\n        ? maxLevel - 1 : level;\r\n    var currentColumnMeta = currentTableColumn.type === TABLE_DATA_TYPE\r\n        ? getColumnMeta(currentTableColumn.column.name, columnBands, currentRowLevel)\r\n        : { level: 0, title: '' };\r\n    if (currentColumnMeta.level < currentRowLevel)\r\n        return { type: BAND_EMPTY_CELL, payload: null };\r\n    var currentColumnIndex = tableColumns\r\n        .findIndex(function (column) { return column.key === currentTableColumn.key; });\r\n    var previousTableColumn = tableColumns[currentColumnIndex - 1];\r\n    var beforeBorder = false;\r\n    if (currentColumnIndex > 0 && currentTableColumn.type === TABLE_DATA_TYPE\r\n        && isNoDataColumn(previousTableColumn.type)) {\r\n        beforeBorder = true;\r\n    }\r\n    if (currentColumnMeta.level === currentRowLevel) {\r\n        return {\r\n            type: BAND_HEADER_CELL,\r\n            payload: __assign({ tableRow: tableHeaderRows.find(function (row) { return row.type === TABLE_HEADING_TYPE; }), rowSpan: maxLevel - currentRowLevel }, beforeBorder && { beforeBorder: beforeBorder }),\r\n        };\r\n    }\r\n    var currentColumnChain = findChainByColumnIndex(tableHeaderColumnChains[currentRowLevel], currentColumnIndex);\r\n    if (currentColumnChain.start < currentColumnIndex) {\r\n        return { type: null, payload: null };\r\n    }\r\n    return {\r\n        type: BAND_GROUP_CELL,\r\n        payload: __assign({ colSpan: currentColumnChain.columns.length, value: currentColumnMeta.title, column: currentColumnMeta }, beforeBorder && { beforeBorder: beforeBorder }),\r\n    };\r\n};\n\nvar tableRowsWithBands = function (tableHeaderRows, columnBands, tableColumns) {\r\n    var tableDataColumns = tableColumns.filter(function (column) { return column.type === TABLE_DATA_TYPE; });\r\n    var getMaxNestedLevel = function (bands, level, result) {\r\n        if (level === void 0) { level = 0; }\r\n        if (result === void 0) { result = null; }\r\n        return (bands.reduce(function (acc, column) {\r\n            if (column.children !== undefined) {\r\n                return getMaxNestedLevel(column.children, level + 1, acc);\r\n            }\r\n            var isDataColumn = tableDataColumns.findIndex(function (dataColumn) { return !!dataColumn.column && dataColumn.column.name === column.columnName; }) > -1;\r\n            if (level > acc.level && isDataColumn) {\r\n                return __assign({}, acc, { level: level });\r\n            }\r\n            return acc;\r\n        }, result || { level: 0 }));\r\n    };\r\n    var tableBandHeaders = Array.from({\r\n        length: getMaxNestedLevel(columnBands, 0).level,\r\n    })\r\n        .map(function (row, index) { return ({\r\n        key: TABLE_BAND_TYPE.toString() + \"_\" + index,\r\n        type: TABLE_BAND_TYPE,\r\n        level: index,\r\n    }); });\r\n    return __spread(tableBandHeaders, tableHeaderRows);\r\n};\r\nvar tableHeaderColumnChainsWithBands = function (tableHeaderRows, tableColumns, bands) {\r\n    var chains = generateSimpleChains(tableHeaderRows, tableColumns);\r\n    var maxBandRowIndex = tableHeaderRows\r\n        .filter(function (row) { return row.type === TABLE_BAND_TYPE; })\r\n        .length;\r\n    var rawBandChains = chains.slice(0, maxBandRowIndex);\r\n    var currentBand = null;\r\n    var shouldSplitChain = function (chain, column, rowIndex) {\r\n        if (rowIndex > maxBandRowIndex)\r\n            return false;\r\n        var columnName = column.column && column.column.name || '';\r\n        currentBand = getColumnMeta(columnName, bands, rowIndex);\r\n        return !chain\r\n            || chain.bandTitle !== currentBand.title;\r\n    };\r\n    var extendChainProps = function () { return ({\r\n        bandTitle: (currentBand || {}).title,\r\n    }); };\r\n    var bandChains = splitHeaderColumnChains(rawBandChains, tableColumns, shouldSplitChain, extendChainProps);\r\n    return __spread(bandChains, chains.slice(maxBandRowIndex));\r\n};\n\nvar toggleDetailRowExpanded = function (prevExpanded, _a) {\r\n    var rowId = _a.rowId, state = _a.state;\r\n    return toggle(prevExpanded, [rowId], state);\r\n};\n\nvar TABLE_DETAIL_TYPE = Symbol('detail');\n\nvar isDetailRowExpanded = function (expandedDetailRowIds, rowId) { return expandedDetailRowIds.indexOf(rowId) > -1; };\r\nvar isDetailToggleTableCell = function (tableRow, tableColumn) { return tableColumn.type === TABLE_DETAIL_TYPE && tableRow.type === TABLE_DATA_TYPE; };\r\nvar isDetailTableRow = function (tableRow) { return tableRow.type === TABLE_DETAIL_TYPE; };\r\nvar isDetailTableCell = function (tableColumn, tableColumns) { return tableColumns.indexOf(tableColumn) === 0; };\n\nvar tableRowsWithExpandedDetail = function (tableRows, expandedDetailRowIds, rowHeight) {\r\n    var result = tableRows;\r\n    expandedDetailRowIds\r\n        .forEach(function (expandedRowId) {\r\n        var rowIndex = result.findIndex(function (tableRow) { return tableRow.type === TABLE_DATA_TYPE && tableRow.rowId === expandedRowId; });\r\n        if (rowIndex === -1)\r\n            return;\r\n        var insertIndex = rowIndex + 1;\r\n        var _a = result[rowIndex], row = _a.row, rowId = _a.rowId;\r\n        result = __spread(result.slice(0, insertIndex), [\r\n            {\r\n                rowId: rowId,\r\n                row: row,\r\n                key: TABLE_DETAIL_TYPE.toString() + \"_\" + rowId,\r\n                type: TABLE_DETAIL_TYPE,\r\n                height: rowHeight,\r\n            }\r\n        ], result.slice(insertIndex));\r\n    });\r\n    return result;\r\n};\r\nvar tableColumnsWithDetail = function (tableColumns, toggleColumnWidth) { return __spread([\r\n    { key: TABLE_DETAIL_TYPE.toString(), type: TABLE_DETAIL_TYPE, width: toggleColumnWidth }\r\n], tableColumns); };\r\nvar tableDetailCellColSpanGetter = function (getTableCellColSpan) { return function (params) {\r\n    var tableRow = params.tableRow, tableColumns = params.tableColumns, tableColumn = params.tableColumn;\r\n    if (tableRow.type === TABLE_DETAIL_TYPE && tableColumns.indexOf(tableColumn) === 0) {\r\n        return tableColumns.length;\r\n    }\r\n    return getTableCellColSpan(params);\r\n}; };\n\nvar TABLE_SELECT_TYPE = Symbol('select');\n\nvar isSelectTableCell = function (tableRow, tableColumn) { return tableColumn.type === TABLE_SELECT_TYPE && tableRow.type === TABLE_DATA_TYPE; };\r\nvar isSelectAllTableCell = function (tableRow, tableColumn) { return tableColumn.type === TABLE_SELECT_TYPE && tableRow.type === TABLE_HEADING_TYPE; };\r\nvar isRowHighlighted = function (highlightRow, selection, tableRow) { return (highlightRow && selection && selection.includes(tableRow.rowId)); };\n\nvar tableColumnsWithSelection = function (tableColumns, selectionColumnWidth) { return __spread([\r\n    { key: TABLE_SELECT_TYPE.toString(), type: TABLE_SELECT_TYPE, width: selectionColumnWidth }\r\n], tableColumns); };\n\nvar TABLE_STUB_TYPE = Symbol('stub');\r\nvar getVisibleBoundaryWithFixed = function (visibleBoundary, items) { return items.reduce(function (acc, item, index) {\r\n    if (item.fixed && (index < visibleBoundary[0] || index > visibleBoundary[1])) {\r\n        acc.push([index, index]);\r\n    }\r\n    return acc;\r\n}, [visibleBoundary]); };\r\nvar getVisibleBoundary = function (items, viewportStart, viewportSize, getItemSize, offset, itemSize) {\r\n    if (offset === void 0) { offset = 0; }\r\n    if (itemSize === void 0) { itemSize = 0; }\r\n    var start = null;\r\n    var end = null;\r\n    var index = 0;\r\n    var beforePosition = offset * itemSize;\r\n    var noVisibleRowsLoaded = itemSize > 0 &&\r\n        beforePosition + items.length * itemSize < viewportStart ||\r\n        viewportStart < beforePosition;\r\n    if (noVisibleRowsLoaded) {\r\n        beforePosition = viewportStart;\r\n        index = items.length;\r\n        start = Math.round(viewportStart / itemSize) - offset;\r\n        end = start;\r\n    }\r\n    var viewportEnd = viewportStart + viewportSize;\r\n    while (end === null && index < items.length) {\r\n        var item = items[index];\r\n        var afterPosition = beforePosition + getItemSize(item);\r\n        var isVisible = (beforePosition >= viewportStart && beforePosition < viewportEnd)\r\n            || (afterPosition > viewportStart && afterPosition <= viewportEnd)\r\n            || (beforePosition < viewportStart && afterPosition > viewportEnd);\r\n        if (isVisible && start === null) {\r\n            start = index;\r\n        }\r\n        if (!isVisible && start !== null) {\r\n            end = index - 1;\r\n            break;\r\n        }\r\n        index += 1;\r\n        beforePosition = afterPosition;\r\n    }\r\n    if (start !== null && end === null) {\r\n        end = index - 1;\r\n    }\r\n    start = start === null ? 0 : start;\r\n    end = end === null ? 0 : end;\r\n    return [start + offset, end + offset];\r\n};\r\nvar getRenderBoundary = function (itemsCount, visibleBoundary, overscan) {\r\n    var _a = __read(visibleBoundary, 2), start = _a[0], end = _a[1];\r\n    start = Math.max(0, start - overscan);\r\n    end = Math.min(itemsCount - 1, end + overscan);\r\n    return [start, end];\r\n};\r\nvar getColumnBoundaries = function (columns, left, width, getColumnWidth) { return (getVisibleBoundaryWithFixed(getColumnsRenderBoundary(columns.length, getVisibleBoundary(columns, left, width, getColumnWidth, 0)), columns)); };\r\nvar getRowsVisibleBoundary = function (rows, top, height, getRowHeight, offset, rowHeight) {\r\n    var boundaries = getVisibleBoundary(rows, top, height, getRowHeight, offset, rowHeight);\r\n    var start = boundaries[0];\r\n    var end = boundaries[1];\r\n    return {\r\n        start: start,\r\n        end: end,\r\n    };\r\n};\r\nvar getColumnsRenderBoundary = function (columnCount, visibleBoundary) { return getRenderBoundary(columnCount, visibleBoundary, 1); };\r\nvar getRowsRenderBoundary = function (rowsCount, visibleBoundary) { return getRenderBoundary(rowsCount, visibleBoundary, 3); };\r\nvar getSpanBoundary = function (items, visibleBoundaries, getItemSpan) { return visibleBoundaries\r\n    .map(function (visibleBoundary) {\r\n    var _a = __read(visibleBoundary, 2), start = _a[0], end = _a[1];\r\n    for (var index = 0; index <= visibleBoundary[1]; index += 1) {\r\n        var span = getItemSpan(items[index]);\r\n        if (index < visibleBoundary[0] && index + span > visibleBoundary[0]) {\r\n            start = index;\r\n        }\r\n        if (index + (span - 1) > visibleBoundary[1]) {\r\n            end = index + (span - 1);\r\n        }\r\n    }\r\n    return [start, end];\r\n}); };\r\nvar collapseBoundaries = function (itemsCount, visibleBoundaries, spanBoundaries) {\r\n    var breakpoints = new Set([0, itemsCount]);\r\n    spanBoundaries.forEach(function (rowBoundaries) { return rowBoundaries\r\n        .forEach(function (boundary) {\r\n        breakpoints.add(boundary[0]);\r\n        if (boundary[1] - 1 < itemsCount) {\r\n            // next interval starts after span end point\r\n            breakpoints.add(boundary[1] + 1);\r\n        }\r\n    }); });\r\n    visibleBoundaries\r\n        .filter(function (boundary) { return boundary.every(function (bound) { return 0 <= bound && bound < itemsCount; }); })\r\n        .forEach(function (boundary) {\r\n        for (var point = boundary[0]; point <= boundary[1]; point += 1) {\r\n            breakpoints.add(point);\r\n        }\r\n        if (boundary[1] + 1 < itemsCount) {\r\n            // close last visible point\r\n            breakpoints.add(boundary[1] + 1);\r\n        }\r\n    });\r\n    var bp = __spread(breakpoints).sort(function (a, b) { return a - b; });\r\n    var bounds = [];\r\n    for (var i = 0; i < bp.length - 1; i += 1) {\r\n        bounds.push([\r\n            bp[i],\r\n            bp[i + 1] - 1,\r\n        ]);\r\n    }\r\n    return bounds;\r\n};\r\nvar getColumnsSize = function (columns, startIndex, endIndex, getColumnSize) {\r\n    var size = 0;\r\n    for (var i = startIndex; i <= endIndex; i += 1) {\r\n        size += getColumnSize(columns[i], 0) || 0;\r\n    }\r\n    return size;\r\n};\r\nvar getCollapsedColumns = function (columns, visibleBoundaries, boundaries, getColumnWidth) {\r\n    var collapsedColumns = [];\r\n    boundaries.forEach(function (boundary) {\r\n        var isVisible = visibleBoundaries.reduce(function (acc, visibleBoundary) { return (acc || (visibleBoundary[0] <= boundary[0] && boundary[1] <= visibleBoundary[1])); }, false);\r\n        if (isVisible) {\r\n            var column = columns[boundary[0]];\r\n            collapsedColumns.push(__assign({}, column, { width: getColumnWidth(column) }));\r\n        }\r\n        else {\r\n            collapsedColumns.push({\r\n                key: TABLE_STUB_TYPE.toString() + \"_\" + boundary[0] + \"_\" + boundary[1],\r\n                type: TABLE_STUB_TYPE,\r\n                width: getColumnsSize(columns, boundary[0], boundary[1], getColumnWidth),\r\n            });\r\n        }\r\n    });\r\n    return collapsedColumns;\r\n};\r\nvar getCollapsedRows = function (rows, visibleBoundary, boundaries, getRowHeight, getCells, offset) {\r\n    var collapsedRows = [];\r\n    boundaries.forEach(function (boundary) {\r\n        var isVisible = visibleBoundary[0] <= boundary[0] && boundary[1] <= visibleBoundary[1];\r\n        if (isVisible) {\r\n            var row = rows[boundary[0] - offset];\r\n            collapsedRows.push({\r\n                row: row,\r\n                cells: getCells(row),\r\n            });\r\n        }\r\n        else {\r\n            var row = {};\r\n            collapsedRows.push({\r\n                row: {\r\n                    key: TABLE_STUB_TYPE.toString() + \"_\" + boundary[0] + \"_\" + boundary[1],\r\n                    type: TABLE_STUB_TYPE,\r\n                    height: getColumnsSize(rows, boundary[0], boundary[1], getRowHeight),\r\n                },\r\n                cells: getCells(row),\r\n            });\r\n        }\r\n    });\r\n    return collapsedRows;\r\n};\r\nvar getCollapsedCells = function (columns, spanBoundaries, boundaries, getColSpan) {\r\n    var collapsedCells = [];\r\n    var index = 0;\r\n    var _loop_1 = function () {\r\n        var boundary = boundaries[index];\r\n        var isSpan = spanBoundaries.reduce(function (acc, spanBoundary) { return (acc || (spanBoundary[0] <= boundary[0] && boundary[1] <= spanBoundary[1])); }, false);\r\n        if (isSpan) {\r\n            var column = columns[boundary[0]];\r\n            var realColSpan = getColSpan(column);\r\n            var realColSpanEnd_1 = (realColSpan + boundary[0]) - 1;\r\n            var colSpanEnd = boundaries.findIndex(function (colSpanBoundary) { return colSpanBoundary[0]\r\n                <= realColSpanEnd_1 && realColSpanEnd_1\r\n                <= colSpanBoundary[1]; });\r\n            collapsedCells.push({\r\n                column: column,\r\n                colSpan: (colSpanEnd - index) + 1,\r\n            });\r\n            index += 1;\r\n        }\r\n        else {\r\n            collapsedCells.push({\r\n                column: {\r\n                    key: TABLE_STUB_TYPE.toString() + \"_\" + boundary[0] + \"_\" + boundary[1],\r\n                    type: TABLE_STUB_TYPE,\r\n                },\r\n                colSpan: 1,\r\n            });\r\n            index += 1;\r\n        }\r\n    };\r\n    while (index < boundaries.length) {\r\n        _loop_1();\r\n    }\r\n    return collapsedCells;\r\n};\r\nvar getCollapsedGrid = function (_a) {\r\n    var rows = _a.rows, columns = _a.columns, rowsVisibleBoundary = _a.rowsVisibleBoundary, columnsVisibleBoundary = _a.columnsVisibleBoundary, _b = _a.getColumnWidth, getColumnWidth = _b === void 0 ? function (column) { return column.width; } : _b, _c = _a.getRowHeight, getRowHeight = _c === void 0 ? function (row) { return row.height; } : _c, _d = _a.getColSpan, getColSpan = _d === void 0 ? function () { return 1; } : _d, totalRowCount = _a.totalRowCount, offset = _a.offset;\r\n    if (!columns.length) {\r\n        return {\r\n            columns: [],\r\n            rows: [],\r\n        };\r\n    }\r\n    var boundaries = rowsVisibleBoundary || [0, rows.length - 1 || 1];\r\n    var rowSpanBoundaries = rows\r\n        .slice(boundaries[0], boundaries[1])\r\n        .map(function (row) { return getSpanBoundary(columns, columnsVisibleBoundary, function (column) { return getColSpan(row, column); }); });\r\n    var columnBoundaries = collapseBoundaries(columns.length, columnsVisibleBoundary, rowSpanBoundaries);\r\n    var rowBoundaries = collapseBoundaries(totalRowCount, [boundaries], []);\r\n    return {\r\n        columns: getCollapsedColumns(columns, columnsVisibleBoundary, columnBoundaries, getColumnWidth),\r\n        rows: getCollapsedRows(rows, boundaries, rowBoundaries, getRowHeight, function (row) { return getCollapsedCells(columns, getSpanBoundary(columns, columnsVisibleBoundary, function (column) { return getColSpan(row, column); }), columnBoundaries, function (column) { return getColSpan(row, column); }); }, offset),\r\n    };\r\n};\r\nvar getColumnWidthGetter = function (tableColumns, tableWidth, minColumnWidth) {\r\n    var colsHavingWidth = tableColumns.filter(function (col) { return col.width !== undefined; });\r\n    var columnsWidth = colsHavingWidth.reduce(function (acc, col) { return (acc + col.width); }, 0);\r\n    var autoWidth = (tableWidth - columnsWidth) / (tableColumns.length - colsHavingWidth.length);\r\n    var autoColWidth = Math.max(autoWidth, minColumnWidth);\r\n    return function (column) { return (column.type === TABLE_FLEX_TYPE\r\n        ? null\r\n        : column.width || autoColWidth); };\r\n};\r\nvar getCollapsedGrids = function (_a) {\r\n    var _b = _a.headerRows, headerRows = _b === void 0 ? [] : _b, _c = _a.bodyRows, bodyRows = _c === void 0 ? [] : _c, _d = _a.footerRows, footerRows = _d === void 0 ? [] : _d, columns = _a.columns, loadedRowsStart = _a.loadedRowsStart, totalRowCount = _a.totalRowCount, getCellColSpan = _a.getCellColSpan, viewportLeft = _a.viewportLeft, containerWidth = _a.containerWidth, visibleRowBoundaries = _a.visibleRowBoundaries, getColumnWidth = _a.getColumnWidth, getRowHeight = _a.getRowHeight;\r\n    var getColSpan = function (tableRow, tableColumn) { return getCellColSpan({ tableRow: tableRow, tableColumn: tableColumn, tableColumns: columns }); };\r\n    var columnBoundaries = getColumnBoundaries(columns, viewportLeft, containerWidth, getColumnWidth);\r\n    var getCollapsedGridBlock = function (rows, rowsVisibleBoundary, rowCount, offset) {\r\n        if (rowCount === void 0) { rowCount = rows.length; }\r\n        if (offset === void 0) { offset = 0; }\r\n        return getCollapsedGrid({\r\n            rows: rows,\r\n            columns: columns,\r\n            rowsVisibleBoundary: rowsVisibleBoundary,\r\n            columnsVisibleBoundary: columnBoundaries,\r\n            getColumnWidth: getColumnWidth,\r\n            getRowHeight: getRowHeight,\r\n            getColSpan: getColSpan,\r\n            totalRowCount: rowCount,\r\n            offset: offset,\r\n        });\r\n    };\r\n    var headerGrid = getCollapsedGridBlock(headerRows, getRenderRowBounds(visibleRowBoundaries.header, headerRows.length));\r\n    var bodyGrid = getCollapsedGridBlock(bodyRows, adjustedRenderRowBounds(visibleRowBoundaries.body, bodyRows.length, loadedRowsStart), totalRowCount || 1, loadedRowsStart);\r\n    var footerGrid = getCollapsedGridBlock(footerRows, getRenderRowBounds(visibleRowBoundaries.footer, footerRows.length));\r\n    return {\r\n        headerGrid: headerGrid,\r\n        bodyGrid: bodyGrid,\r\n        footerGrid: footerGrid,\r\n    };\r\n};\r\nvar getRenderRowBounds = function (visibleBounds, rowCount) { return getRowsRenderBoundary(rowCount, [visibleBounds.start, visibleBounds.end]); };\r\nvar adjustedRenderRowBounds = function (visibleBounds, rowCount, loadedRowsStart) {\r\n    var renderRowBoundaries = getRenderRowBounds(visibleBounds, loadedRowsStart + rowCount);\r\n    var adjustedInterval = intervalUtil.intersect({ start: renderRowBoundaries[0], end: renderRowBoundaries[1] }, { start: loadedRowsStart, end: loadedRowsStart + rowCount });\r\n    return [adjustedInterval.start, adjustedInterval.end];\r\n};\n\nvar isDataTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_DATA_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isHeaderStubTableCell = function (tableRow, headerRows) { return headerRows.indexOf(tableRow) > -1; };\r\nvar isDataTableRow = function (tableRow) { return tableRow.type === TABLE_DATA_TYPE; };\r\nvar isNoDataTableRow = function (tableRow) { return tableRow.type === TABLE_NODATA_TYPE; };\r\nvar isNoDataTableCell = function (tableColumn, tableColumns) { return tableColumns.indexOf(tableColumn) === 0; };\r\nvar isStubTableCell = function (tableRow) { return (tableRow.type === TABLE_STUB_TYPE); };\n\nvar getColumnExtension = function (columnExtensions, columnName) {\r\n    if (!columnExtensions) {\r\n        // tslint:disable-next-line:no-object-literal-type-assertion\r\n        return {};\r\n    }\r\n    var columnExtension = columnExtensions.find(function (extension) { return extension.columnName === columnName; });\r\n    if (!columnExtension) {\r\n        // tslint:disable-next-line:no-object-literal-type-assertion\r\n        return {};\r\n    }\r\n    return columnExtension;\r\n};\r\nvar getColumnExtensionValueGetter = function (columnExtensions, extensionName, defaultValue) { return function (columnName) {\r\n    if (columnExtensions) {\r\n        var columnExtension = getColumnExtension(columnExtensions, columnName);\r\n        var extensionValue = columnExtension[extensionName];\r\n        return extensionValue !== undefined ? extensionValue : defaultValue;\r\n    }\r\n    return defaultValue;\r\n}; };\n\nvar tableColumnsWithDataRows = function (columns, columnExtensions) { return columns.map(function (column) {\r\n    var name = column.name;\r\n    var columnExtension = getColumnExtension(columnExtensions, name);\r\n    return {\r\n        column: column,\r\n        key: TABLE_DATA_TYPE.toString() + \"_\" + name,\r\n        type: TABLE_DATA_TYPE,\r\n        width: columnExtension.width,\r\n        align: columnExtension.align,\r\n        wordWrapEnabled: columnExtension.wordWrapEnabled,\r\n    };\r\n}); };\r\nvar tableRowsWithDataRows = function (rows, getRowId, isRemoteRowsLoading) { return (!rows.length && !isRemoteRowsLoading\r\n    ? [{ key: TABLE_NODATA_TYPE.toString(), type: TABLE_NODATA_TYPE }]\r\n    : rows.map(function (row, dataIndex) {\r\n        var rowId = getRowId(row);\r\n        return {\r\n            row: row,\r\n            // dataIndex,\r\n            rowId: rowId,\r\n            type: TABLE_DATA_TYPE,\r\n            key: TABLE_DATA_TYPE.toString() + \"_\" + rowId,\r\n        };\r\n    })); };\r\nvar tableCellColSpanGetter = function (params) {\r\n    var tableRow = params.tableRow, tableColumns = params.tableColumns, tableColumn = params.tableColumn;\r\n    if (tableRow.type === TABLE_NODATA_TYPE && tableColumns.indexOf(tableColumn) === 0) {\r\n        return tableColumns.length;\r\n    }\r\n    return 1;\r\n};\n\nvar visibleTableColumns = function (tableColumns, hiddenColumnNames) { return tableColumns.filter(function (tableColumn) { return tableColumn.type !== TABLE_DATA_TYPE\r\n    || hiddenColumnNames.indexOf(tableColumn.column.name) === -1; }); };\n\nvar tableDataColumnsExist = function (tableColumns) { return tableColumns.some(function (column) { return column.type === TABLE_DATA_TYPE; }); };\n\nvar columnChooserItems = function (columns, hiddenColumnNames) { return columns.map(function (column) { return ({\r\n    column: column,\r\n    hidden: hiddenColumnNames.indexOf(column.name) !== -1,\r\n}); }); };\n\nvar toggleColumn = function (hiddenColumnNames, columnName) { return (hiddenColumnNames.indexOf(columnName) === -1\r\n    ? __spread(hiddenColumnNames, [columnName]) : hiddenColumnNames.filter(function (hiddenColumn) { return hiddenColumn !== columnName; })); };\n\nvar toggleRowExpanded = function (prevExpanded, _a) {\r\n    var rowId = _a.rowId, state = _a.state;\r\n    return toggle(prevExpanded, [rowId], state);\r\n};\n\nvar GRID_TREE_NODE_TYPE = Symbol('treeNode');\n\nvar customTreeRows = function (currentRow, getChildRows, rootRows, level) {\r\n    if (level === void 0) { level = 0; }\r\n    var childRows = getChildRows(currentRow, rootRows);\r\n    if (!childRows)\r\n        return { rows: [], treeMeta: [], empty: true };\r\n    return childRows\r\n        .reduce(function (acc, row) {\r\n        var _a, _b;\r\n        var nestedResult = customTreeRows(row, getChildRows, rootRows, level + 1);\r\n        (_a = acc.rows).push.apply(_a, __spread([row], nestedResult.rows));\r\n        (_b = acc.treeMeta).push.apply(_b, __spread([[row, { level: level, leaf: !!nestedResult.empty }]], nestedResult.treeMeta));\r\n        return acc;\r\n    }, { rows: [], treeMeta: [] });\r\n};\r\nvar customTreeRowsWithMeta = function (rows, getChildRows) {\r\n    var result = customTreeRows(null, getChildRows, rows);\r\n    return {\r\n        rows: result.rows,\r\n        treeMeta: new Map(result.treeMeta),\r\n    };\r\n};\r\nvar customTreeRowIdGetter = function (getRowId, _a) {\r\n    var rows = _a.rows, treeMeta = _a.treeMeta;\r\n    var firstNestedRowIndex = rows.findIndex(function (row) { return treeMeta.get(row).level > 0; });\r\n    if (firstNestedRowIndex === -1 || getRowId(rows[firstNestedRowIndex]) !== undefined) {\r\n        return getRowId;\r\n    }\r\n    var map = new Map(rows\r\n        .map(function (row, rowIndex) { return [row, rowIndex]; }));\r\n    return function (row) { return map.get(row); };\r\n};\r\nvar customTreeRowLevelKeyGetter = function (getRowLevelKey, _a) {\r\n    var treeMeta = _a.treeMeta;\r\n    return function (row) {\r\n        var rowMeta = treeMeta.get(row);\r\n        if (rowMeta !== undefined) {\r\n            return GRID_TREE_NODE_TYPE.toString() + \"_\" + rowMeta.level;\r\n        }\r\n        return getRowLevelKey && getRowLevelKey();\r\n    };\r\n};\r\nvar expandedTreeRows = function (_a, getRowId, expandedRowIds) {\r\n    var rows = _a.rows, treeMeta = _a.treeMeta;\r\n    var expandedRowIdsSet = new Set(expandedRowIds);\r\n    var currentExpanded = true;\r\n    var currentLevel = 0;\r\n    var collapsedRowsMeta = new Map();\r\n    var resultRows = [];\r\n    rows.forEach(function (row) {\r\n        var rowMeta = treeMeta.get(row);\r\n        var level = rowMeta && rowMeta.level;\r\n        if (level === undefined && currentExpanded) {\r\n            resultRows.push(row);\r\n        }\r\n        else if (!currentExpanded && (level === undefined || level > currentLevel)) {\r\n            var lastRow = resultRows[resultRows.length - 1];\r\n            var collapsedItems = collapsedRowsMeta.get(lastRow);\r\n            if (!collapsedItems) {\r\n                collapsedItems = [];\r\n                collapsedRowsMeta.set(lastRow, collapsedItems);\r\n            }\r\n            collapsedItems.push(row);\r\n        }\r\n        else {\r\n            currentExpanded = expandedRowIdsSet.has(getRowId(row));\r\n            currentLevel = level;\r\n            resultRows.push(row);\r\n        }\r\n    });\r\n    return {\r\n        treeMeta: treeMeta,\r\n        collapsedRowsMeta: collapsedRowsMeta,\r\n        rows: resultRows,\r\n    };\r\n};\r\nvar collapsedTreeRowsGetter = function (getCollapsedRows, _a) {\r\n    var collapsedRowsMeta = _a.collapsedRowsMeta;\r\n    return function (row) { return collapsedRowsMeta.get(row) || (getCollapsedRows && getCollapsedRows(row)); };\r\n};\r\nvar isTreeRowLeafGetter = function (_a) {\r\n    var treeMeta = _a.treeMeta;\r\n    return function (row) {\r\n        var rowMeta = treeMeta.get(row);\r\n        return rowMeta && rowMeta.leaf;\r\n    };\r\n};\r\nvar getTreeRowLevelGetter = function (_a) {\r\n    var treeMeta = _a.treeMeta;\r\n    return function (row) {\r\n        var rowMeta = treeMeta.get(row);\r\n        return (rowMeta && rowMeta.level);\r\n    };\r\n};\r\nvar unwrappedCustomTreeRows = function (_a) {\r\n    var rows = _a.rows;\r\n    return rows;\r\n};\n\nvar isTreeTableCell = function (tableRow, tableColumn, forColumnName) { return tableRow.type === TABLE_DATA_TYPE && tableColumn.type === TABLE_DATA_TYPE\r\n    && tableColumn.column.name === forColumnName; };\n\nvar changeSearchValue = function (prevSearchValue, searchValue) { return searchValue; };\n\nvar searchFilterExpression = function (searchValue, columns, filterExpression) {\r\n    var filters = columns.map(function (_a) {\r\n        var name = _a.name;\r\n        return ({ columnName: name, value: searchValue });\r\n    });\r\n    var selfFilterExpression = { filters: filters, operator: 'or' };\r\n    if (!filterExpression) {\r\n        return selfFilterExpression;\r\n    }\r\n    return {\r\n        operator: 'and',\r\n        filters: [filterExpression, selfFilterExpression],\r\n    };\r\n};\n\nvar getAvailableFilterOperationsGetter = function (getAvailableFilterOperations, availableFilterOperations, columnNames) { return function (columnName) { return (columnNames.indexOf(columnName) > -1 && availableFilterOperations)\r\n    // tslint:disable-next-line: max-line-length\r\n    || (typeof getAvailableFilterOperations === 'function' && getAvailableFilterOperations(columnName))\r\n    || undefined; }; };\n\nvar FIXED_COLUMN_LEFT_SIDE = 'left';\r\nvar FIXED_COLUMN_RIGHT_SIDE = 'right';\r\nvar TABLE_FIXED_TYPE = Symbol('fixed');\n\nvar getFixedColumnKeys = function (tableColumns, fixedNames) { return tableColumns\r\n    .filter(function (tableColumn) { return ((tableColumn.type === TABLE_DATA_TYPE && fixedNames.indexOf(tableColumn.column.name) !== -1)\r\n    || fixedNames.indexOf(tableColumn.type) !== -1); })\r\n    .map(function (_a) {\r\n    var key = _a.key;\r\n    return key;\r\n}); };\r\nvar isFixedTableRow = function (tableRow) { return tableRow.type === TABLE_FIXED_TYPE; };\r\nvar calculatePosition = function (array, index, tableColumnDimensions) { return (index === 0\r\n    ? 0\r\n    : array\r\n        .slice(0, index)\r\n        .reduce(function (acc, target) { return acc + tableColumnDimensions[target] || 0; }, 0)); };\r\nvar calculateFixedColumnProps = function (_a, _b, tableColumns, tableColumnDimensions, tableHeaderColumnChains) {\r\n    var tableColumn = _a.tableColumn;\r\n    var leftColumns = _b.leftColumns, rightColumns = _b.rightColumns;\r\n    var side = tableColumn.fixed;\r\n    var targetArray = side === FIXED_COLUMN_LEFT_SIDE\r\n        ? getFixedColumnKeys(tableColumns, leftColumns)\r\n        : slice(getFixedColumnKeys(tableColumns, rightColumns)).reverse();\r\n    var index = tableColumns.findIndex(function (_a) {\r\n        var key = _a.key;\r\n        return key === tableColumn.key;\r\n    });\r\n    var fixedIndex = targetArray.indexOf(tableColumn.key);\r\n    var columnChain = findChainByColumnIndex(tableHeaderColumnChains[0], index);\r\n    var showLeftDivider = columnChain.start === index && index !== 0;\r\n    var showRightDivider = columnChain.start + columnChain.columns.length - 1 === index\r\n        && index < tableColumns.length - 1;\r\n    var position = calculatePosition(targetArray, fixedIndex, tableColumnDimensions);\r\n    return {\r\n        showRightDivider: showRightDivider,\r\n        showLeftDivider: showLeftDivider,\r\n        position: position,\r\n        side: side,\r\n    };\r\n};\n\nvar tableColumnsWithFixed = function (tableColumns, leftColumns, rightColumns) { return tableColumns\r\n    .map(function (tableColumn) {\r\n    var fixed;\r\n    if ((tableColumn.type === TABLE_DATA_TYPE\r\n        && leftColumns.indexOf(tableColumn.column.name) !== -1)\r\n        || leftColumns.indexOf(tableColumn.type) !== -1) {\r\n        fixed = FIXED_COLUMN_LEFT_SIDE;\r\n    }\r\n    if ((tableColumn.type === TABLE_DATA_TYPE\r\n        && rightColumns.indexOf(tableColumn.column.name) !== -1)\r\n        || rightColumns.indexOf(tableColumn.type) !== -1) {\r\n        fixed = FIXED_COLUMN_RIGHT_SIDE;\r\n    }\r\n    return fixed ? __assign({}, tableColumn, { fixed: fixed }) : tableColumn;\r\n}); };\r\nvar tableHeaderRowsWithFixed = function (tableHeaderRows) { return __spread(tableHeaderRows, [\r\n    { key: TABLE_FIXED_TYPE.toString(), type: TABLE_FIXED_TYPE, height: 0 },\r\n]); };\r\nvar tableHeaderColumnChainsWithFixed = function (tableHeaderColumnChains, tableHeaderRows, tableColumns) {\r\n    var chains = tableHeaderColumnChains\r\n        || generateSimpleChains(tableHeaderRows, tableColumns);\r\n    var shouldSplitChain = function (currentGroup, column) { return (!currentGroup || currentGroup.fixed !== column.fixed); };\r\n    var extendChainProps = function (column) { return ({\r\n        fixed: column.fixed,\r\n    }); };\r\n    return splitHeaderColumnChains(chains, tableColumns, shouldSplitChain, extendChainProps);\r\n};\n\nvar defaultSummaryCalculators = {\r\n    count: function (rows) { return rows.length; },\r\n    sum: function (rows, getValue) { return rows.reduce(function (acc, row) { return acc + getValue(row); }, 0); },\r\n    max: function (rows, getValue) { return (rows.length\r\n        ? rows.reduce(function (acc, row) { return Math.max(acc, getValue(row)); }, -Infinity)\r\n        : null); },\r\n    min: function (rows, getValue) { return (rows.length\r\n        ? rows.reduce(function (acc, row) { return Math.min(acc, getValue(row)); }, Infinity)\r\n        : null); },\r\n    avg: function (rows, getValue) { return (rows.length\r\n        ? rows.reduce(function (acc, row) { return acc + getValue(row); }, 0) / rows.length\r\n        : null); },\r\n};\r\nvar defaultSummaryCalculator = function (type, rows, getValue) {\r\n    var summaryCalculator = defaultSummaryCalculators[type];\r\n    if (!summaryCalculator) {\r\n        throw new Error(\"The summary type '\" + type + \"' is not defined\");\r\n    }\r\n    return summaryCalculator(rows, getValue);\r\n};\r\nvar rowsSummary = function (rows, summaryItems, getCellValue, calculator) { return summaryItems\r\n    .reduce(function (acc, _a) {\r\n    var type = _a.type, columnName = _a.columnName;\r\n    var getValue = function (row) { return getCellValue(row, columnName); };\r\n    acc.push(calculator(type, rows, getValue));\r\n    return acc;\r\n}, []); };\r\nvar totalSummaryValues = function (rows, summaryItems, getCellValue, getRowLevelKey, isGroupRow, getCollapsedRows, calculator) {\r\n    if (calculator === void 0) { calculator = defaultSummaryCalculator; }\r\n    var plainRows = rows.reduce(function (acc, row) {\r\n        if (getRowLevelKey && getRowLevelKey(row)) {\r\n            if (!isGroupRow || !isGroupRow(row)) {\r\n                acc.push(row);\r\n            }\r\n            var collapsedRows = getCollapsedRows && getCollapsedRows(row);\r\n            if (collapsedRows) {\r\n                acc.push.apply(acc, __spread(collapsedRows));\r\n            }\r\n            return acc;\r\n        }\r\n        acc.push(row);\r\n        return acc;\r\n    }, []);\r\n    return rowsSummary(plainRows, summaryItems, getCellValue, calculator);\r\n};\r\nvar groupSummaryValues = function (rows, summaryItems, getCellValue, getRowLevelKey, isGroupRow, calculator) {\r\n    if (calculator === void 0) { calculator = defaultSummaryCalculator; }\r\n    var levels = [];\r\n    var summaries = {};\r\n    rows.forEach(function (row) {\r\n        var levelKey = getRowLevelKey(row);\r\n        if (!levelKey) {\r\n            levels.forEach(function (level) {\r\n                level.rows.push(row);\r\n            });\r\n        }\r\n        var levelIndex = levels.findIndex(function (level) { return level.levelKey === levelKey; });\r\n        if (levelIndex > -1) {\r\n            levels.slice(levelIndex).forEach(function (level) {\r\n                summaries[level.row.compoundKey] = rowsSummary(level.rows, summaryItems, getCellValue, calculator);\r\n            });\r\n            levels = levels.slice(0, levelIndex);\r\n        }\r\n        if (isGroupRow(row)) {\r\n            levels.push({\r\n                levelKey: levelKey,\r\n                row: row,\r\n                rows: [],\r\n            });\r\n        }\r\n    }, {});\r\n    levels.forEach(function (level) {\r\n        summaries[level.row.compoundKey] = rowsSummary(level.rows, summaryItems, getCellValue, calculator);\r\n    });\r\n    return summaries;\r\n};\r\nvar treeSummaryValues = function (rows, summaryItems, getCellValue, getRowLevelKey, isGroupRow, getRowId, calculator) {\r\n    if (calculator === void 0) { calculator = defaultSummaryCalculator; }\r\n    var levels = [];\r\n    var summaries = {};\r\n    rows.forEach(function (row) {\r\n        var levelKey = getRowLevelKey(row);\r\n        if (!levelKey) {\r\n            levels[levels.length - 1].rows.push(row);\r\n            return;\r\n        }\r\n        var levelIndex = levels.findIndex(function (level) { return level.levelKey === levelKey; });\r\n        if (levelIndex > -1) {\r\n            levels.slice(levelIndex).forEach(function (level) {\r\n                if (level.rows.length) {\r\n                    summaries[getRowId(level.row)] = rowsSummary(level.rows, summaryItems, getCellValue, calculator);\r\n                }\r\n            });\r\n            levels = levels.slice(0, levelIndex);\r\n        }\r\n        if (!isGroupRow || !isGroupRow(row)) {\r\n            if (levels.length) {\r\n                levels[levels.length - 1].rows.push(row);\r\n            }\r\n            levels.push({\r\n                levelKey: levelKey,\r\n                row: row,\r\n                rows: [],\r\n            });\r\n        }\r\n    }, {});\r\n    levels.forEach(function (level) {\r\n        if (level.rows.length) {\r\n            summaries[getRowId(level.row)] = rowsSummary(level.rows, summaryItems, getCellValue, calculator);\r\n        }\r\n    });\r\n    return summaries;\r\n};\n\nvar TABLE_TOTAL_SUMMARY_TYPE = Symbol('totalSummary');\r\nvar TABLE_GROUP_SUMMARY_TYPE = Symbol('groupSummary');\r\nvar TABLE_TREE_SUMMARY_TYPE = Symbol('treeSummary');\n\nvar tableRowsWithTotalSummaries = function (footerRows) { return __spread([\r\n    { key: TABLE_TOTAL_SUMMARY_TYPE.toString(), type: TABLE_TOTAL_SUMMARY_TYPE }\r\n], footerRows); };\r\nvar tableRowsWithSummaries = function (tableRows, getRowLevelKey, isGroupRow, getRowId) {\r\n    if (!getRowLevelKey)\r\n        return tableRows;\r\n    var result = [];\r\n    var closeLevel = function (level) {\r\n        if (!level.opened)\r\n            return;\r\n        if (isGroupRow && isGroupRow(level.row)) {\r\n            var compoundKey = level.row.compoundKey;\r\n            result.push({\r\n                key: TABLE_GROUP_SUMMARY_TYPE.toString() + \"_\" + compoundKey,\r\n                type: TABLE_GROUP_SUMMARY_TYPE,\r\n                row: level.row,\r\n            });\r\n        }\r\n        else {\r\n            var rowId = getRowId(level.row);\r\n            result.push({\r\n                key: TABLE_TREE_SUMMARY_TYPE.toString() + \"_\" + rowId,\r\n                type: TABLE_TREE_SUMMARY_TYPE,\r\n                row: level.row,\r\n            });\r\n        }\r\n    };\r\n    var levels = [];\r\n    tableRows.forEach(function (tableRow) {\r\n        var row = tableRow.row;\r\n        var levelKey = getRowLevelKey(row);\r\n        if (levelKey) {\r\n            var levelIndex = levels.findIndex(function (level) { return level.levelKey === levelKey; });\r\n            if (levelIndex > -1) {\r\n                levels.slice(levelIndex).reverse().forEach(closeLevel);\r\n                levels = levels.slice(0, levelIndex);\r\n            }\r\n            if (!isGroupRow || !isGroupRow(row)) {\r\n                levels = levels.map(function (level) { return (__assign({}, level, { opened: true })); });\r\n            }\r\n            levels.push({\r\n                levelKey: levelKey,\r\n                row: row,\r\n                opened: false,\r\n            });\r\n        }\r\n        else {\r\n            levels = levels.map(function (level) { return (__assign({}, level, { opened: true })); });\r\n        }\r\n        result.push(tableRow);\r\n    });\r\n    levels.slice().reverse().forEach(closeLevel);\r\n    return result;\r\n};\n\nvar isTotalSummaryTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_TOTAL_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isGroupSummaryTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_GROUP_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isTreeSummaryTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_TREE_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE; };\r\nvar isTotalSummaryTableRow = function (tableRow) { return (tableRow.type === TABLE_TOTAL_SUMMARY_TYPE); };\r\nvar isGroupSummaryTableRow = function (tableRow) { return (tableRow.type === TABLE_GROUP_SUMMARY_TYPE); };\r\nvar isTreeSummaryTableRow = function (tableRow) { return (tableRow.type === TABLE_TREE_SUMMARY_TYPE); };\r\nvar getColumnSummaries = function (summaryItems, columnName, summaryValues) { return summaryItems\r\n    .map(function (item, index) { return [item, index]; })\r\n    .filter(function (_a) {\r\n    var _b = __read(_a, 1), item = _b[0];\r\n    return item.columnName === columnName;\r\n})\r\n    .map(function (_a) {\r\n    var _b = __read(_a, 2), item = _b[0], index = _b[1];\r\n    return ({\r\n        type: item.type,\r\n        value: summaryValues[index],\r\n    });\r\n}); };\n\nvar getTargetColumnGeometries = function (columnGeometries, sourceIndex) {\r\n    var sourceWidth = columnGeometries[sourceIndex].right - columnGeometries[sourceIndex].left;\r\n    var getWidthDifference = function (index) { return columnGeometries[index].right\r\n        - columnGeometries[index].left\r\n        - sourceWidth; };\r\n    return columnGeometries\r\n        .map(function (_a, targetIndex) {\r\n        var top = _a.top, right = _a.right, bottom = _a.bottom, left = _a.left;\r\n        var leftBorder = left;\r\n        if (targetIndex > 0 && targetIndex <= sourceIndex) {\r\n            leftBorder = Math.min(leftBorder, leftBorder - getWidthDifference(targetIndex - 1));\r\n        }\r\n        if (targetIndex > sourceIndex) {\r\n            leftBorder = Math.max(leftBorder, leftBorder + getWidthDifference(targetIndex));\r\n        }\r\n        var rightBorder = right;\r\n        if (targetIndex < columnGeometries.length - 1 && targetIndex >= sourceIndex) {\r\n            rightBorder = Math.max(rightBorder, rightBorder + getWidthDifference(targetIndex + 1));\r\n        }\r\n        if (targetIndex < sourceIndex) {\r\n            rightBorder = Math.min(rightBorder, rightBorder - getWidthDifference(targetIndex));\r\n        }\r\n        return {\r\n            top: top,\r\n            bottom: bottom,\r\n            right: rightBorder,\r\n            left: leftBorder,\r\n        };\r\n    });\r\n};\n\nvar getTableColumnGeometries = function (columns, tableWidth) {\r\n    var columnWidths = columns\r\n        .map(function (column) { return column.width; });\r\n    var freeSpace = tableWidth;\r\n    var restrictedSpace = columnWidths\r\n        .reduce(function (accum, width) { return accum + (width || 0); }, 0);\r\n    var freeSpacePortions = columnWidths\r\n        .reduce(function (accum, width) { return accum + (width === undefined ? 1 : 0); }, 0);\r\n    var freeSpacePortion = (freeSpace - restrictedSpace) / freeSpacePortions;\r\n    var lastRightPosition = 0;\r\n    return columnWidths\r\n        .map(function (width) { return (width === undefined ? freeSpacePortion : width); })\r\n        .map(function (width) {\r\n        lastRightPosition += width;\r\n        return {\r\n            left: lastRightPosition - width,\r\n            right: lastRightPosition,\r\n        };\r\n    });\r\n};\r\nvar getTableTargetColumnIndex = function (columnGeometries, sourceIndex, offset) { return getTargetColumnGeometries(columnGeometries, sourceIndex)\r\n    .findIndex(function (_a) {\r\n    var left = _a.left, right = _a.right;\r\n    return offset > left && offset < right;\r\n}); };\r\nvar ANIMATION_DURATION = 200;\r\nvar getAnimationProgress = function (animation) { return (new Date().getTime() - animation.startTime) / ANIMATION_DURATION; };\r\nvar getAnimations = function (prevColumns, nextColumns, tableWidth, prevAnimations) {\r\n    var resizing = prevColumns.map(function (column) { return column.key; }).join()\r\n        === nextColumns.map(function (column) { return column.key; }).join();\r\n    var prevColumnGeometries = new Map(getTableColumnGeometries(prevColumns, tableWidth)\r\n        .map(function (geometry, index) { return [prevColumns[index].key, geometry]; })\r\n        .map(function (_a) {\r\n        var _b = __read(_a, 2), key = _b[0], geometry = _b[1];\r\n        var animation = prevAnimations.get(key);\r\n        if (!animation)\r\n            return [key, geometry];\r\n        var progress = easeOutCubic(getAnimationProgress(animation));\r\n        var _c = animation.left, to = _c.to, from = _c.from;\r\n        var left = ((to - from) * progress) + from;\r\n        return [key, {\r\n                left: left,\r\n                right: geometry.right - (geometry.left - left),\r\n            }];\r\n        // tslint:disable-next-line:array-type\r\n    }));\r\n    var nextColumnGeometries = new Map(getTableColumnGeometries(nextColumns, tableWidth)\r\n        // tslint:disable-next-line:array-type\r\n        .map(function (geometry, index) { return [nextColumns[index].key, geometry]; }));\r\n    return new Map(__spread(nextColumnGeometries.keys()).map(function (key) {\r\n        var prev = prevColumnGeometries.get(key);\r\n        var next = nextColumnGeometries.get(key);\r\n        var result = { startTime: new Date().getTime(), style: {} };\r\n        var takePrevColumnIntoAccount = !!prevAnimations.get(key) || (prev && !resizing);\r\n        if (Math.abs((takePrevColumnIntoAccount ? prev.left : next.left) - next.left) > 1) {\r\n            result.left = { from: prev.left, to: next.left };\r\n        }\r\n        return [key, result];\r\n    })\r\n        .filter(function (animation) { return animation[1].left; }));\r\n};\r\nvar filterActiveAnimations = function (animations) { return new Map(__spread(animations.entries()).filter(function (_a) {\r\n    var _b = __read(_a, 2), animation = _b[1];\r\n    return getAnimationProgress(animation) < 1;\r\n})); };\r\nvar evalAnimations = function (animations) { return new Map(__spread(animations.entries()).map(function (_a) {\r\n    var _b = __read(_a, 2), key = _b[0], animation = _b[1];\r\n    var progress = easeOutCubic(getAnimationProgress(animation));\r\n    var result = __assign({}, animation.style);\r\n    if (animation.left) {\r\n        var offset = (animation.left.to - animation.left.from) * (progress - 1);\r\n        result.transform = \"translateX(\" + offset + \"px)\";\r\n    }\r\n    return [key, result];\r\n})); };\n\nvar isOnTheSameLine = function (geometry, y) { return (y >= geometry.top && y <= geometry.bottom); };\r\nvar rectToObject = function (_a) {\r\n    var top = _a.top, right = _a.right, bottom = _a.bottom, left = _a.left;\r\n    return ({\r\n        top: top, right: right, bottom: bottom, left: left,\r\n    });\r\n};\r\nvar collapseGapsBetweenItems = function (geometries) { return (geometries.map(function (geometry, index) {\r\n    if (index !== geometries.length - 1 && geometry.top === geometries[index + 1].top) {\r\n        return __assign({}, geometry, { right: geometries[index + 1].left });\r\n    }\r\n    return geometry;\r\n})); };\r\nvar getGroupCellTargetIndex = function (geometries, sourceIndex, _a) {\r\n    var x = _a.x, y = _a.y;\r\n    if (geometries.length === 0)\r\n        return 0;\r\n    var targetGeometries = sourceIndex !== -1\r\n        ? getTargetColumnGeometries(geometries, sourceIndex)\r\n        : geometries.map(rectToObject);\r\n    var targetIndex = collapseGapsBetweenItems(targetGeometries)\r\n        .findIndex(function (geometry, index) {\r\n        var inVerticalBounds = isOnTheSameLine(geometry, y);\r\n        var inHorizontalBounds = x >= geometry.left && x <= geometry.right;\r\n        var shouldGoFirst = index === 0 && x < geometry.left;\r\n        var shouldGoOnLineBreak = !inVerticalBounds\r\n            && !!geometries[index - 1]\r\n            && isOnTheSameLine(geometries[index - 1], y);\r\n        return (inVerticalBounds && inHorizontalBounds)\r\n            || shouldGoFirst\r\n            || shouldGoOnLineBreak;\r\n    });\r\n    return targetIndex === -1 ? geometries.length : targetIndex;\r\n};\n\n/** how many rows up and down before next page request */\r\nvar pageTriggersMeta = function (_a, _b) {\r\n    var containerHeight = _a.containerHeight, visibleRowBoundaries = _a.visibleRowBoundaries, estimatedRowHeight = _a.estimatedRowHeight;\r\n    var pageSize = _b.pageSize, virtualRows = _b.virtualRows;\r\n    var loadedCount = virtualRows.rows.length;\r\n    if (loadedCount === 0) {\r\n        return null;\r\n    }\r\n    var loadedRowsStart = virtualRows.skip;\r\n    var topTriggerIndex = loadedRowsStart > 0 ? loadedRowsStart + pageSize : 0;\r\n    var bottomTriggerIndex = loadedRowsStart + loadedCount - pageSize;\r\n    var bodyBoundaries = visibleRowBoundaries.body;\r\n    var firstRowIndex = bodyBoundaries.start;\r\n    var visibleCount = bodyBoundaries.end - bodyBoundaries.start;\r\n    var middleIndex = firstRowIndex + Math.round(visibleCount / 2);\r\n    var middlePosition = visibleRowBoundaries.viewportTop + containerHeight / 2;\r\n    var topTriggerOffset = (middleIndex - topTriggerIndex) * estimatedRowHeight;\r\n    var bottomTriggerOffset = (bottomTriggerIndex - middleIndex) * estimatedRowHeight;\r\n    var topTriggerPosition = middlePosition - topTriggerOffset;\r\n    var bottomTriggerPosition = middlePosition + bottomTriggerOffset;\r\n    return {\r\n        topTriggerIndex: topTriggerIndex,\r\n        topTriggerPosition: topTriggerPosition,\r\n        bottomTriggerIndex: bottomTriggerIndex,\r\n        bottomTriggerPosition: bottomTriggerPosition,\r\n    };\r\n};\n\nvar getVisibleRowsBounds = function (state, getters, estimatedRowHeight, getRowHeight) {\r\n    var viewportTop = state.viewportTop, containerHeight = state.containerHeight, headerHeight = state.headerHeight, footerHeight = state.footerHeight;\r\n    var loadedRowsStart = getters.loadedRowsStart, bodyRows = getters.bodyRows, _a = getters.headerRows, headerRows = _a === void 0 ? [] : _a, _b = getters.footerRows, footerRows = _b === void 0 ? [] : _b;\r\n    return {\r\n        viewportTop: viewportTop,\r\n        header: getRowsVisibleBoundary(headerRows, 0, headerHeight, getRowHeight, 0, estimatedRowHeight),\r\n        body: getRowsVisibleBoundary(bodyRows, viewportTop, containerHeight - headerHeight - footerHeight, getRowHeight, loadedRowsStart, estimatedRowHeight),\r\n        footer: getRowsVisibleBoundary(footerRows, 0, footerHeight, getRowHeight, 0, estimatedRowHeight),\r\n    };\r\n};\r\nvar nextPageReferenceIndex = function (payload, getters) {\r\n    var triggersMeta = pageTriggersMeta(payload, getters);\r\n    if (triggersMeta === null) {\r\n        return null;\r\n    }\r\n    var topTriggerPosition = triggersMeta.topTriggerPosition, bottomTriggerPosition = triggersMeta.bottomTriggerPosition, topTriggerIndex = triggersMeta.topTriggerIndex, bottomTriggerIndex = triggersMeta.bottomTriggerIndex;\r\n    var viewportTop = payload.viewportTop, estimatedRowHeight = payload.estimatedRowHeight, containerHeight = payload.containerHeight;\r\n    var referencePosition = viewportTop + containerHeight / 2;\r\n    var getReferenceIndex = function (triggetIndex, triggerPosition) { return (triggetIndex + Math.round((referencePosition - triggerPosition) / estimatedRowHeight)); };\r\n    var referenceIndex = null;\r\n    if (referencePosition < topTriggerPosition) {\r\n        referenceIndex = getReferenceIndex(topTriggerIndex, topTriggerPosition);\r\n    }\r\n    if (bottomTriggerPosition < referencePosition) {\r\n        referenceIndex = getReferenceIndex(bottomTriggerIndex, bottomTriggerPosition);\r\n    }\r\n    return referenceIndex;\r\n};\n\nvar empty = {\r\n    start: Number.POSITIVE_INFINITY,\r\n    end: Number.NEGATIVE_INFINITY,\r\n};\r\nvar getRowsInterval = function (r) { return (r === emptyVirtualRows\r\n    ? empty\r\n    : {\r\n        start: r.skip,\r\n        end: r.skip + r.rows.length,\r\n    }); };\r\nvar getLength = function (a) { return a.end - a.start; };\r\nvar intersect = function (a, b) {\r\n    if (a.end < b.start || b.end < a.start) {\r\n        return empty;\r\n    }\r\n    return {\r\n        start: Math.max(a.start, b.start),\r\n        end: Math.min(a.end, b.end),\r\n    };\r\n};\r\nvar difference = function (a, b) {\r\n    if (empty === intervalUtil.intersect(a, b)) {\r\n        return a;\r\n    }\r\n    if (b.end < a.end) {\r\n        return {\r\n            start: b.end,\r\n            end: a.end,\r\n        };\r\n    }\r\n    if (a.start < b.start) {\r\n        return {\r\n            start: a.start,\r\n            end: b.start,\r\n        };\r\n    }\r\n    return empty;\r\n};\r\nvar intervalUtil = {\r\n    empty: empty,\r\n    getRowsInterval: getRowsInterval,\r\n    getLength: getLength,\r\n    intersect: intersect,\r\n    difference: difference,\r\n};\n\nvar emptyVirtualRows = {\r\n    skip: Number.POSITIVE_INFINITY,\r\n    rows: [],\r\n};\r\nvar pluckSubarray = function (source, sourceStart, left, right) { return (source.slice(left - sourceStart, right - sourceStart)); };\r\nvar mergeRows = function (rowsInterval, cacheInterval, rows, cacheRows, rowsStart, cacheStart) {\r\n    var breakpoints = [\r\n        rowsInterval.start, rowsInterval.end,\r\n        cacheInterval.start, cacheInterval.end,\r\n    ]\r\n        .filter(function (i) { return 0 <= i && i < Number.POSITIVE_INFINITY; })\r\n        .sort(function (a, b) { return a - b; });\r\n    var result = [];\r\n    if (breakpoints.length > 1) {\r\n        for (var i = 0; i < breakpoints.length - 1; i += 1) {\r\n            var left = breakpoints[i];\r\n            var right = breakpoints[i + 1];\r\n            var chunk = rowsInterval.start <= left && right <= rowsInterval.end\r\n                ? pluckSubarray(rows, rowsStart, left, right) // rows have higher priority\r\n                : pluckSubarray(cacheRows, cacheStart, left, right);\r\n            result = result.concat(chunk);\r\n        }\r\n    }\r\n    return {\r\n        skip: breakpoints[0],\r\n        rows: result,\r\n    };\r\n};\r\nvar calculateRequestedRange = function (loadedInterval, newRange, referenceIndex, pageSize) {\r\n    var isAdjacentPage = Math.abs(loadedInterval.start - newRange.start) < 2 * pageSize;\r\n    if (isAdjacentPage) {\r\n        return intervalUtil.difference(newRange, loadedInterval);\r\n    }\r\n    var useFirstHalf = referenceIndex % pageSize < pageSize / 2;\r\n    var isLastPage = intervalUtil.getLength(newRange) / pageSize < 3;\r\n    var start = useFirstHalf || isLastPage\r\n        ? newRange.start\r\n        : newRange.start + pageSize;\r\n    var end = Math.min(newRange.end, start + 2 * pageSize);\r\n    return { start: start, end: end };\r\n};\r\nvar rowToPageIndex = function (rowIndex, pageSize) { return Math.floor(rowIndex / pageSize); };\r\nvar recalculateBounds = function (middleIndex, pageSize, totalCount) {\r\n    var currentPageIndex = rowToPageIndex(middleIndex, pageSize);\r\n    var prevPageIndex = currentPageIndex - 1;\r\n    var nextPageIndex = currentPageIndex + 2;\r\n    var start = Math.max(0, prevPageIndex * pageSize);\r\n    var end = Math.min(nextPageIndex * pageSize, totalCount);\r\n    return {\r\n        start: start,\r\n        end: end,\r\n    };\r\n};\r\nvar trimRowsToInterval = function (virtualRows, targetInterval) {\r\n    var rowsInterval = intervalUtil.getRowsInterval(virtualRows);\r\n    var intersection = intervalUtil.intersect(rowsInterval, targetInterval);\r\n    if (intervalUtil.empty === intersection) {\r\n        return emptyVirtualRows;\r\n    }\r\n    var rows = pluckSubarray(virtualRows.rows, virtualRows.skip, intersection.start, intersection.end);\r\n    return {\r\n        rows: rows,\r\n        skip: intersection.start,\r\n    };\r\n};\r\nvar getAvailableRowCount = function (infiniteScroll, newCount, lastCount, totalRowCount) { return (infiniteScroll\r\n    ? Math.max(newCount, lastCount)\r\n    : totalRowCount); };\n\nvar virtualRowsWithCache = function (skip, rows, cache) {\r\n    var rowsInterval = intervalUtil.getRowsInterval({ skip: skip, rows: rows });\r\n    var cacheInterval = intervalUtil.getRowsInterval(cache);\r\n    return mergeRows(rowsInterval, cacheInterval, rows, cache.rows, skip, cache.skip);\r\n};\r\nvar plainRows = function (virtualRows) { return virtualRows.rows; };\r\nvar loadedRowsStart = function (virtualRows) { return virtualRows.skip; };\n\n/** @internal */\n\nexport { BAND_DUPLICATE_RENDER, BAND_EMPTY_CELL, BAND_GROUP_CELL, BAND_HEADER_CELL, DEFAULT_FILTER_OPERATIONS, FIXED_COLUMN_LEFT_SIDE, FIXED_COLUMN_RIGHT_SIDE, GROUP_KEY_SEPARATOR, TABLE_ADDED_TYPE, TABLE_BAND_TYPE, TABLE_DATA_TYPE, TABLE_DETAIL_TYPE, TABLE_EDIT_COMMAND_TYPE, TABLE_EDIT_TYPE, TABLE_FILTER_TYPE, TABLE_FIXED_TYPE, TABLE_FLEX_TYPE, TABLE_GROUP_SUMMARY_TYPE, TABLE_GROUP_TYPE, TABLE_HEADING_TYPE, TABLE_NODATA_TYPE, TABLE_REORDERING_TYPE, TABLE_SELECT_TYPE, TABLE_STUB_TYPE, TABLE_TOTAL_SUMMARY_TYPE, TABLE_TREE_SUMMARY_TYPE, addRow, addedRowsByIds, adjustSortIndex, allSelected, calculateFixedColumnProps, calculateGroupCellIndent, calculateKeepOther, calculateRequestedRange, calculateStartPage, cancelAddedRows, cancelChanges, cancelColumnGroupingDraft, cancelDeletedRows, cancelTableColumnWidthDraft, cellValueGetter, changeAddedRow, changeColumnFilter, changeColumnGrouping, changeColumnOrder, changeColumnSorting, changeRow, changeSearchValue, changeTableColumnWidth, changedRowsByIds, clamp, collapsedTreeRowsGetter, columnChooserItems, createRowChangeGetter, currentPage, customGroupedRows, customGroupingRowIdGetter, customTreeRowIdGetter, customTreeRowLevelKeyGetter, customTreeRowsWithMeta, defaultFilterPredicate, defaultSummaryCalculator, deleteRows, draftColumnGrouping, draftOrder, draftTableColumnWidth, emptyVirtualRows, evalAnimations, expandedGroupRows, expandedTreeRows, filterActiveAnimations, filterExpression, filteredCollapsedRowsGetter, filteredRows, findChainByColumnIndex, firstRowOnPage, generateSimpleChains, getAnimations, getAvailableFilterOperationsGetter, getAvailableRowCount, getBandComponent, getCollapsedGrid, getCollapsedGrids, getColumnBoundaries, getColumnExtension, getColumnExtensionValueGetter, getColumnFilterConfig, getColumnFilterOperations, getColumnMeta, getColumnSortingDirection, getColumnSummaries, getColumnWidthGetter, getColumnsRenderBoundary, getFixedColumnKeys, getGroupCellTargetIndex, getPersistentSortedColumns, getRowChange, getRowsRenderBoundary, getRowsVisibleBoundary, getSelectedFilterOperation, getTableColumnGeometries, getTableTargetColumnIndex, getTreeRowLevelGetter, getVisibleRowsBounds, groupCollapsedRowsGetter, groupRowChecker, groupRowLevelKeyGetter, groupSummaryValues, groupedRows, groupingPanelItems, intervalUtil, isAddedTableRow, isBandedOrHeaderRow, isBandedTableRow, isDataTableCell, isDataTableRow, isDetailRowExpanded, isDetailTableCell, isDetailTableRow, isDetailToggleTableCell, isEditCommandsTableCell, isEditTableCell, isEditTableRow, isFilterTableCell, isFilterTableRow, isFilterValueEmpty, isFixedTableRow, isGroupIndentTableCell, isGroupSummaryTableCell, isGroupSummaryTableRow, isGroupTableCell, isGroupTableRow, isHeaderStubTableCell, isHeadingEditCommandsTableCell, isHeadingTableCell, isHeadingTableRow, isNoDataColumn, isNoDataTableCell, isNoDataTableRow, isRowHighlighted, isSelectAllTableCell, isSelectTableCell, isStubTableCell, isTotalSummaryTableCell, isTotalSummaryTableRow, isTreeRowLeafGetter, isTreeSummaryTableCell, isTreeSummaryTableRow, isTreeTableCell, lastRowOnPage, loadedRowsStart, mergeRows, nextPageReferenceIndex, orderedColumns, pageCount, pageTriggersMeta, paginatedRows, plainRows, recalculateBounds, rowCount, rowIdGetter, rowToPageIndex, rowsWithAvailableToSelect, rowsWithPageHeaders, searchFilterExpression, setCurrentPage, setPageSize, someSelected, sortedRows, splitHeaderColumnChains, startEditRows, stopEditRows, tableCellColSpanGetter, tableColumnsWithDataRows, tableColumnsWithDetail, tableColumnsWithDraftWidths, tableColumnsWithEditing, tableColumnsWithFixed, tableColumnsWithGrouping, tableColumnsWithSelection, tableColumnsWithWidths, tableDataColumnsExist, tableDetailCellColSpanGetter, tableGroupCellColSpanGetter, tableHeaderColumnChainsWithBands, tableHeaderColumnChainsWithFixed, tableHeaderRowsWithFilter, tableHeaderRowsWithFixed, tableHeaderRowsWithReordering, tableRowsWithBands, tableRowsWithDataRows, tableRowsWithEditing, tableRowsWithExpandedDetail, tableRowsWithGrouping, tableRowsWithHeading, tableRowsWithSummaries, tableRowsWithTotalSummaries, toggleColumn, toggleDetailRowExpanded, toggleExpandedGroups, toggleRowExpanded, toggleSelection, totalSummaryValues, treeSummaryValues, trimRowsToInterval, unwrapSelectedRows, unwrappedCustomTreeRows, unwrappedFilteredRows, virtualRowsWithCache, visibleTableColumns };\n//# sourceMappingURL=dx-grid-core.es.js.map\n","/**\n * Bundle of @devexpress/dx-vue-grid\n * Generated: 2018-11-07\n * Version: 1.9.0\n * License: https://js.devexpress.com/Licensing\n */\n\nimport { DxPlugin, DxGetter, DxTemplate, DxTemplatePlaceholder, DxPluginHost, DxTemplateConnector, DxAction, DxSizer, DxRefHolder } from '@devexpress/dx-vue-core';\nimport { rowIdGetter, cellValueGetter, tableColumnsWithDataRows, tableRowsWithDataRows, tableCellColSpanGetter, isDataTableCell, isDataTableRow, isHeaderStubTableCell, isNoDataTableRow, isNoDataTableCell, tableRowsWithHeading, isHeadingTableCell, isHeadingTableRow, getColumnSortingDirection, TABLE_DATA_TYPE, sortedRows, getColumnExtension, changeColumnSorting, getColumnExtensionValueGetter, getPersistentSortedColumns, calculateKeepOther, TABLE_FLEX_TYPE, getCollapsedGrid, changeColumnFilter, filterExpression, filteredRows, filteredCollapsedRowsGetter, unwrappedFilteredRows, defaultFilterPredicate, getColumnFilterConfig, tableHeaderRowsWithFilter, isFilterTableCell, isFilterTableRow, getColumnFilterOperations, isFilterValueEmpty, changeColumnGrouping, toggleExpandedGroups, adjustSortIndex, groupRowChecker, groupRowLevelKeyGetter, groupCollapsedRowsGetter, groupedRows, expandedGroupRows, customGroupingRowIdGetter, customGroupedRows, groupingPanelItems, tableColumnsWithGrouping, tableRowsWithGrouping, tableGroupCellColSpanGetter, isGroupIndentTableCell, isGroupTableCell, isGroupTableRow, changeSearchValue, searchFilterExpression, toggleSelection, rowsWithAvailableToSelect, someSelected, allSelected, unwrapSelectedRows, tableColumnsWithSelection, isSelectTableCell, isSelectAllTableCell, setCurrentPage, setPageSize, paginatedRows, rowsWithPageHeaders, rowCount, currentPage, pageCount, getAvailableFilterOperationsGetter, toggleDetailRowExpanded, tableRowsWithExpandedDetail, tableDetailCellColSpanGetter, isDetailRowExpanded, tableColumnsWithDetail, isDetailToggleTableCell, isDetailTableRow, isDetailTableCell, createRowChangeGetter, startEditRows, stopEditRows, addRow, changeAddedRow, cancelAddedRows, addedRowsByIds, changeRow, cancelChanges, changedRowsByIds, deleteRows, cancelDeletedRows, tableColumnsWithEditing, isHeadingEditCommandsTableCell, isEditCommandsTableCell, isAddedTableRow, isEditTableRow, getRowChange, tableRowsWithEditing, isEditTableCell, toggleRowExpanded, customTreeRowLevelKeyGetter, customTreeRowIdGetter, customTreeRowsWithMeta, expandedTreeRows, collapsedTreeRowsGetter, isTreeRowLeafGetter, getTreeRowLevelGetter, unwrappedCustomTreeRows, isTreeTableCell, getBandComponent, isBandedTableRow, isBandedOrHeaderRow, tableRowsWithBands, BAND_GROUP_CELL, BAND_HEADER_CELL, BAND_EMPTY_CELL, BAND_DUPLICATE_RENDER, toggleColumn, visibleTableColumns, tableDataColumnsExist, columnChooserItems } from '@devexpress/dx-grid-core';\nimport { getMessagesFormatter } from '@devexpress/dx-core';\n\nvar GridCore = {\n  name: 'GridCore',\n  props: {\n    rows: {\n      type: Array,\n      required: true\n    },\n    getRowId: {\n      type: Function\n    },\n    getCellValue: {\n      type: Function\n    },\n    columns: {\n      type: Array,\n      required: true\n    },\n    rootComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var rows = this.rows,\n        columns = this.columns,\n        getRowId = this.getRowId,\n        getCellValue = this.getCellValue,\n        Root = this.rootComponent;\n\n\n    return h(DxPlugin, [h(DxGetter, {\n      attrs: { name: 'rows', value: rows }\n    }), h(DxGetter, {\n      attrs: { name: 'getRowId', value: rowIdGetter(getRowId, rows) }\n    }), h(DxGetter, {\n      attrs: { name: 'columns', value: columns }\n    }), h(DxGetter, {\n      attrs: { name: 'getCellValue', value: cellValueGetter(getCellValue, columns) }\n    }), h(\n      DxTemplate,\n      {\n        attrs: { name: 'root' }\n      },\n      [h(Root, [h(DxTemplatePlaceholder, {\n        attrs: { name: 'header' }\n      }), h(DxTemplatePlaceholder, {\n        attrs: { name: 'body' }\n      }), h(DxTemplatePlaceholder, {\n        attrs: { name: 'footer' }\n      })])]\n    )]);\n  }\n};\n\nvar DxGrid = {\n  name: 'DxGrid',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxPluginHost, [h(GridCore, context.data), context.children]);\n  }\n};\n\nvar nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/;\n\nvar babelHelperVueJsxMergeProps = function mergeJSXProps(objs) {\n  return objs.reduce(function (a, b) {\n    var aa, bb, key, nestedKey, temp;\n    for (key in b) {\n      aa = a[key];\n      bb = b[key];\n      if (aa && nestRE.test(key)) {\n        // normalize class\n        if (key === 'class') {\n          if (typeof aa === 'string') {\n            temp = aa;\n            a[key] = aa = {};\n            aa[temp] = true;\n          }\n          if (typeof bb === 'string') {\n            temp = bb;\n            b[key] = bb = {};\n            bb[temp] = true;\n          }\n        }\n        if (key === 'on' || key === 'nativeOn' || key === 'hook') {\n          // merge functions\n          for (nestedKey in bb) {\n            aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey]);\n          }\n        } else if (Array.isArray(aa)) {\n          a[key] = aa.concat(bb);\n        } else if (Array.isArray(bb)) {\n          a[key] = [aa].concat(bb);\n        } else {\n          for (nestedKey in bb) {\n            aa[nestedKey] = bb[nestedKey];\n          }\n        }\n      } else {\n        a[key] = b[key];\n      }\n    }\n    return a;\n  }, {});\n};\n\nfunction mergeFn(a, b) {\n  return function () {\n    a && a.apply(this, arguments);\n    b && b.apply(this, arguments);\n  };\n}\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar objectWithoutProperties = function (obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\nvar RowPlaceholder = {\n  props: {\n    tableRow: {\n      type: Object,\n      required: true\n    },\n    height: {\n      type: [Number, String]\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxTemplatePlaceholder,\n      babelHelperVueJsxMergeProps([{\n        attrs: {\n          name: 'tableRow'\n        }\n      }, { attrs: _extends({}, this.$props) }]),\n      [this.$slots.default]\n    );\n  }\n};\n\nvar CellPlaceholder = {\n  props: {\n    tableColumn: {\n      type: Object,\n      required: true\n    },\n    tableRow: {\n      type: Object,\n      required: true\n    },\n    colSpan: {\n      type: Number,\n      required: true\n    },\n    rowSpan: {\n      type: Number\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(DxTemplatePlaceholder, babelHelperVueJsxMergeProps([{\n      attrs: {\n        name: 'tableCell'\n      }\n    }, { attrs: _extends({}, this.$props) }]));\n  }\n};\n\nvar tableHeaderRows = [];\nvar tableBodyRowsComputed = function tableBodyRowsComputed(_ref) {\n  var rows = _ref.rows,\n      getRowId = _ref.getRowId;\n  return tableRowsWithDataRows(rows, getRowId);\n};\n\nvar DxTable = {\n  name: 'DxTable',\n  props: {\n    layoutComponent: {\n      type: Object,\n      required: true\n    },\n    tableComponent: {\n      type: Object,\n      required: true\n    },\n    headComponent: {\n      type: Object,\n      required: true\n    },\n    bodyComponent: {\n      type: Object,\n      required: true\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    stubRowComponent: {\n      type: Object,\n      required: true\n    },\n    stubCellComponent: {\n      type: Object,\n      required: true\n    },\n    stubHeaderCellComponent: {\n      type: Object,\n      required: true\n    },\n    noDataRowComponent: {\n      type: Object,\n      required: true\n    },\n    noDataCellComponent: {\n      type: Object,\n      required: true\n    },\n    columnExtensions: {\n      type: Array\n    },\n    messages: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Layout = this.layoutComponent,\n        Cell = this.cellComponent,\n        Row = this.rowComponent,\n        NoDataRow = this.noDataRowComponent,\n        NoDataCell = this.noDataCellComponent,\n        StubRow = this.stubRowComponent,\n        StubCell = this.stubCellComponent,\n        StubHeaderCell = this.stubHeaderCellComponent,\n        columnExtensions = this.columnExtensions,\n        containerComponent = this.containerComponent,\n        tableComponent = this.tableComponent,\n        headComponent = this.headComponent,\n        bodyComponent = this.bodyComponent,\n        messages = this.messages;\n\n\n    var getMessage = getMessagesFormatter(messages);\n    var tableColumnsComputed = function tableColumnsComputed(_ref2) {\n      var columns = _ref2.columns;\n      return tableColumnsWithDataRows(columns, columnExtensions);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTable'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableHeaderRows', value: tableHeaderRows }\n      }), h(DxGetter, {\n        attrs: { name: 'tableBodyRows', computed: tableBodyRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: tableColumnsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getTableCellColSpan', value: tableCellColSpanGetter }\n      }), h(\n        DxTemplate,\n        {\n          attrs: { name: 'body' }\n        },\n        [h(DxTemplatePlaceholder, {\n          attrs: { name: 'table' }\n        })]\n      ), h(\n        DxTemplate,\n        {\n          attrs: { name: 'table' }\n        },\n        [h(DxTemplateConnector, [function (_ref3) {\n          var _ref3$getters = _ref3.getters,\n              headerRows = _ref3$getters.tableHeaderRows,\n              bodyRows = _ref3$getters.tableBodyRows,\n              columns = _ref3$getters.tableColumns,\n              getTableCellColSpan = _ref3$getters.getTableCellColSpan;\n          return h(Layout, {\n            attrs: {\n              tableComponent: tableComponent,\n              headComponent: headComponent,\n              bodyComponent: bodyComponent,\n              containerComponent: containerComponent,\n              headerRows: headerRows,\n              bodyRows: bodyRows,\n              columns: columns,\n              rowComponent: RowPlaceholder,\n              cellComponent: CellPlaceholder,\n              getCellColSpan: getTableCellColSpan\n            }\n          });\n        }])]\n      ), h(\n        DxTemplate,\n        {\n          attrs: { name: 'tableCell' }\n        },\n        [function (_ref4) {\n          var attrs = _ref4.attrs,\n              listeners = _ref4.listeners;\n          return h(DxTemplateConnector, [function (_ref5) {\n            var headerRows = _ref5.getters.tableHeaderRows;\n            return isHeaderStubTableCell(attrs.tableRow, headerRows) ? h(StubHeaderCell, { attrs: _extends({}, attrs), on: _extends({}, listeners) }) : h(StubCell, { attrs: _extends({}, attrs), on: _extends({}, listeners) });\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref6) {\n              var _ref6$attrs = _ref6.attrs,\n                  tableRow = _ref6$attrs.tableRow,\n                  tableColumn = _ref6$attrs.tableColumn;\n              return isDataTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref7) {\n          var attrs = _ref7.attrs,\n              listeners = _ref7.listeners;\n          return h(DxTemplateConnector, [function (_ref8) {\n            var getCellValue = _ref8.getters.getCellValue;\n\n            var value = getCellValue(attrs.tableRow.row, attrs.tableColumn.column.name);\n            return h(\n              DxTemplatePlaceholder,\n              {\n                attrs: {\n                  name: 'valueFormatter',\n                  row: attrs.tableRow.row,\n                  column: attrs.tableColumn.column,\n                  value: value\n                }\n              },\n              [function (content) {\n                return h(\n                  Cell,\n                  babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                    attrs: {\n                      row: attrs.tableRow.row,\n                      column: attrs.tableColumn.column,\n                      value: value\n                    }\n                  }]),\n                  [content]\n                );\n              }]\n            );\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref9) {\n              var tableRow = _ref9.attrs.tableRow;\n              return isNoDataTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref10) {\n          var attrs = _ref10.attrs,\n              listeners = _ref10.listeners;\n          return h(DxTemplateConnector, [function (_ref11) {\n            var tableColumns = _ref11.getters.tableColumns;\n\n            if (isNoDataTableCell(attrs.tableColumn, tableColumns)) {\n              return h(NoDataCell, babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                attrs: {\n                  getMessage: getMessage\n                }\n              }]));\n            }\n            return null;\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: { name: 'tableRow' }\n        },\n        [function (_ref12) {\n          var attrs = _ref12.attrs,\n              listeners = _ref12.listeners,\n              slots = _ref12.slots;\n          return h(\n            StubRow,\n            { attrs: _extends({}, attrs), on: _extends({}, listeners) },\n            [slots.default]\n          );\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref13) {\n              var tableRow = _ref13.attrs.tableRow;\n              return isDataTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref14) {\n          var attrs = _ref14.attrs,\n              listeners = _ref14.listeners,\n              slots = _ref14.slots;\n          return h(\n            Row,\n            babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row\n              }\n            }]),\n            [slots.default]\n          );\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref15) {\n              var tableRow = _ref15.attrs.tableRow;\n              return isNoDataTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref16) {\n          var attrs = _ref16.attrs,\n              listeners = _ref16.listeners,\n              slots = _ref16.slots;\n          return h(\n            NoDataRow,\n            { attrs: _extends({}, attrs), on: _extends({}, listeners) },\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar tableHeaderRowsComputed = function tableHeaderRowsComputed(_ref) {\n  var tableHeaderRows = _ref.tableHeaderRows;\n  return tableRowsWithHeading(tableHeaderRows);\n};\n\nvar pluginDependencies = [{ name: 'DxTable' }];\n\nvar DxTableHeaderRow = {\n  name: 'DxTableHeaderRow',\n  props: {\n    showSortingControls: {\n      type: Boolean\n    },\n    showGroupingControls: {\n      type: Boolean\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var HeaderCell = this.cellComponent,\n        HeaderRow = this.rowComponent;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableHeaderRow',\n          dependencies: pluginDependencies\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableHeaderRows', computed: tableHeaderRowsComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var _ref2$attrs = _ref2.attrs,\n                  tableRow = _ref2$attrs.tableRow,\n                  tableColumn = _ref2$attrs.tableColumn;\n              return isHeadingTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs,\n              listeners = _ref3.listeners;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var _ref4$getters = _ref4.getters,\n                sorting = _ref4$getters.sorting,\n                tableColumns = _ref4$getters.tableColumns,\n                isColumnSortingEnabled = _ref4$getters.isColumnSortingEnabled,\n                isColumnGroupingEnabled = _ref4$getters.isColumnGroupingEnabled,\n                _ref4$actions = _ref4.actions,\n                changeColumnSorting$$1 = _ref4$actions.changeColumnSorting,\n                changeColumnGrouping$$1 = _ref4$actions.changeColumnGrouping;\n            var columnName = attrs.tableColumn.column.name;\n\n            var atLeastOneDataColumn = tableColumns.filter(function (_ref5) {\n              var type = _ref5.type;\n              return type === TABLE_DATA_TYPE;\n            }).length > 1;\n            var sortingEnabled = isColumnSortingEnabled && isColumnSortingEnabled(columnName);\n            var groupingEnabled = isColumnGroupingEnabled && isColumnGroupingEnabled(columnName) && atLeastOneDataColumn;\n\n            return h(\n              HeaderCell,\n              babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                attrs: {\n                  column: attrs.tableColumn.column,\n                  showSortingControls: _this.showSortingControls,\n                  showGroupingControls: _this.showGroupingControls,\n                  sortingEnabled: sortingEnabled,\n                  groupingEnabled: groupingEnabled,\n                  sortingDirection: _this.showSortingControls ? getColumnSortingDirection(sorting, columnName) : undefined\n                },\n                on: {\n                  'sort': function sort(_ref6) {\n                    var direction = _ref6.direction,\n                        keepOther = _ref6.keepOther;\n                    return changeColumnSorting$$1({ columnName: columnName, direction: direction, keepOther: keepOther });\n                  },\n                  'group': function group() {\n                    return changeColumnGrouping$$1({ columnName: columnName });\n                  }\n                }\n              }]),\n              [h(DxTemplatePlaceholder, {\n                slot: 'before',\n                attrs: { name: 'tableHeaderCellBefore',\n                  column: attrs.tableColumn.column\n                }\n              })]\n            );\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref7) {\n              var tableRow = _ref7.attrs.tableRow;\n              return isHeadingTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref8) {\n          var attrs = _ref8.attrs,\n              listeners = _ref8.listeners,\n              slots = _ref8.slots;\n          return h(\n            HeaderRow,\n            { attrs: _extends({}, attrs), on: _extends({}, listeners) },\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar pluginDependencies$1 = [{ name: 'DxSortingState' }];\n\nvar DxIntegratedSorting = {\n  name: 'DxIntegratedSorting',\n  props: {\n    columnExtensions: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var columnExtensions = this.columnExtensions;\n\n    var getColumnCompare = function getColumnCompare(columnName) {\n      return getColumnExtension(columnExtensions, columnName).compare;\n    };\n\n    var rowsComputed = function rowsComputed(_ref) {\n      var rows = _ref.rows,\n          sorting = _ref.sorting,\n          getCellValue = _ref.getCellValue,\n          isGroupRow = _ref.isGroupRow,\n          getRowLevelKey = _ref.getRowLevelKey;\n      return sortedRows(rows, sorting, getCellValue, getColumnCompare, isGroupRow, getRowLevelKey);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxIntegratedSorting',\n          dependencies: pluginDependencies$1\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'rows', computed: rowsComputed }\n      })]\n    );\n  }\n};\n\nvar DxSortingState = {\n  name: 'DxSortingState',\n  props: {\n    sorting: {\n      type: Array,\n      required: true\n    },\n    columnExtensions: {\n      type: Array\n    },\n    columnSortingEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  methods: {\n    changeColumnSorting: function changeColumnSorting$$1(payload) {\n      var persistentSortedColumns = getPersistentSortedColumns(this.sorting, this.columnExtensions);\n      var keepOther = calculateKeepOther(this.sorting, payload.keepOther, persistentSortedColumns);\n      this.$emit('update:sorting', changeColumnSorting({ sorting: this.sorting }, _extends({}, payload, { keepOther: keepOther })).sorting);\n    }\n  },\n\n  render: function render() {\n    var h = arguments[0];\n    var columnExtensions = this.columnExtensions,\n        columnSortingEnabled = this.columnSortingEnabled;\n\n    var columnExtensionValueGetter = function columnExtensionValueGetter(extensions, defaultValue) {\n      return getColumnExtensionValueGetter(extensions, 'sortingEnabled', defaultValue);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxSortingState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'sorting', value: this.sorting }\n      }), h(DxGetter, {\n        attrs: {\n          name: 'isColumnSortingEnabled',\n          value: columnExtensionValueGetter(columnExtensions, columnSortingEnabled)\n        }\n      }), h(DxAction, {\n        attrs: { name: 'changeColumnSorting', action: this.changeColumnSorting }\n      })]\n    );\n  }\n};\n\nvar DxToolbar = {\n  name: 'DxToolbar',\n  props: {\n    rootComponent: {\n      type: Object,\n      required: true\n    },\n    flexibleSpaceComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Root = this.rootComponent,\n        FlexibleSpaceComponent = this.flexibleSpaceComponent;\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxToolbar'\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: { name: 'header' }\n        },\n        [h(Root, [h(DxTemplatePlaceholder, {\n          attrs: { name: 'toolbarContent' }\n        })]), h(DxTemplatePlaceholder)]\n      ), h(\n        DxTemplate,\n        {\n          attrs: { name: 'toolbarContent' }\n        },\n        [h(FlexibleSpaceComponent)]\n      )]\n    );\n  }\n};\n\nvar TableLayout = {\n  props: {\n    columns: {\n      type: Array,\n      required: true\n    },\n    layoutComponent: {\n      type: Object,\n      required: true\n    },\n    minColumnWidth: {\n      type: Number,\n      required: true\n    }\n  },\n  methods: {\n    getColumns: function getColumns() {\n      var columns = this.columns;\n\n\n      var result = columns;\n\n      var isFixedWidth = columns.filter(function (column) {\n        return column.width === undefined;\n      }).length === 0;\n      if (isFixedWidth) {\n        result = result.slice();\n        result.push({ key: TABLE_FLEX_TYPE.toString(), type: TABLE_FLEX_TYPE });\n      }\n\n      return result;\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var minColumnWidth = this.minColumnWidth,\n        Layout = this.layoutComponent;\n\n\n    var columns = this.getColumns();\n    var minWidth = columns.map(function (column) {\n      return column.width || (column.type === TABLE_FLEX_TYPE ? 0 : minColumnWidth);\n    }).reduce(function (acc, width) {\n      return acc + width;\n    }, 0);\n\n    return h(Layout, babelHelperVueJsxMergeProps([{ attrs: this.$attrs }, {\n      attrs: {\n        columns: columns,\n        minWidth: minWidth,\n        minColumnWidth: minColumnWidth\n      }\n    }]));\n  }\n};\n\nvar ColumnGroup = {\n  name: 'ColumnGroup',\n  props: {\n    columns: {\n      type: Array,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var columns = this.columns;\n\n\n    return h('colgroup', [columns.map(function (column) {\n      return h('col', {\n        key: column.key,\n        style: column.width !== undefined ? { width: column.width + 'px' } : null\n      });\n    })]);\n  }\n};\n\nvar getRowStyle = function getRowStyle(_ref) {\n  var row = _ref.row;\n  return row.height !== undefined ? { height: row.height + 'px' } : undefined;\n};\n\nvar RowLayout = {\n  name: 'RowLayout',\n  props: {\n    row: {\n      required: true\n    },\n    columns: {\n      type: Array,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    getCellColSpan: {\n      getCellColSpan: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var row = this.row,\n        columns = this.columns,\n        Row = this.rowComponent,\n        Cell = this.cellComponent,\n        getCellColSpan = this.getCellColSpan;\n\n    var getColSpan = function getColSpan(tableRow, tableColumn) {\n      return getCellColSpan({ tableRow: tableRow, tableColumn: tableColumn, tableColumns: columns });\n    };\n\n    return h(\n      Row,\n      {\n        attrs: {\n          tableRow: row\n        },\n        style: getRowStyle({ row: row })\n      },\n      [columns.map(function (column) {\n        return h(Cell, {\n          key: column.key,\n          attrs: { tableRow: row,\n            tableColumn: column,\n            colSpan: getColSpan(row, column)\n          }\n        });\n      })]\n    );\n  }\n};\n\nvar RowsBlockLayout = {\n  name: 'RowsBlockLayout',\n  props: {\n    rows: {\n      type: Array,\n      required: true\n    },\n    columns: {\n      type: Array,\n      required: true\n    },\n    blockComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    getCellColSpan: {\n      getCellColSpan: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var rows = this.rows,\n        columns = this.columns,\n        Block = this.blockComponent,\n        rowComponent = this.rowComponent,\n        cellComponent = this.cellComponent,\n        getCellColSpan = this.getCellColSpan;\n\n\n    return h(Block, [rows.map(function (row) {\n      return h(RowLayout, {\n        key: row.key,\n        attrs: { row: row,\n          columns: columns,\n          rowComponent: rowComponent,\n          cellComponent: cellComponent,\n          getCellColSpan: getCellColSpan\n        }\n      });\n    })]);\n  }\n};\n\nvar StaticTableLayout = {\n  props: {\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    bodyComponent: {\n      type: Object,\n      required: true\n    },\n    headComponent: {\n      type: Object\n    },\n    tableComponent: {\n      type: Object,\n      required: true\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    columns: {\n      type: Array,\n      required: true\n    },\n    bodyRows: {\n      type: Array,\n      required: true\n    },\n    headerRows: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    minWidth: {\n      type: Number,\n      required: true\n    },\n    getCellColSpan: {\n      getCellColSpan: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var cellComponent = this.cellComponent,\n        rowComponent = this.rowComponent,\n        bodyComponent = this.bodyComponent,\n        headComponent = this.headComponent,\n        Table = this.tableComponent,\n        Container = this.containerComponent,\n        columns = this.columns,\n        bodyRows = this.bodyRows,\n        headerRows = this.headerRows,\n        minWidth = this.minWidth,\n        getCellColSpan = this.getCellColSpan;\n\n\n    return h(Container, [h(\n      Table,\n      {\n        style: { minWidth: minWidth + 'px' }\n      },\n      [h(ColumnGroup, {\n        attrs: { columns: columns }\n      }), !!headerRows.length && h(RowsBlockLayout, {\n        attrs: {\n          rows: headerRows,\n          columns: columns,\n          blockComponent: headComponent,\n          rowComponent: rowComponent,\n          cellComponent: cellComponent,\n          getCellColSpan: getCellColSpan\n        }\n      }), h(RowsBlockLayout, {\n        attrs: {\n          rows: bodyRows,\n          columns: columns,\n          blockComponent: bodyComponent,\n          rowComponent: rowComponent,\n          cellComponent: cellComponent,\n          getCellColSpan: getCellColSpan\n        }\n      })]\n    )]);\n  }\n};\n\nvar VirtualTableLayout = {\n  name: 'VirtualTableLayout',\n  props: {\n    minWidth: {\n      type: Number,\n      required: true\n    },\n    minColumnWidth: {\n      type: Number,\n      required: true\n    },\n    height: {\n      type: Number,\n      required: true\n    },\n    headerRows: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    bodyRows: {\n      type: Array,\n      required: true\n    },\n    columns: {\n      type: Array,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    bodyComponent: {\n      type: Object,\n      required: true\n    },\n    headComponent: {\n      type: Object,\n      default: function _default() {\n        return null;\n      }\n    },\n    tableComponent: {\n      type: Object,\n      required: true\n    },\n    headTableComponent: {\n      type: Object,\n      default: function _default() {\n        return null;\n      }\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    estimatedRowHeight: {\n      type: Number,\n      required: true\n    },\n    getCellColSpan: {\n      type: Function,\n      required: true\n    }\n  },\n  data: function data() {\n    return {\n      rowHeights: new Map(),\n      viewportTop: 0,\n      viewportLeft: 0\n    };\n  },\n  mounted: function mounted() {\n    this.storeRowHeights();\n  },\n  updated: function updated() {\n    this.storeRowHeights();\n  },\n\n  watch: {\n    headerRows: function headerRows(_headerRows) {\n      var prevRowHeight = this.rowHeights,\n          bodyRows = this.bodyRows;\n\n      var rowHeights = [_headerRows, bodyRows].reduce(function (acc, row) {\n        var rowHeight = prevRowHeight.get(row.key);\n        if (rowHeight !== undefined) {\n          acc.set(row.key, rowHeight);\n        }\n        return acc;\n      }, new Map());\n      this.rowHeights = rowHeights;\n    },\n    bodyRows: function bodyRows(_bodyRows) {\n      var prevRowHeight = this.rowHeights,\n          headerRows = this.headerRows;\n\n      var rowHeights = [headerRows, _bodyRows].reduce(function (acc, row) {\n        var rowHeight = prevRowHeight.get(row.key);\n        if (rowHeight !== undefined) {\n          acc.set(row.key, rowHeight);\n        }\n        return acc;\n      }, new Map());\n      this.rowHeights = rowHeights;\n    }\n  },\n  methods: {\n    getRowHeight: function getRowHeight(row) {\n      var storedHeight = this.rowHeights.get(row.key);\n      if (storedHeight !== undefined) return storedHeight;\n      if (row.height) return row.height;\n      return this.estimatedRowHeight;\n    },\n    storeRowHeights: function storeRowHeights() {\n      var _this = this;\n\n      var rowsWithChangedHeights = Object.keys(this.$refs).map(function (node) {\n        return _this.$refs[node];\n      }).filter(function (node) {\n        return !!node;\n      }).map(function (node) {\n        return [node.$attrs.row, node.$el.getBoundingClientRect().height];\n      }).filter(function (_ref) {\n        var _ref2 = slicedToArray(_ref, 2),\n            row = _ref2[0],\n            height = _ref2[1];\n\n        return height !== _this.getRowHeight(row);\n      });\n\n      if (rowsWithChangedHeights.length) {\n        var newRowHeights = new Map();\n        rowsWithChangedHeights.forEach(function (_ref3) {\n          var _ref4 = slicedToArray(_ref3, 2),\n              row = _ref4[0],\n              height = _ref4[1];\n\n          return newRowHeights.set(row.key, height);\n        });\n\n        this.rowHeights = newRowHeights;\n      }\n    },\n    updateViewport: function updateViewport(e) {\n      var node = e.target;\n\n      if (node !== e.currentTarget) {\n        return;\n      }\n\n      // NOTE: prevent iOS to flicker in bounces\n      if (node.scrollTop < 0 || node.scrollLeft < 0 || node.scrollLeft + node.clientWidth > Math.max(node.scrollWidth, node.clientWidth) || node.scrollTop + node.clientHeight > Math.max(node.scrollHeight, node.clientHeight)) {\n        return;\n      }\n\n      this.viewportTop = node.scrollTop;\n      this.viewportLeft = node.scrollLeft;\n    },\n    renderRowsBlock: function renderRowsBlock(collapsedGrid, Table, Body) {\n      var h = this.$createElement;\n      var minWidth = this.minWidth,\n          Row = this.rowComponent,\n          Cell = this.cellComponent;\n\n\n      return h(\n        Table,\n        {\n          style: { minWidth: minWidth + 'px' },\n          attrs: { minWidth: minWidth + 'px'\n          }\n        },\n        [h(ColumnGroup, {\n          attrs: {\n            columns: collapsedGrid.columns\n          }\n        }), h(Body, [collapsedGrid.rows.map(function (visibleRow) {\n          var row = visibleRow.row,\n              _visibleRow$cells = visibleRow.cells,\n              cells = _visibleRow$cells === undefined ? [] : _visibleRow$cells;\n\n          return h(\n            DxRefHolder,\n            {\n              key: row.key,\n              ref: '' + row.key,\n              attrs: { row: row\n              }\n            },\n            [h(\n              Row,\n              {\n                attrs: {\n                  tableRow: row,\n                  height: row.height !== undefined ? row.height + 'px' : undefined\n                }\n              },\n              [cells.map(function (cell) {\n                var column = cell.column;\n\n                return h(Cell, {\n                  key: column.key,\n                  attrs: { tableRow: row,\n                    tableColumn: column,\n\n                    colSpan: cell.colSpan\n                  },\n                  style: column.animationState });\n              })]\n            )]\n          );\n        })])]\n      );\n    }\n  },\n  render: function render() {\n    var _this2 = this;\n\n    var h = arguments[0];\n    var headerRows = this.headerRows,\n        bodyRows = this.bodyRows,\n        columns = this.columns,\n        minColumnWidth = this.minColumnWidth,\n        height = this.height,\n        Container = this.containerComponent,\n        HeadTable = this.headTableComponent,\n        Table = this.tableComponent,\n        Head = this.headComponent,\n        Body = this.bodyComponent,\n        getCellColSpan = this.getCellColSpan,\n        updateViewport = this.updateViewport,\n        renderRowsBlock = this.renderRowsBlock;\n\n\n    return h(DxSizer, [function (_ref5) {\n      var width = _ref5.width;\n\n      var headHeight = headerRows.reduce(function (acc, row) {\n        return acc + _this2.getRowHeight(row);\n      }, 0);\n      var getColSpan = function getColSpan(tableRow, tableColumn) {\n        return getCellColSpan({ tableRow: tableRow, tableColumn: tableColumn, tableColumns: columns });\n      };\n      var collapsedHeaderGrid = getCollapsedGrid({\n        rows: headerRows,\n        columns: columns,\n        top: 0,\n        left: _this2.viewportLeft,\n        width: width,\n        height: headHeight,\n        getColumnWidth: function getColumnWidth(column) {\n          return column.width || minColumnWidth;\n        },\n        getRowHeight: _this2.getRowHeight,\n        getColSpan: getColSpan\n      });\n      var collapsedBodyGrid = getCollapsedGrid({\n        rows: bodyRows,\n        columns: columns,\n        top: _this2.viewportTop,\n        left: _this2.viewportLeft,\n        width: width,\n        height: height - headHeight,\n        getColumnWidth: function getColumnWidth(column) {\n          return column.width || minColumnWidth;\n        },\n        getRowHeight: _this2.getRowHeight,\n        getColSpan: getColSpan\n      });\n      return h(\n        Container,\n        {\n          style: { height: height + 'px' },\n          on: {\n            'scroll': updateViewport\n          }\n        },\n        [!!headerRows.length && renderRowsBlock(collapsedHeaderGrid, HeadTable, Head), renderRowsBlock(collapsedBodyGrid, Table, Body)]\n      );\n    }]);\n  }\n};\n\nvar columnExtensionValueGetter = function columnExtensionValueGetter(columnExtensions, defaultValue) {\n  return getColumnExtensionValueGetter(columnExtensions, 'filteringEnabled', defaultValue);\n};\nvar filterExpressionComputed = function filterExpressionComputed(_ref) {\n  var filters = _ref.filters,\n      filterExpressionValue = _ref.filterExpression;\n  return filterExpression(filters, filterExpressionValue);\n};\n\nvar DxFilteringState = {\n  name: 'DxFilteringState',\n  props: {\n    filters: {\n      type: Array,\n      required: true\n    },\n    columnExtensions: {\n      type: Array\n    },\n    columnFilteringEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  methods: {\n    changeColumnFilter: function changeColumnFilter$$1(payload) {\n      this.$emit('update:filters', changeColumnFilter(this.filters, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var filters = this.filters,\n        columnExtensions = this.columnExtensions,\n        columnFilteringEnabled = this.columnFilteringEnabled;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxFilteringState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'filters', value: filters }\n      }), h(DxGetter, {\n        attrs: { name: 'filterExpression', computed: filterExpressionComputed }\n      }), h(DxGetter, {\n        attrs: {\n          name: 'isColumnFilteringEnabled',\n          value: columnExtensionValueGetter(columnExtensions, columnFilteringEnabled)\n        }\n      }), h(DxAction, {\n        attrs: { name: 'changeColumnFilter', action: this.changeColumnFilter }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$2 = [{ name: 'DxFilteringState', optional: true }, { name: 'DxSearchState', optional: true }];\n\nvar getCollapsedRowsComputed = function getCollapsedRowsComputed(_ref) {\n  var rows = _ref.rows;\n  return filteredCollapsedRowsGetter(rows);\n};\nvar unwrappedRowsComputed = function unwrappedRowsComputed(_ref2) {\n  var rows = _ref2.rows;\n  return unwrappedFilteredRows(rows);\n};\n\nvar DxIntegratedFiltering = {\n  name: 'DxIntegratedFiltering',\n  props: {\n    columnExtensions: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var columnExtensions = this.columnExtensions;\n\n    var getColumnPredicate = function getColumnPredicate(columnName) {\n      return getColumnExtension(columnExtensions, columnName).predicate;\n    };\n\n    var rowsComputed = function rowsComputed(_ref3) {\n      var rows = _ref3.rows,\n          filterExpression$$1 = _ref3.filterExpression,\n          getCellValue = _ref3.getCellValue,\n          getRowLevelKey = _ref3.getRowLevelKey,\n          getCollapsedRows = _ref3.getCollapsedRows;\n      return filteredRows(rows, filterExpression$$1, getCellValue, getColumnPredicate, getRowLevelKey, getCollapsedRows);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxIntegratedFiltering',\n          dependencies: pluginDependencies$2\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'rows', computed: rowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getCollapsedRows', computed: getCollapsedRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: unwrappedRowsComputed }\n      })]\n    );\n  }\n};\n\nDxIntegratedFiltering.defaultPredicate = defaultFilterPredicate;\n\nvar pluginDependencies$3 = [{ name: 'DxFilteringState' }, { name: 'DxTable' }, { name: 'DxDataTypeProvider', optional: true }];\n\nvar DxTableFilterRow = {\n  name: 'DxTableFilterRow',\n  props: {\n    rowHeight: {\n      type: Number\n    },\n    showFilterSelector: {\n      type: Boolean,\n      default: false\n    },\n    messages: {\n      type: Object\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    filterSelectorComponent: {\n      type: Object,\n      required: true\n    },\n    iconComponent: {\n      type: Object,\n      required: true\n    },\n    editorComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  data: function data() {\n    return {\n      filterOperations: {}\n    };\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var rowHeight = this.rowHeight,\n        showFilterSelector = this.showFilterSelector,\n        FilterCell = this.cellComponent,\n        FilterRow = this.rowComponent,\n        FilterSelector = this.filterSelectorComponent,\n        iconComponent = this.iconComponent,\n        EditorComponent = this.editorComponent,\n        messages = this.messages,\n        filterOperations = this.filterOperations;\n\n\n    var getMessage = getMessagesFormatter(messages);\n\n    var tableHeaderRowsComputed = function tableHeaderRowsComputed(_ref) {\n      var tableHeaderRows = _ref.tableHeaderRows;\n      return tableHeaderRowsWithFilter(tableHeaderRows, rowHeight);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableFilterRow',\n          dependencies: pluginDependencies$3\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableHeaderRows', computed: tableHeaderRowsComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var _ref2$attrs = _ref2.attrs,\n                  tableRow = _ref2$attrs.tableRow,\n                  tableColumn = _ref2$attrs.tableColumn;\n              return isFilterTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs,\n              listeners = _ref3.listeners;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var _ref4$getters = _ref4.getters,\n                filters = _ref4$getters.filters,\n                isColumnFilteringEnabled = _ref4$getters.isColumnFilteringEnabled,\n                getAvailableFilterOperations = _ref4$getters.getAvailableFilterOperations,\n                changeColumnFilter$$1 = _ref4.actions.changeColumnFilter;\n            var columnName = attrs.tableColumn.column.name;\n\n            var filter = getColumnFilterConfig(filters, columnName);\n            var onFilter = function onFilter(config) {\n              return changeColumnFilter$$1({ columnName: columnName, config: config });\n            };\n            var columnFilterOperations = getColumnFilterOperations(getAvailableFilterOperations, columnName);\n            var selectedFilterOperation = filterOperations[columnName] || columnFilterOperations[0];\n            var handleFilterOperationChange = function handleFilterOperationChange(value) {\n              _this.filterOperations = _extends({}, filterOperations, defineProperty({}, columnName, value));\n              if (filter && !isFilterValueEmpty(filter.value)) {\n                onFilter({ value: filter.value, operation: value });\n              }\n            };\n            var handleFilterValueChange = function handleFilterValueChange(value) {\n              onFilter(!isFilterValueEmpty(value) ? { value: value, operation: selectedFilterOperation } : null);\n            };\n            var filteringEnabled = isColumnFilteringEnabled(columnName);\n            return h(\n              DxTemplatePlaceholder,\n              {\n                attrs: {\n                  name: 'valueEditor',\n                  column: attrs.tableColumn.column,\n                  value: filter ? filter.value : undefined\n                },\n                on: {\n                  'valueChange': handleFilterValueChange\n                }\n              },\n              [function (content) {\n                return h(\n                  FilterCell,\n                  babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                    attrs: {\n                      getMessage: getMessage,\n                      column: attrs.tableColumn.column,\n                      filter: filter,\n                      filteringEnabled: filteringEnabled\n                    },\n                    on: {\n                      'filter': onFilter\n                    }\n                  }]),\n                  [showFilterSelector ? h(FilterSelector, {\n                    attrs: {\n                      iconComponent: iconComponent,\n                      value: selectedFilterOperation,\n                      availableValues: columnFilterOperations,\n\n                      disabled: !filteringEnabled,\n                      getMessage: getMessage\n                    },\n                    on: {\n                      'changeValue': handleFilterOperationChange\n                    }\n                  }) : null, content || h(EditorComponent, {\n                    attrs: {\n                      value: filter ? filter.value : '',\n                      disabled: !filteringEnabled,\n                      getMessage: getMessage\n                    },\n                    on: {\n                      'changeValue': handleFilterValueChange\n                    }\n                  })]\n                );\n              }]\n            );\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref5) {\n              var tableRow = _ref5.attrs.tableRow;\n              return isFilterTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref6) {\n          var attrs = _ref6.attrs,\n              listeners = _ref6.listeners,\n              slots = _ref6.slots;\n          return h(\n            FilterRow,\n            babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row\n              }\n            }]),\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar dependencies = [{ name: 'DxSortingState', optional: true }];\n\nvar callback = function callback(_ref, _ref2, _ref3, _ref4, columnName) {\n  var grouping = _ref.grouping;\n  var prevGrouping = _ref2.grouping;\n  var sorting = _ref3.sorting;\n  var changeColumnSorting$$1 = _ref4.changeColumnSorting;\n\n  if (!sorting) return;\n  var columnSortingIndex = sorting.findIndex(function (columnSorting) {\n    return columnSorting.columnName === columnName;\n  });\n  var prevGroupingIndex = prevGrouping.findIndex(function (columnGrouping) {\n    return columnGrouping.columnName === columnName;\n  });\n  var groupingIndex = grouping.findIndex(function (columnGrouping) {\n    return columnGrouping.columnName === columnName;\n  });\n\n  if (columnSortingIndex === -1 || prevGroupingIndex === prevGrouping.length - 1 && groupingIndex === -1) return;\n\n  var sortIndex = adjustSortIndex(groupingIndex === -1 ? grouping.length : groupingIndex, grouping, sorting);\n\n  if (columnSortingIndex === sortIndex) return;\n\n  changeColumnSorting$$1(_extends({\n    keepOther: true,\n    sortIndex: sortIndex\n  }, sorting[columnSortingIndex]));\n};\n\nvar columnExtensionValueGetter$1 = function columnExtensionValueGetter(columnExtensions, defaultValue) {\n  return getColumnExtensionValueGetter(columnExtensions, 'groupingEnabled', defaultValue);\n};\n\nvar DxGroupingState = {\n  name: 'DxGroupingState',\n  props: {\n    grouping: {\n      type: Array,\n      required: true\n    },\n    expandedGroups: {\n      type: Array,\n      required: true\n    },\n    columnExtensions: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    columnGroupingEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  methods: {\n    changeColumnSorting: function changeColumnSorting$$1(_ref5, _ref6, _ref7) {\n      var sorting = _ref6.sorting;\n      var changeColumnSorting$$1 = _ref7.changeColumnSorting;\n      var columnName = _ref5.columnName,\n          keepOther = _ref5.keepOther,\n          restParams = objectWithoutProperties(_ref5, ['columnName', 'keepOther']);\n      var grouping = this.grouping;\n\n      var groupingIndex = grouping.findIndex(function (columnGrouping) {\n        return columnGrouping.columnName === columnName;\n      });\n      if (groupingIndex === -1) {\n        changeColumnSorting$$1(_extends({\n          columnName: columnName,\n          keepOther: keepOther || grouping.map(function (columnGrouping) {\n            return columnGrouping.columnName;\n          })\n        }, restParams));\n        return false;\n      }\n\n      var sortIndex = adjustSortIndex(groupingIndex, grouping, sorting);\n      changeColumnSorting$$1(_extends({\n        columnName: columnName,\n        keepOther: true,\n        sortIndex: sortIndex\n      }, restParams));\n      return false;\n    },\n    changeColumnGrouping: function changeColumnGrouping$$1(_ref8, getters, actions) {\n      var columnName = _ref8.columnName,\n          groupingIndex = _ref8.groupingIndex;\n\n      var prevState = {\n        grouping: this.grouping,\n        expandedGroups: this.expandedGroups\n      };\n      var stateChange = changeColumnGrouping(prevState, { columnName: columnName, groupingIndex: groupingIndex });\n\n      this.$emit('update:grouping', stateChange.grouping);\n\n      callback(_extends({}, prevState, stateChange), prevState, getters, actions, columnName);\n    },\n    toggleGroupExpanded: function toggleGroupExpanded(_ref9) {\n      var groupKey = _ref9.groupKey;\n\n      this.$emit('update:expandedGroups', toggleExpandedGroups({ expandedGroups: this.expandedGroups }, { groupKey: groupKey }).expandedGroups);\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var grouping = this.grouping,\n        expandedGroups = this.expandedGroups;\n    var columnExtensions = this.columnExtensions,\n        columnGroupingEnabled = this.columnGroupingEnabled;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxGroupingState',\n          dependencies: dependencies\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'grouping', value: grouping }\n      }), h(DxGetter, {\n        attrs: {\n          name: 'isColumnGroupingEnabled',\n          value: columnExtensionValueGetter$1(columnExtensions, columnGroupingEnabled)\n        }\n      }), h(DxAction, {\n        attrs: { name: 'changeColumnGrouping', action: this.changeColumnGrouping }\n      }), h(DxGetter, {\n        attrs: { name: 'expandedGroups', value: expandedGroups }\n      }), h(DxAction, {\n        attrs: { name: 'toggleGroupExpanded', action: this.toggleGroupExpanded }\n      }), h(DxAction, {\n        attrs: { name: 'changeColumnSorting', action: this.changeColumnSorting }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$4 = [{ name: 'DxGroupingState' }];\n\nvar getCollapsedRowsComputed$1 = function getCollapsedRowsComputed(_ref) {\n  var getCollapsedRows = _ref.getCollapsedRows;\n  return groupCollapsedRowsGetter(getCollapsedRows);\n};\n\nvar expandedGroupedRowsComputed = function expandedGroupedRowsComputed(_ref2) {\n  var rows = _ref2.rows,\n      grouping = _ref2.grouping,\n      expandedGroups = _ref2.expandedGroups;\n  return expandedGroupRows(rows, grouping, expandedGroups);\n};\n\nvar DxIntegratedGrouping = {\n  name: 'DxIntegratedGrouping',\n  props: {\n    columnExtensions: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var columnExtensions = this.columnExtensions;\n\n    var getColumnCriteria = function getColumnCriteria(columnName) {\n      return getColumnExtension(columnExtensions, columnName).criteria;\n    };\n\n    var groupedRowsComputed = function groupedRowsComputed(_ref3) {\n      var rows = _ref3.rows,\n          grouping = _ref3.grouping,\n          getCellValue = _ref3.getCellValue;\n      return groupedRows(rows, grouping, getCellValue, getColumnCriteria);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxIntegratedGrouping',\n          dependencies: pluginDependencies$4\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'isGroupRow', value: groupRowChecker }\n      }), h(DxGetter, {\n        attrs: { name: 'getRowLevelKey', value: groupRowLevelKeyGetter }\n      }), h(DxGetter, {\n        attrs: { name: 'getCollapsedRows', computed: getCollapsedRowsComputed$1 }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: groupedRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: expandedGroupedRowsComputed }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$5 = [{ name: 'DxGroupingState' }];\n\nvar getCollapsedRowsComputed$2 = function getCollapsedRowsComputed(_ref) {\n  var getCollapsedRows = _ref.getCollapsedRows;\n  return groupCollapsedRowsGetter(getCollapsedRows);\n};\nvar expandedGroupedRowsComputed$1 = function expandedGroupedRowsComputed(_ref2) {\n  var rows = _ref2.rows,\n      grouping = _ref2.grouping,\n      expandedGroups = _ref2.expandedGroups;\n  return expandedGroupRows(rows, grouping, expandedGroups);\n};\nvar getRowIdComputed = function getRowIdComputed(_ref3) {\n  var getRowId = _ref3.getRowId,\n      rows = _ref3.rows;\n  return customGroupingRowIdGetter(getRowId, rows);\n};\n\nvar DxCustomGrouping = {\n  name: 'DxCustomGrouping',\n  props: {\n    getChildGroups: {\n      type: Function,\n      required: true\n    },\n    grouping: {\n      type: Array\n    },\n    expandedGroups: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var getChildGroups = this.getChildGroups,\n        appliedGrouping = this.grouping,\n        appliedExpandedGroups = this.expandedGroups;\n\n    var groupedRowsComputed = function groupedRowsComputed(_ref4) {\n      var rows = _ref4.rows,\n          grouping = _ref4.grouping;\n      return customGroupedRows(rows, grouping, getChildGroups);\n    };\n    var groupingComputed = function groupingComputed(_ref5) {\n      var grouping = _ref5.grouping;\n      return appliedGrouping || grouping;\n    };\n    var expandedGroupsComputed = function expandedGroupsComputed(_ref6) {\n      var expandedGroups = _ref6.expandedGroups;\n      return appliedExpandedGroups || expandedGroups;\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxCustomGrouping',\n          dependencies: pluginDependencies$5\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'grouping', computed: groupingComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'expandedGroups', computed: expandedGroupsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'isGroupRow', value: groupRowChecker }\n      }), h(DxGetter, {\n        attrs: { name: 'getRowLevelKey', value: groupRowLevelKeyGetter }\n      }), h(DxGetter, {\n        attrs: { name: 'getCollapsedRows', computed: getCollapsedRowsComputed$2 }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: groupedRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getRowId', computed: getRowIdComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: expandedGroupedRowsComputed$1 }\n      })]\n    );\n  }\n};\n\nvar DxGroupingPanel = {\n  props: {\n    showSortingControls: {\n      type: Boolean\n    },\n    showGroupingControls: {\n      type: Boolean\n    },\n    messages: {\n      type: Object\n    },\n    layoutComponent: {\n      type: Object,\n      required: true\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    itemComponent: {\n      type: Object,\n      required: true\n    },\n    emptyMessageComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Layout = this.layoutComponent,\n        Container = this.containerComponent,\n        Item = this.itemComponent,\n        EmptyMessage = this.emptyMessageComponent,\n        showSortingControls = this.showSortingControls,\n        showGroupingControls = this.showGroupingControls,\n        messages = this.messages;\n\n\n    var getMessage = getMessagesFormatter(messages);\n\n    var EmptyMessagePlaceholder = {\n      render: function render() {\n        var h = arguments[0];\n\n        return h(EmptyMessage, {\n          attrs: {\n            getMessage: getMessage\n          }\n        });\n      }\n    };\n\n    var ItemPlaceholder = {\n      props: {\n        item: {\n          type: Object,\n          required: true\n        }\n      },\n      render: function render() {\n        var _this = this;\n\n        var h = arguments[0];\n        var columnName = this.item.column.name;\n\n\n        return h(DxTemplateConnector, [function (_ref) {\n          var _ref$getters = _ref.getters,\n              sorting = _ref$getters.sorting,\n              isColumnSortingEnabled = _ref$getters.isColumnSortingEnabled,\n              isColumnGroupingEnabled = _ref$getters.isColumnGroupingEnabled,\n              _ref$actions = _ref.actions,\n              changeColumnGrouping$$1 = _ref$actions.changeColumnGrouping,\n              changeColumnSorting$$1 = _ref$actions.changeColumnSorting;\n\n          var sortingEnabled = isColumnSortingEnabled && isColumnSortingEnabled(columnName);\n          var groupingEnabled = isColumnGroupingEnabled && isColumnGroupingEnabled(columnName);\n\n          return h(Item, {\n            attrs: {\n              item: _this.item,\n              sortingEnabled: sortingEnabled,\n              groupingEnabled: groupingEnabled,\n              showSortingControls: showSortingControls,\n              sortingDirection: showSortingControls ? getColumnSortingDirection(sorting, columnName) : undefined,\n              showGroupingControls: showGroupingControls\n            },\n            on: {\n              'group': function group() {\n                return changeColumnGrouping$$1({ columnName: columnName });\n              },\n              'sort': function sort(_ref2) {\n                var direction = _ref2.direction,\n                    keepOther = _ref2.keepOther;\n                return changeColumnSorting$$1({ columnName: columnName, direction: direction, keepOther: keepOther });\n              }\n            }\n          });\n        }]);\n      }\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxGroupingPanel',\n          dependencies: [{ name: 'DxGroupingState' }, { name: 'DxToolbar' }, { name: 'DxSortingState', optional: !showSortingControls }]\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: { name: 'toolbarContent' }\n        },\n        [h(\n          'div',\n          { style: { display: 'flex', flex: 1 } },\n          [h(DxTemplateConnector, [function (_ref3) {\n            var _ref3$getters = _ref3.getters,\n                columns = _ref3$getters.columns,\n                grouping = _ref3$getters.grouping,\n                isColumnGroupingEnabled = _ref3$getters.isColumnGroupingEnabled,\n                changeColumnGrouping$$1 = _ref3.actions.changeColumnGrouping;\n            return h(Layout, {\n              attrs: {\n                items: groupingPanelItems(columns, grouping, []),\n                isColumnGroupingEnabled: isColumnGroupingEnabled,\n\n                itemComponent: ItemPlaceholder,\n                emptyMessageComponent: EmptyMessagePlaceholder,\n                containerComponent: Container\n              },\n              on: {\n                'group': changeColumnGrouping$$1\n              }\n            });\n          }]), h(DxTemplatePlaceholder)]\n        )]\n      )]\n    );\n  }\n};\n\nvar pluginDependencies$6 = [{ name: 'DxGroupingState' }, { name: 'DxTable' }, { name: 'DxDataTypeProvider', optional: true }];\n\nvar tableBodyRowsComputed$1 = function tableBodyRowsComputed(_ref) {\n  var tableBodyRows = _ref.tableBodyRows,\n      isGroupRow = _ref.isGroupRow;\n  return tableRowsWithGrouping(tableBodyRows, isGroupRow);\n};\nvar getCellColSpanComputed = function getCellColSpanComputed(_ref2) {\n  var getTableCellColSpan = _ref2.getTableCellColSpan;\n  return tableGroupCellColSpanGetter(getTableCellColSpan);\n};\n\nvar showColumnWhenGroupedGetter = function showColumnWhenGroupedGetter(showColumnsWhenGrouped) {\n  var columnExtensions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n\n  var map = columnExtensions.reduce(function (acc, columnExtension) {\n    acc[columnExtension.columnName] = columnExtension.showWhenGrouped;\n    return acc;\n  }, {});\n\n  return function (columnName) {\n    return map[columnName] || showColumnsWhenGrouped;\n  };\n};\n\nvar DxTableGroupRow = {\n  name: 'DxTableGroupRow',\n  props: {\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    indentCellComponent: {\n      type: Object\n    },\n    indentColumnWidth: {\n      type: Number,\n      required: true\n    },\n    showColumnsWhenGrouped: {\n      type: Boolean\n    },\n    columnExtensions: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var GroupCell = this.cellComponent,\n        GroupRow = this.rowComponent,\n        GroupIndentCell = this.indentCellComponent,\n        indentColumnWidth = this.indentColumnWidth,\n        showColumnsWhenGrouped = this.showColumnsWhenGrouped,\n        columnExtensions = this.columnExtensions;\n\n\n    var tableColumnsComputed = function tableColumnsComputed(_ref3) {\n      var columns = _ref3.columns,\n          tableColumns = _ref3.tableColumns,\n          grouping = _ref3.grouping;\n      return tableColumnsWithGrouping(columns, tableColumns, grouping, grouping, indentColumnWidth, showColumnWhenGroupedGetter(showColumnsWhenGrouped, columnExtensions));\n    };\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableGroupRow',\n          dependencies: pluginDependencies$6\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: tableColumnsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'tableBodyRows', computed: tableBodyRowsComputed$1 }\n      }), h(DxGetter, {\n        attrs: { name: 'getTableCellColSpan', computed: getCellColSpanComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref4) {\n              var tableRow = _ref4.attrs.tableRow;\n              return isGroupTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref5) {\n          var attrs = _ref5.attrs,\n              listeners = _ref5.listeners;\n          return h(DxTemplateConnector, [function (_ref6) {\n            var _ref6$getters = _ref6.getters,\n                grouping = _ref6$getters.grouping,\n                expandedGroups = _ref6$getters.expandedGroups,\n                toggleGroupExpanded = _ref6.actions.toggleGroupExpanded;\n\n            if (isGroupTableCell(attrs.tableRow, attrs.tableColumn)) {\n              return h(\n                DxTemplatePlaceholder,\n                {\n                  attrs: {\n                    name: 'valueFormatter',\n                    column: attrs.tableColumn.column,\n                    value: attrs.tableRow.row.value\n                  }\n                },\n                [function (content) {\n                  return h(\n                    GroupCell,\n                    babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                      attrs: {\n                        row: attrs.tableRow.row,\n                        column: attrs.tableColumn.column,\n                        expanded: expandedGroups.indexOf(attrs.tableRow.row.compoundKey) !== -1\n                      },\n                      on: {\n                        'toggle': function toggle() {\n                          return toggleGroupExpanded({ groupKey: attrs.tableRow.row.compoundKey });\n                        }\n                      }\n                    }]),\n                    [content]\n                  );\n                }]\n              );\n            }\n            if (isGroupIndentTableCell(attrs.tableRow, attrs.tableColumn, grouping)) {\n              if (GroupIndentCell) {\n                return h(GroupIndentCell, babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                  attrs: {\n                    row: attrs.tableRow.row,\n                    column: attrs.tableColumn.column\n                  }\n                }]));\n              }\n              return h(DxTemplatePlaceholder);\n            }\n            return null;\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref7) {\n              var tableRow = _ref7.attrs.tableRow;\n              return isGroupTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref8) {\n          var attrs = _ref8.attrs,\n              listeners = _ref8.listeners,\n              slots = _ref8.slots;\n          return h(\n            GroupRow,\n            babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row\n              }\n            }]),\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar ItemLayout = {\n  props: {\n    item: {\n      type: Object,\n      required: true\n    },\n    itemComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var item = this.item,\n        Item = this.itemComponent;\n\n    return h(Item, {\n      attrs: { item: _extends({}, item) }\n    });\n  }\n};\n\nvar GroupPanelLayout = {\n  props: {\n    items: {\n      type: Array,\n      required: true\n    },\n    itemComponent: {\n      type: Object,\n      required: true\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    emptyMessageComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var items = this.items,\n        EmptyMessage = this.emptyMessageComponent,\n        Container = this.containerComponent,\n        Item = this.itemComponent;\n\n\n    var groupPanel = items.length ? h(Container, [items.map(function (item) {\n      var columnName = item.column.name;\n\n      return h(ItemLayout, {\n        key: columnName,\n        attrs: { item: item,\n          itemComponent: Item\n        }\n      });\n    })]) : h(EmptyMessage);\n\n    return groupPanel;\n  }\n};\n\nvar DxSearchState = {\n  name: 'DxSearchState',\n  props: {\n    value: {\n      type: String,\n      required: true\n    }\n  },\n  methods: {\n    changeValue: function changeValue(payload) {\n      this.$emit('update:value', changeSearchValue(this.value, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var value = this.value,\n        changeValue = this.changeValue;\n\n    var filterExpressionComputed = function filterExpressionComputed(_ref) {\n      var filterExpression$$1 = _ref.filterExpression,\n          columns = _ref.columns;\n      return searchFilterExpression(value, columns, filterExpression$$1);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxSearchState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'filterExpression', computed: filterExpressionComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'searchValue', value: value }\n      }), h(DxAction, {\n        attrs: { name: 'changeSearchValue', action: changeValue }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$7 = [{ name: 'DxToolbar' }, { name: 'DxSearchState' }];\n\nvar DxSearchPanel = {\n  name: 'DxSearchPanel',\n  props: {\n    inputComponent: {\n      type: Object,\n      required: true\n    },\n    messages: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Input = this.inputComponent,\n        messages = this.messages;\n\n    var getMessage = getMessagesFormatter(messages);\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxSearchPanel',\n          dependencies: pluginDependencies$7\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: { name: 'toolbarContent' }\n        },\n        [h(\n          'div',\n          { style: { display: 'flex', flex: 1 } },\n          [h(DxTemplatePlaceholder), h(DxTemplateConnector, [function (_ref) {\n            var searchValue = _ref.getters.searchValue,\n                changeSearchValue$$1 = _ref.actions.changeSearchValue;\n            return h(Input, {\n              attrs: {\n                value: searchValue,\n\n                getMessage: getMessage\n              },\n              on: {\n                'valueChange': changeSearchValue$$1\n              }\n            });\n          }])]\n        )]\n      )]\n    );\n  }\n};\n\nvar DxSelectionState = {\n  name: 'DxSelectionState',\n  props: {\n    selection: {\n      type: Array,\n      required: true\n    }\n  },\n  methods: {\n    toggleSelection: function toggleSelection$$1(payload) {\n      this.$emit('update:selection', toggleSelection(this.selection, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxSelectionState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'selection', value: this.selection }\n      }), h(DxAction, {\n        attrs: { name: 'toggleSelection', action: this.toggleSelection }\n      })]\n    );\n  }\n};\n\nvar rowsWithAvailableToSelectComputed = function rowsWithAvailableToSelectComputed(_ref) {\n  var rows = _ref.rows,\n      getRowId = _ref.getRowId,\n      isGroupRow = _ref.isGroupRow;\n  return rowsWithAvailableToSelect(rows, getRowId, isGroupRow);\n};\nvar allSelectedComputed = function allSelectedComputed(_ref2) {\n  var rows = _ref2.rows,\n      selection = _ref2.selection;\n  return allSelected(rows, selection);\n};\nvar someSelectedComputed = function someSelectedComputed(_ref3) {\n  var rows = _ref3.rows,\n      selection = _ref3.selection;\n  return someSelected(rows, selection);\n};\nvar selectAllAvailableComputed = function selectAllAvailableComputed(_ref4) {\n  var availableToSelect = _ref4.rows.availableToSelect;\n  return !!availableToSelect.length;\n};\nvar toggleSelectAll = function toggleSelectAll(state, _ref5, _ref6) {\n  var availableToSelect = _ref5.rows.availableToSelect;\n  var toggleSelection$$1 = _ref6.toggleSelection;\n\n  toggleSelection$$1({ rowIds: availableToSelect, state: state });\n};\nvar unwrapRowsComputed = function unwrapRowsComputed(_ref7) {\n  var rows = _ref7.rows;\n  return unwrapSelectedRows(rows);\n};\n\nvar pluginDependencies$8 = [{ name: 'DxSelectionState' }];\n\nvar DxIntegratedSelection = {\n  name: 'DxIntegratedSelection',\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxIntegratedSelection',\n          dependencies: pluginDependencies$8\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'rows', computed: rowsWithAvailableToSelectComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'allSelected', computed: allSelectedComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'someSelected', computed: someSelectedComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'selectAllAvailable', computed: selectAllAvailableComputed }\n      }), h(DxAction, {\n        attrs: { name: 'toggleSelectAll', action: toggleSelectAll }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: unwrapRowsComputed }\n      })]\n    );\n  }\n};\n\nvar DxTableSelection = {\n  name: 'DxTableSelection',\n  props: {\n    highlightRow: {\n      type: Boolean\n    },\n    selectByRowClick: {\n      type: Boolean\n    },\n    showSelectionColumn: {\n      type: Boolean,\n      default: true\n    },\n    showSelectAll: {\n      type: Boolean\n    },\n    selectionColumnWidth: {\n      type: Number,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    headerCellComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var highlightRow = this.highlightRow,\n        selectByRowClick = this.selectByRowClick,\n        showSelectionColumn = this.showSelectionColumn,\n        showSelectAll = this.showSelectAll,\n        HeaderCell = this.headerCellComponent,\n        Cell = this.cellComponent,\n        Row = this.rowComponent,\n        selectionColumnWidth = this.selectionColumnWidth;\n\n\n    var tableColumnsComputed = function tableColumnsComputed(_ref) {\n      var tableColumns = _ref.tableColumns;\n      return tableColumnsWithSelection(tableColumns, selectionColumnWidth);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableSelection',\n          dependencies: [{ name: 'DxTable' }, { name: 'DxSelectionState' }, { name: 'DxIntegratedSelection', optional: !showSelectAll }]\n        }\n      },\n      [showSelectionColumn && h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: tableColumnsComputed }\n      }), showSelectionColumn && showSelectAll && h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var _ref2$attrs = _ref2.attrs,\n                  tableRow = _ref2$attrs.tableRow,\n                  tableColumn = _ref2$attrs.tableColumn;\n              return isSelectAllTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs,\n              listeners = _ref3.listeners;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var _ref4$getters = _ref4.getters,\n                selectAllAvailable = _ref4$getters.selectAllAvailable,\n                allSelected$$1 = _ref4$getters.allSelected,\n                someSelected$$1 = _ref4$getters.someSelected,\n                toggleSelectAll = _ref4.actions.toggleSelectAll;\n            return h(HeaderCell, babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                disabled: !selectAllAvailable,\n                allSelected: allSelected$$1,\n                someSelected: someSelected$$1\n              },\n              on: {\n                'toggle': function toggle(select) {\n                  return toggleSelectAll(select);\n                }\n              }\n            }]));\n          }]);\n        }]\n      ), showSelectionColumn && h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref5) {\n              var _ref5$attrs = _ref5.attrs,\n                  tableRow = _ref5$attrs.tableRow,\n                  tableColumn = _ref5$attrs.tableColumn;\n              return isSelectTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref6) {\n          var attrs = _ref6.attrs,\n              listeners = _ref6.listeners;\n          return h(DxTemplateConnector, [function (_ref7) {\n            var selection = _ref7.getters.selection,\n                toggleSelection$$1 = _ref7.actions.toggleSelection;\n            return h(Cell, babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row,\n                selected: selection.indexOf(attrs.tableRow.rowId) !== -1\n              },\n              on: {\n                'toggle': function toggle() {\n                  return toggleSelection$$1({ rowIds: [attrs.tableRow.rowId] });\n                }\n              }\n            }]));\n          }]);\n        }]\n      ), (highlightRow || selectByRowClick) && h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref8) {\n              var tableRow = _ref8.attrs.tableRow;\n              return isDataTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref9) {\n          var attrs = _ref9.attrs,\n              listeners = _ref9.listeners,\n              slots = _ref9.slots;\n          return h(DxTemplateConnector, [function (_ref10) {\n            var selection = _ref10.getters.selection,\n                toggleSelection$$1 = _ref10.actions.toggleSelection;\n            return h(\n              Row,\n              babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                attrs: {\n                  selectByRowClick: selectByRowClick,\n                  selected: highlightRow && selection.indexOf(attrs.tableRow.rowId) !== -1\n                },\n                on: {\n                  'toggle': function toggle() {\n                    return toggleSelection$$1({ rowIds: [attrs.tableRow.rowId] });\n                  }\n                }\n              }]),\n              [slots.default]\n            );\n          }]);\n        }]\n      )]\n    );\n  }\n};\n\nvar DxPagingState = {\n  name: 'DxPagingState',\n  props: {\n    currentPage: {\n      type: Number,\n      required: true\n    },\n    pageSize: {\n      type: Number,\n      default: 10\n    }\n  },\n  methods: {\n    setCurrentPage: function setCurrentPage$$1(payload) {\n      this.$emit('update:currentPage', setCurrentPage(this.currentPage, payload));\n    },\n    setPageSize: function setPageSize$$1(payload) {\n      this.$emit('update:pageSize', setPageSize(this.pageSize, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var pageSize = this.pageSize,\n        currentPage$$1 = this.currentPage;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxPagingState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'pageSize', value: pageSize }\n      }), h(DxGetter, {\n        attrs: { name: 'currentPage', value: currentPage$$1 }\n      }), h(DxAction, {\n        attrs: { name: 'setCurrentPage', action: this.setCurrentPage }\n      }), h(DxAction, {\n        attrs: { name: 'setPageSize', action: this.setPageSize }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$9 = [{ name: 'DxPagingState' }];\n\nvar rowsWithHeadersComputed = function rowsWithHeadersComputed(_ref) {\n  var rows = _ref.rows,\n      pageSize = _ref.pageSize,\n      getRowLevelKey = _ref.getRowLevelKey;\n  return rowsWithPageHeaders(rows, pageSize, getRowLevelKey);\n};\nvar totalCountComputed = function totalCountComputed(_ref2) {\n  var rows = _ref2.rows;\n  return rowCount(rows);\n};\nvar paginatedRowsComputed = function paginatedRowsComputed(_ref3) {\n  var rows = _ref3.rows,\n      pageSize = _ref3.pageSize,\n      page = _ref3.currentPage;\n  return paginatedRows(rows, pageSize, page);\n};\nvar currentPageComputed = function currentPageComputed(_ref4, _ref5) {\n  var page = _ref4.currentPage,\n      totalCount = _ref4.totalCount,\n      pageSize = _ref4.pageSize;\n  var setCurrentPage$$1 = _ref5.setCurrentPage;\n  return currentPage(page, totalCount, pageSize, setCurrentPage$$1);\n};\n\nvar DxIntegratedPaging = {\n  name: 'DxIntegratedPaging',\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxIntegratedPaging',\n          dependencies: pluginDependencies$9\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'rows', computed: rowsWithHeadersComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'totalCount', computed: totalCountComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'currentPage', computed: currentPageComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: paginatedRowsComputed }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$a = [{ name: 'DxPagingState' }];\n\nvar DxCustomPaging = {\n  name: 'DxCustomPaging',\n  props: {\n    totalCount: {\n      type: Number,\n      default: 0\n    }\n  },\n\n  render: function render() {\n    var h = arguments[0];\n    var totalCount = this.totalCount;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxCustomPaging',\n          dependencies: pluginDependencies$a\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'totalCount', value: totalCount }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$b = [{ name: 'DxPagingState' }];\n\nvar DxPagingPanel = {\n  name: 'DxPagingPanel',\n  props: {\n    pageSizes: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    messages: {\n      type: Object\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    }\n  },\n\n  render: function render() {\n    var h = arguments[0];\n    var Pager = this.containerComponent,\n        pageSizes = this.pageSizes,\n        messages = this.messages;\n\n    var getMessage = getMessagesFormatter(messages);\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxPagingPanel',\n          dependencies: pluginDependencies$b\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: { name: 'footer' }\n        },\n        [h('div', [' ', h(DxTemplatePlaceholder), h(DxTemplateConnector, [function (_ref) {\n          var _ref$getters = _ref.getters,\n              currentPage$$1 = _ref$getters.currentPage,\n              pageSize = _ref$getters.pageSize,\n              totalCount = _ref$getters.totalCount,\n              _ref$actions = _ref.actions,\n              setCurrentPage$$1 = _ref$actions.setCurrentPage,\n              setPageSize$$1 = _ref$actions.setPageSize;\n          return h(Pager, {\n            attrs: {\n              currentPage: currentPage$$1,\n              pageSize: pageSize,\n              totalCount: totalCount,\n              totalPages: pageCount(totalCount, pageSize),\n              pageSizes: pageSizes,\n              getMessage: getMessage\n            },\n            on: {\n              'currentPageChange': setCurrentPage$$1,\n              'pageSizeChange': setPageSize$$1\n            }\n          });\n        }])])]\n      )]\n    );\n  }\n};\n\nvar DxDataTypeProvider = {\n  name: 'DxDataTypeProvider',\n  props: {\n    for: {\n      type: Array,\n      required: true\n    },\n    formatterComponent: {\n      type: Object\n    },\n    editorComponent: {\n      type: Object\n    },\n    availableFilterOperations: {\n      type: Array\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var columnNames = this.for,\n        Formatter = this.formatterComponent,\n        Editor = this.editorComponent,\n        availableFilterOperations = this.availableFilterOperations;\n\n\n    var getAvailableFilterOperationsComputed = function getAvailableFilterOperationsComputed(_ref) {\n      var getAvailableFilterOperations = _ref.getAvailableFilterOperations;\n      return getAvailableFilterOperationsGetter(getAvailableFilterOperations, availableFilterOperations, columnNames);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: { name: 'DxDataTypeProvider' }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'getAvailableFilterOperations', computed: getAvailableFilterOperationsComputed }\n      }), Formatter ? h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'valueFormatter',\n            predicate: function predicate(_ref2) {\n              var column = _ref2.attrs.column;\n              return columnNames.includes(column.name);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs;\n          return h(Formatter, { attrs: attrs });\n        }]\n      ) : null, Editor ? h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'valueEditor',\n            predicate: function predicate(_ref4) {\n              var column = _ref4.attrs.column;\n              return columnNames.includes(column.name);\n            }\n          }\n        },\n        [function (_ref5) {\n          var attrs = _ref5.attrs,\n              listeners = _ref5.listeners;\n          return h(Editor, { attrs: _extends({}, attrs), on: _extends({}, listeners) });\n        }]\n      ) : null]\n    );\n  }\n};\n\nvar DxRowDetailState = {\n  name: 'DxRowDetailState',\n  props: {\n    expandedRowIds: {\n      type: Array,\n      required: true\n    }\n  },\n  methods: {\n    toggleDetailRowExpanded: function toggleDetailRowExpanded$$1(payload) {\n      this.$emit('update:expandedRowIds', toggleDetailRowExpanded(this.expandedRowIds, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxRowDetailState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'expandedDetailRowIds', value: this.expandedRowIds }\n      }), h(DxAction, {\n        attrs: { name: 'toggleDetailRowExpanded', action: this.toggleDetailRowExpanded }\n      })]\n    );\n  }\n};\n\nvar getCellColSpanComputed$1 = function getCellColSpanComputed(_ref) {\n  var getTableCellColSpan = _ref.getTableCellColSpan;\n  return tableDetailCellColSpanGetter(getTableCellColSpan);\n};\n\nvar pluginDependencies$c = [{ name: 'DxRowDetailState' }, { name: 'DxTable' }];\n\nvar DxTableRowDetail = {\n  name: 'DxTableRowDetail',\n  props: {\n    contentComponent: {\n      type: Object\n    },\n    toggleCellComponent: {\n      type: Object,\n      required: true\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    },\n    toggleColumnWidth: {\n      type: Number,\n      required: true\n    },\n    rowHeight: {\n      type: Number\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var rowHeight = this.rowHeight,\n        Content = this.contentComponent,\n        ToggleCell = this.toggleCellComponent,\n        Cell = this.cellComponent,\n        Row = this.rowComponent,\n        toggleColumnWidth = this.toggleColumnWidth;\n\n\n    var tableColumnsComputed = function tableColumnsComputed(_ref2) {\n      var tableColumns = _ref2.tableColumns;\n      return tableColumnsWithDetail(tableColumns, toggleColumnWidth);\n    };\n    var tableBodyRowsComputed = function tableBodyRowsComputed(_ref3) {\n      var tableBodyRows = _ref3.tableBodyRows,\n          expandedDetailRowIds = _ref3.expandedDetailRowIds;\n      return tableRowsWithExpandedDetail(tableBodyRows, expandedDetailRowIds, rowHeight);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableRowDetail',\n          dependencies: pluginDependencies$c\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: tableColumnsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'tableBodyRows', computed: tableBodyRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getTableCellColSpan', computed: getCellColSpanComputed$1 }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref4) {\n              var _ref4$attrs = _ref4.attrs,\n                  tableRow = _ref4$attrs.tableRow,\n                  tableColumn = _ref4$attrs.tableColumn;\n              return isDetailToggleTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref5) {\n          var attrs = _ref5.attrs,\n              listeners = _ref5.listeners;\n          return h(DxTemplateConnector, [function (_ref6) {\n            var expandedDetailRowIds = _ref6.getters.expandedDetailRowIds,\n                toggleDetailRowExpanded$$1 = _ref6.actions.toggleDetailRowExpanded;\n            return h(ToggleCell, babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row,\n                expanded: isDetailRowExpanded(expandedDetailRowIds, attrs.tableRow.rowId)\n              },\n              on: {\n                'toggle': function toggle() {\n                  return toggleDetailRowExpanded$$1({ rowId: attrs.tableRow.rowId });\n                }\n              }\n            }]));\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref7) {\n              var tableRow = _ref7.attrs.tableRow;\n              return isDetailTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref8) {\n          var attrs = _ref8.attrs,\n              listeners = _ref8.listeners;\n          return h(DxTemplateConnector, [function (_ref9) {\n            var tableColumns = _ref9.getters.tableColumns;\n\n            if (isDetailTableCell(attrs.tableColumn, tableColumns)) {\n              return h(\n                Cell,\n                babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                  attrs: {\n                    row: attrs.tableRow.row\n                  }\n                }]),\n                [h(Content, {\n                  attrs: { row: attrs.tableRow.row }\n                })]\n              );\n            }\n            return null;\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref10) {\n              var tableRow = _ref10.attrs.tableRow;\n              return isDetailTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref11) {\n          var attrs = _ref11.attrs,\n              listeners = _ref11.listeners,\n              slots = _ref11.slots;\n          return h(\n            Row,\n            babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row\n              }\n            }]),\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar columnExtensionValueGetter$2 = function columnExtensionValueGetter(columnExtensions, defaultValue) {\n  return getColumnExtensionValueGetter(columnExtensions, 'editingEnabled', defaultValue);\n};\n\nvar DxEditingState = {\n  name: 'DxEditingState',\n  props: {\n    createRowChange: {\n      type: Function\n    },\n    columnEditingEnabled: {\n      type: Boolean,\n      default: true\n    },\n    columnExtensions: {\n      type: Array\n    },\n    editingRowIds: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    addedRows: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    rowChanges: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    },\n    deletedRowIds: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    }\n  },\n  methods: {\n    startEditRows: function startEditRows$$1(payload) {\n      this.$emit('update:editingRowIds', startEditRows(this.editingRowIds, payload));\n    },\n    stopEditRows: function stopEditRows$$1(payload) {\n      this.$emit('update:editingRowIds', stopEditRows(this.editingRowIds, payload));\n    },\n    changeRow: function changeRow$$1(payload) {\n      this.$emit('update:rowChanges', changeRow(this.rowChanges, payload));\n    },\n    cancelChangedRows: function cancelChangedRows(payload) {\n      this.$emit('update:rowChanges', cancelChanges(this.rowChanges, payload));\n    },\n    commitChangedRows: function commitChangedRows(_ref) {\n      var rowIds = _ref.rowIds;\n\n      this.$emit('commitChanges', { changed: changedRowsByIds(this.rowChanges, rowIds) });\n      this.cancelChangedRows({ rowIds: rowIds });\n    },\n    addRow: function addRow$$1(payload) {\n      this.$emit('update:addedRows', addRow(this.addedRows, payload));\n    },\n    changeAddedRow: function changeAddedRow$$1(payload) {\n      this.$emit('update:addedRows', changeAddedRow(this.addedRows, payload));\n    },\n    cancelAddedRows: function cancelAddedRows$$1(payload) {\n      this.$emit('update:addedRows', cancelAddedRows(this.addedRows, payload));\n    },\n    commitAddedRows: function commitAddedRows(_ref2) {\n      var rowIds = _ref2.rowIds;\n\n      this.$emit('commitChanges', { added: addedRowsByIds(this.addedRows, rowIds) });\n      this.cancelAddedRows({ rowIds: rowIds });\n    },\n    deleteRows: function deleteRows$$1(payload) {\n      this.$emit('update:deletedRowIds', deleteRows(this.deletedRowIds, payload));\n    },\n    cancelDeletedRows: function cancelDeletedRows$$1(payload) {\n      this.$emit('update:deletedRowIds', cancelDeletedRows(this.deletedRowIds, payload));\n    },\n    commitDeletedRows: function commitDeletedRows(_ref3) {\n      var rowIds = _ref3.rowIds;\n\n      this.$emit('commitChanges', { deleted: rowIds });\n      this.cancelDeletedRows({ rowIds: rowIds });\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var createRowChange = this.createRowChange,\n        columnExtensions = this.columnExtensions,\n        columnEditingEnabled = this.columnEditingEnabled,\n        editingRowIds = this.editingRowIds,\n        rowChanges = this.rowChanges,\n        addedRows = this.addedRows,\n        deletedRowIds = this.deletedRowIds;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxEditingState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: {\n          name: 'createRowChange',\n          value: createRowChangeGetter(createRowChange, columnExtensions)\n        }\n      }), h(DxGetter, {\n        attrs: { name: 'editingRowIds', value: editingRowIds }\n      }), h(DxAction, {\n        attrs: { name: 'startEditRows', action: this.startEditRows }\n      }), h(DxAction, {\n        attrs: { name: 'stopEditRows', action: this.stopEditRows }\n      }), h(DxGetter, {\n        attrs: { name: 'rowChanges', value: rowChanges }\n      }), h(DxAction, {\n        attrs: { name: 'changeRow', action: this.changeRow }\n      }), h(DxAction, {\n        attrs: { name: 'cancelChangedRows', action: this.cancelChangedRows }\n      }), h(DxAction, {\n        attrs: { name: 'commitChangedRows', action: this.commitChangedRows }\n      }), h(DxGetter, {\n        attrs: { name: 'addedRows', value: addedRows }\n      }), h(DxAction, {\n        attrs: { name: 'addRow', action: this.addRow }\n      }), h(DxAction, {\n        attrs: { name: 'changeAddedRow', action: this.changeAddedRow }\n      }), h(DxAction, {\n        attrs: { name: 'cancelAddedRows', action: this.cancelAddedRows }\n      }), h(DxAction, {\n        attrs: { name: 'commitAddedRows', action: this.commitAddedRows }\n      }), h(DxGetter, {\n        attrs: { name: 'deletedRowIds', value: deletedRowIds }\n      }), h(DxAction, {\n        attrs: { name: 'deleteRows', action: this.deleteRows }\n      }), h(DxAction, {\n        attrs: { name: 'cancelDeletedRows', action: this.cancelDeletedRows }\n      }), h(DxAction, {\n        attrs: { name: 'commitDeletedRows', action: this.commitDeletedRows }\n      }), h(DxGetter, {\n        attrs: {\n          name: 'isColumnEditingEnabled',\n          value: columnExtensionValueGetter$2(columnExtensions, columnEditingEnabled)\n        }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$d = [{ name: 'DxEditingState' }, { name: 'DxTable' }];\n\nvar DxTableEditColumn = {\n  name: 'DxTableEditColumn',\n  props: {\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    headerCellComponent: {\n      type: Object,\n      required: true\n    },\n    commandComponent: {\n      type: Object,\n      required: true\n    },\n    showAddCommand: {\n      type: Boolean\n    },\n    showEditCommand: {\n      type: Boolean\n    },\n    showDeleteCommand: {\n      type: Boolean\n    },\n    width: {\n      type: Number,\n      default: 140\n    },\n    messages: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Cell = this.cellComponent,\n        HeaderCell = this.headerCellComponent,\n        Command = this.commandComponent,\n        showAddCommand = this.showAddCommand,\n        showEditCommand = this.showEditCommand,\n        showDeleteCommand = this.showDeleteCommand,\n        width = this.width,\n        messages = this.messages;\n\n    var getMessage = getMessagesFormatter(messages);\n    var tableColumnsComputed = function tableColumnsComputed(_ref) {\n      var tableColumns = _ref.tableColumns;\n      return tableColumnsWithEditing(tableColumns, width);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableEditColumn',\n          dependencies: pluginDependencies$d\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: tableColumnsComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var _ref2$attrs = _ref2.attrs,\n                  tableRow = _ref2$attrs.tableRow,\n                  tableColumn = _ref2$attrs.tableColumn;\n              return isHeadingEditCommandsTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs,\n              listeners = _ref3.listeners;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var addRow$$1 = _ref4.actions.addRow;\n            return h(\n              HeaderCell,\n              { attrs: _extends({}, attrs), on: _extends({}, listeners) },\n              [showAddCommand && h(Command, {\n                attrs: {\n                  id: 'add',\n                  text: getMessage('addCommand')\n                },\n                on: {\n                  'execute': function execute() {\n                    return addRow$$1();\n                  }\n                }\n              })]\n            );\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref5) {\n              var _ref5$attrs = _ref5.attrs,\n                  tableRow = _ref5$attrs.tableRow,\n                  tableColumn = _ref5$attrs.tableColumn;\n              return isEditCommandsTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref6) {\n          var attrs = _ref6.attrs,\n              listeners = _ref6.listeners;\n          return h(DxTemplateConnector, [function (_ref7) {\n            var _ref7$actions = _ref7.actions,\n                startEditRows$$1 = _ref7$actions.startEditRows,\n                commitDeletedRows = _ref7$actions.commitDeletedRows,\n                commitAddedRows = _ref7$actions.commitAddedRows,\n                commitChangedRows = _ref7$actions.commitChangedRows,\n                deleteRows$$1 = _ref7$actions.deleteRows,\n                stopEditRows$$1 = _ref7$actions.stopEditRows,\n                cancelAddedRows$$1 = _ref7$actions.cancelAddedRows,\n                cancelChangedRows = _ref7$actions.cancelChangedRows;\n\n            var isEdit = isEditTableRow(attrs.tableRow);\n            var isNew = isAddedTableRow(attrs.tableRow);\n            var isEditing = isEdit || isNew;\n            var rowIds = [attrs.tableRow.rowId];\n            return h(\n              Cell,\n              babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                attrs: {\n                  row: attrs.tableRow.row\n                }\n              }]),\n              [showEditCommand && !isEditing && h(Command, {\n                attrs: {\n                  id: 'edit',\n                  text: getMessage('editCommand')\n                },\n                on: {\n                  'execute': function execute() {\n                    return startEditRows$$1({ rowIds: rowIds });\n                  }\n                }\n              }), showDeleteCommand && !isEditing && h(Command, {\n                attrs: {\n                  id: 'delete',\n                  text: getMessage('deleteCommand')\n                },\n                on: {\n                  'execute': function execute() {\n                    deleteRows$$1({ rowIds: rowIds });\n                    commitDeletedRows({ rowIds: rowIds });\n                  }\n                }\n              }), isEditing && h(Command, {\n                attrs: {\n                  id: 'commit',\n                  text: getMessage('commitCommand')\n                },\n                on: {\n                  'execute': function execute() {\n                    if (isNew) {\n                      commitAddedRows({ rowIds: rowIds });\n                    } else {\n                      stopEditRows$$1({ rowIds: rowIds });\n                      commitChangedRows({ rowIds: rowIds });\n                    }\n                  }\n                }\n              }), isEditing && h(Command, {\n                attrs: {\n                  id: 'cancel',\n                  text: getMessage('cancelCommand')\n                },\n                on: {\n                  'execute': function execute() {\n                    if (isNew) {\n                      cancelAddedRows$$1({ rowIds: rowIds });\n                    } else {\n                      stopEditRows$$1({ rowIds: rowIds });\n                      cancelChangedRows({ rowIds: rowIds });\n                    }\n                  }\n                }\n              })]\n            );\n          }]);\n        }]\n      )]\n    );\n  }\n};\n\nvar pluginDependencies$e = [{ name: 'DxEditingState' }, { name: 'DxTable' }, { name: 'DxDataTypeProvider', optional: true }];\n\nvar DxTableEditRow = {\n  name: 'DxTableEditRow',\n  props: {\n    rowHeight: {\n      type: Number\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    rowComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var EditCell = this.cellComponent,\n        EditRow = this.rowComponent,\n        rowHeight = this.rowHeight;\n\n\n    var tableBodyRowsComputed = function tableBodyRowsComputed(_ref) {\n      var tableBodyRows = _ref.tableBodyRows,\n          editingRowIds = _ref.editingRowIds,\n          addedRows = _ref.addedRows;\n      return tableRowsWithEditing(tableBodyRows, editingRowIds, addedRows, rowHeight);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableEditRow',\n          dependencies: pluginDependencies$e\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableBodyRows', computed: tableBodyRowsComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var _ref2$attrs = _ref2.attrs,\n                  tableRow = _ref2$attrs.tableRow,\n                  tableColumn = _ref2$attrs.tableColumn;\n              return isEditTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs,\n              listeners = _ref3.listeners;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var _ref4$getters = _ref4.getters,\n                getCellValue = _ref4$getters.getCellValue,\n                createRowChange = _ref4$getters.createRowChange,\n                rowChanges = _ref4$getters.rowChanges,\n                isColumnEditingEnabled = _ref4$getters.isColumnEditingEnabled,\n                _ref4$actions = _ref4.actions,\n                changeAddedRow$$1 = _ref4$actions.changeAddedRow,\n                changeRow$$1 = _ref4$actions.changeRow;\n            var _attrs$tableRow = attrs.tableRow,\n                rowId = _attrs$tableRow.rowId,\n                row = _attrs$tableRow.row;\n            var column = attrs.tableColumn.column;\n            var columnName = column.name;\n\n\n            var isNew = isAddedTableRow(attrs.tableRow);\n            var changedRow = isNew ? row : _extends({}, row, getRowChange(rowChanges, rowId));\n\n            var value = getCellValue(changedRow, columnName);\n            var onValueChange = function onValueChange(newValue) {\n              var changeArgs = {\n                rowId: rowId,\n                change: createRowChange(changedRow, newValue, columnName)\n              };\n              if (isNew) {\n                changeAddedRow$$1(changeArgs);\n              } else {\n                changeRow$$1(changeArgs);\n              }\n            };\n            return h(\n              DxTemplatePlaceholder,\n              {\n                attrs: {\n                  name: 'valueEditor',\n                  column: column,\n                  row: row,\n                  value: value\n                },\n                on: {\n                  'valueChange': onValueChange\n                }\n              },\n              [function (content) {\n                return h(\n                  EditCell,\n                  babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                    attrs: {\n                      row: row,\n                      column: column,\n                      value: value,\n                      editingEnabled: isColumnEditingEnabled(columnName)\n                    },\n                    on: {\n                      'valueChange': onValueChange\n                    }\n                  }]),\n                  [content]\n                );\n              }]\n            );\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref5) {\n              var tableRow = _ref5.attrs.tableRow;\n              return isEditTableRow(tableRow) || isAddedTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref6) {\n          var attrs = _ref6.attrs,\n              listeners = _ref6.listeners,\n              slots = _ref6.slots;\n          return h(\n            EditRow,\n            babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n              attrs: {\n                row: attrs.tableRow.row\n              }\n            }]),\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar DxTreeDataState = {\n  name: 'DxTreeDataState',\n  props: {\n    expandedRowIds: {\n      type: Array,\n      required: true\n    }\n  },\n  methods: {\n    toggleRowExpanded: function toggleRowExpanded$$1(payload) {\n      this.$emit('update:expandedRowIds', toggleRowExpanded(this.expandedRowIds, payload));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTreeDataState'\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'expandedRowIds', value: this.expandedRowIds }\n      }), h(DxAction, {\n        attrs: { name: 'toggleRowExpanded', action: this.toggleRowExpanded }\n      })]\n    );\n  }\n};\n\nvar pluginDependencies$f = [{ name: 'DxTreeDataState' }];\n\nvar expandedTreeRowsComputed = function expandedTreeRowsComputed(_ref) {\n  var rows = _ref.rows,\n      getRowId = _ref.getRowId,\n      expandedRowIds = _ref.expandedRowIds;\n  return expandedTreeRows(rows, getRowId, expandedRowIds);\n};\nvar getRowIdComputed$1 = function getRowIdComputed(_ref2) {\n  var getRowId = _ref2.getRowId,\n      rows = _ref2.rows;\n  return customTreeRowIdGetter(getRowId, rows);\n};\nvar getRowLevelKeyComputed = function getRowLevelKeyComputed(_ref3) {\n  var getRowLevelKey = _ref3.getRowLevelKey,\n      rows = _ref3.rows;\n  return customTreeRowLevelKeyGetter(getRowLevelKey, rows);\n};\nvar isTreeRowLeafComputed = function isTreeRowLeafComputed(_ref4) {\n  var rows = _ref4.rows;\n  return isTreeRowLeafGetter(rows);\n};\nvar getTreeRowLevelComputed = function getTreeRowLevelComputed(_ref5) {\n  var rows = _ref5.rows;\n  return getTreeRowLevelGetter(rows);\n};\nvar collapsedTreeRowsGetterComputed = function collapsedTreeRowsGetterComputed(_ref6) {\n  var rows = _ref6.rows,\n      getCollapsedRows = _ref6.getCollapsedRows;\n  return collapsedTreeRowsGetter(getCollapsedRows, rows);\n};\nvar unwrappedTreeRowsComputed = function unwrappedTreeRowsComputed(_ref7) {\n  var rows = _ref7.rows;\n  return unwrappedCustomTreeRows(rows);\n};\n\nvar DxCustomTreeData = {\n  name: 'DxCustomTreeData',\n  props: {\n    getChildRows: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var getChildRows = this.getChildRows;\n\n    var treeRowsComputed = function treeRowsComputed(_ref8) {\n      var rows = _ref8.rows;\n      return customTreeRowsWithMeta(rows, getChildRows);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'CustomTreeData',\n          dependencies: pluginDependencies$f\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'rows', computed: treeRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getRowId', computed: getRowIdComputed$1 }\n      }), h(DxGetter, {\n        attrs: { name: 'getRowLevelKey', computed: getRowLevelKeyComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'isTreeRowLeaf', computed: isTreeRowLeafComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getTreeRowLevel', computed: getTreeRowLevelComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: expandedTreeRowsComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'getCollapsedRows', computed: collapsedTreeRowsGetterComputed }\n      }), h(DxGetter, {\n        attrs: { name: 'rows', computed: unwrappedTreeRowsComputed }\n      })]\n    );\n  }\n};\n\nvar DxTableTreeColumn = {\n  name: 'DxTableTreeColumn',\n  props: {\n    for: {\n      type: String,\n      required: true\n    },\n    showSelectionControls: {\n      type: Boolean,\n      default: false\n    },\n    showSelectAll: {\n      type: Boolean,\n      default: false\n    },\n    cellComponent: {\n      type: Object,\n      required: true\n    },\n    indentComponent: {\n      type: Object,\n      required: true\n    },\n    expandButtonComponent: {\n      type: Object,\n      required: true\n    },\n    checkboxComponent: {\n      type: Object,\n      required: true\n    },\n    contentComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var forColumnName = this.for,\n        showSelectionControls = this.showSelectionControls,\n        showSelectAll = this.showSelectAll,\n        Indent = this.indentComponent,\n        ExpandButton = this.expandButtonComponent,\n        Checkbox = this.checkboxComponent,\n        Content = this.contentComponent,\n        Cell = this.cellComponent;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableTreeColumn',\n          dependencies: [{ name: 'DxDataTypeProvider', optional: true }, { name: 'DxTreeDataState' }, { name: 'DxSelectionState', optional: !showSelectionControls }, { name: 'DxIntegratedSelection', optional: !showSelectAll }, { name: 'DxTable' }, { name: 'DxTableHeaderRow', optional: true }]\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableHeaderCellBefore',\n            predicate: function predicate(_ref) {\n              var column = _ref.attrs.column;\n              return column.name === forColumnName;\n            }\n          }\n        },\n        [h(\n          'div',\n          { style: 'display: flex' },\n          [h(ExpandButton, {\n            attrs: {\n              visible: false\n            }\n          }), showSelectionControls && showSelectAll && h(DxTemplateConnector, [function (_ref2) {\n            var _ref2$getters = _ref2.getters,\n                selectAllAvailable = _ref2$getters.selectAllAvailable,\n                allSelected$$1 = _ref2$getters.allSelected,\n                someSelected$$1 = _ref2$getters.someSelected,\n                toggleSelectAll = _ref2.actions.toggleSelectAll;\n            return h(Checkbox, {\n              attrs: {\n                disabled: !selectAllAvailable,\n                checked: allSelected$$1,\n                indeterminate: someSelected$$1\n              },\n              on: {\n                'change': toggleSelectAll\n              }\n            });\n          }])]\n        )]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref3) {\n              var _ref3$attrs = _ref3.attrs,\n                  tableRow = _ref3$attrs.tableRow,\n                  tableColumn = _ref3$attrs.tableColumn;\n              return isTreeTableCell(tableRow, tableColumn, forColumnName);\n            }\n          }\n        },\n        [function (_ref4) {\n          var attrs = _ref4.attrs,\n              listeners = _ref4.listeners;\n          return h(DxTemplateConnector, [function (_ref5) {\n            var _ref5$getters = _ref5.getters,\n                getCollapsedRows = _ref5$getters.getCollapsedRows,\n                expandedRowIds = _ref5$getters.expandedRowIds,\n                selection = _ref5$getters.selection,\n                isTreeRowLeaf = _ref5$getters.isTreeRowLeaf,\n                getTreeRowLevel = _ref5$getters.getTreeRowLevel,\n                getCellValue = _ref5$getters.getCellValue,\n                _ref5$actions = _ref5.actions,\n                toggleRowExpanded$$1 = _ref5$actions.toggleRowExpanded,\n                toggleSelection$$1 = _ref5$actions.toggleSelection;\n            var _attrs$tableRow = attrs.tableRow,\n                row = _attrs$tableRow.row,\n                rowId = _attrs$tableRow.rowId;\n\n            var columnName = attrs.tableColumn.column.name;\n            var value = getCellValue(row, columnName);\n            var collapsedRows = getCollapsedRows(row);\n            return h(\n              DxTemplatePlaceholder,\n              {\n                attrs: {\n                  name: 'valueFormatter',\n                  row: row,\n                  column: attrs.tableColumn.column,\n                  value: value\n                }\n              },\n              [function (content) {\n                return h(\n                  Cell,\n                  babelHelperVueJsxMergeProps([{ attrs: _extends({}, attrs), on: _extends({}, listeners) }, {\n                    attrs: {\n                      row: row,\n                      column: attrs.tableColumn.column,\n                      value: value\n                    }\n                  }]),\n                  [h(Indent, {\n                    attrs: {\n                      level: getTreeRowLevel(row)\n                    }\n                  }), h(ExpandButton, {\n                    attrs: {\n                      visible: collapsedRows ? !!collapsedRows.length : !isTreeRowLeaf(row),\n                      expanded: expandedRowIds.indexOf(rowId) > -1\n                    },\n                    on: {\n                      'toggle': function toggle() {\n                        return toggleRowExpanded$$1({ rowId: rowId });\n                      }\n                    }\n                  }), showSelectionControls && h(Checkbox, {\n                    attrs: {\n                      disabled: false,\n                      checked: selection.indexOf(rowId) > -1,\n                      indeterminate: false\n                    },\n                    on: {\n                      'change': function change() {\n                        return toggleSelection$$1({ rowIds: [rowId] });\n                      }\n                    }\n                  }), h(Content, [content || value])]\n                );\n              }]\n            );\n          }]);\n        }]\n      )]\n    );\n  }\n};\n\nvar CellPlaceholder$1 = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(DxTemplatePlaceholder);\n  }\n};\n\nvar DxTableBandHeader = {\n  name: 'DxTableBandHeader',\n  props: {\n    columnBands: {\n      type: Array\n    },\n    cellComponent: {\n      type: Object\n    },\n    rowComponent: {\n      type: Object\n    },\n    bandedHeaderCellComponent: {\n      type: Object\n    },\n    invisibleCellComponent: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var Cell = this.cellComponent,\n        Row = this.rowComponent,\n        HeaderCell = this.bandedHeaderCellComponent,\n        InvisibleCell = this.invisibleCellComponent,\n        columnBands = this.columnBands;\n\n\n    var tableHeaderRowsComputed = function tableHeaderRowsComputed(_ref) {\n      var tableHeaderRows = _ref.tableHeaderRows,\n          tableColumns = _ref.tableColumns;\n      return tableRowsWithBands(tableHeaderRows, columnBands, tableColumns);\n    };\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableBandHeader',\n          dependencies: [{ name: 'DxTable' }, { name: 'DxTableHeaderRow' }, { name: 'DxTableSelection', optional: true }, { name: 'DxTableEditColumn', optional: true }]\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'tableHeaderRows', computed: tableHeaderRowsComputed }\n      }), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref2) {\n              var tableRow = _ref2.attrs.tableRow;\n              return isBandedOrHeaderRow(tableRow);\n            }\n          }\n        },\n        [function (_ref3) {\n          var attrs = _ref3.attrs;\n          return h(DxTemplateConnector, [function (_ref4) {\n            var _ref4$getters = _ref4.getters,\n                tableColumns = _ref4$getters.tableColumns,\n                tableHeaderRows = _ref4$getters.tableHeaderRows;\n\n            var bandComponent = getBandComponent(attrs, tableHeaderRows, tableColumns, columnBands);\n\n            switch (bandComponent.type) {\n              case BAND_DUPLICATE_RENDER:\n                return h(DxTemplatePlaceholder, {\n                  attrs: {\n                    colSpan: attrs.colSpan,\n                    tableColumn: attrs.tableColumn,\n                    tableRow: attrs.tableRow,\n                    rowSpan: attrs.rowSpan\n                  }\n                });\n              case BAND_EMPTY_CELL:\n                return h(InvisibleCell);\n              case BAND_GROUP_CELL:\n                {\n                  var _bandComponent$payloa = bandComponent.payload,\n                      value = _bandComponent$payloa.value,\n                      payload = objectWithoutProperties(_bandComponent$payloa, ['value']);\n\n                  return h(\n                    Cell,\n                    { attrs: _extends({}, attrs, payload) },\n                    [value]\n                  );\n                }\n              case BAND_HEADER_CELL:\n                return h(DxTemplatePlaceholder, {\n                  attrs: {\n                    name: 'tableCell',\n                    colSpan: attrs.colSpan,\n                    tableColumn: attrs.tableColumn,\n                    tableRow: bandComponent.payload.tableRow,\n                    rowSpan: bandComponent.payload.rowSpan\n                  }\n                });\n              default:\n                return null;\n            }\n          }]);\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableCell',\n            predicate: function predicate(_ref5) {\n              var _ref5$attrs = _ref5.attrs,\n                  tableRow = _ref5$attrs.tableRow,\n                  tableColumn = _ref5$attrs.tableColumn;\n              return isHeadingTableCell(tableRow, tableColumn);\n            }\n          }\n        },\n        [function (_ref6) {\n          var attrs = _ref6.attrs;\n          return h(HeaderCell, babelHelperVueJsxMergeProps([{\n            attrs: { component: CellPlaceholder$1 }\n          }, { attrs: _extends({}, attrs) }]));\n        }]\n      ), h(\n        DxTemplate,\n        {\n          attrs: {\n            name: 'tableRow',\n            predicate: function predicate(_ref7) {\n              var tableRow = _ref7.attrs.tableRow;\n              return isBandedTableRow(tableRow);\n            }\n          }\n        },\n        [function (_ref8) {\n          var attrs = _ref8.attrs,\n              slots = _ref8.slots;\n          return h(\n            Row,\n            { attrs: _extends({}, attrs) },\n            [slots.default]\n          );\n        }]\n      )]\n    );\n  }\n};\n\nvar pluginDependencies$g = [{ name: 'DxTable' }];\n\nvar visibleTableColumnsComputed = function visibleTableColumnsComputed(_ref) {\n  var tableColumns = _ref.tableColumns,\n      hiddenColumnNames = _ref.hiddenColumnNames;\n  return visibleTableColumns(tableColumns, hiddenColumnNames);\n};\n\nvar columnExtensionValueGetter$3 = function columnExtensionValueGetter(columnExtensions, defaultValue) {\n  return getColumnExtensionValueGetter(columnExtensions, 'togglingEnabled', defaultValue);\n};\n\nvar DxTableColumnVisibility = {\n  name: 'DxTableColumnVisibility',\n  props: {\n    hiddenColumnNames: {\n      type: Array,\n      required: true\n    },\n    emptyMessageComponent: {\n      type: Object,\n      required: true\n    },\n    messages: {\n      type: Object\n    },\n    columnExtensions: {\n      type: Array\n    },\n    columnTogglingEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  methods: {\n    toggleColumnVisibility: function toggleColumnVisibility(columnName) {\n      this.$emit('update:hiddenColumnNames', toggleColumn(this.hiddenColumnNames, columnName));\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var EmptyMessage = this.emptyMessageComponent,\n        messages = this.messages,\n        hiddenColumnNames = this.hiddenColumnNames,\n        columnExtensions = this.columnExtensions,\n        columnTogglingEnabled = this.columnTogglingEnabled;\n\n    var getMessage = getMessagesFormatter(messages);\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxTableColumnVisibility',\n          dependencies: pluginDependencies$g\n        }\n      },\n      [h(DxGetter, {\n        attrs: { name: 'hiddenColumnNames', value: hiddenColumnNames }\n      }), h(DxGetter, {\n        attrs: { name: 'tableColumns', computed: visibleTableColumnsComputed }\n      }), h(DxGetter, {\n        attrs: {\n          name: 'isColumnTogglingEnabled',\n          value: columnExtensionValueGetter$3(columnExtensions, columnTogglingEnabled)\n        }\n      }), h(DxAction, {\n        attrs: {\n          name: 'toggleColumnVisibility',\n          action: this.toggleColumnVisibility\n        }\n      }), h(\n        DxTemplate,\n        {\n          attrs: { name: 'table' }\n        },\n        [function (attrs) {\n          return h(DxTemplateConnector, [function (_ref2) {\n            var tableColumns = _ref2.getters.tableColumns;\n            return tableDataColumnsExist(tableColumns) ? h(DxTemplatePlaceholder) : h(EmptyMessage, babelHelperVueJsxMergeProps([{\n              attrs: {\n                getMessage: getMessage\n              }\n            }, { attrs: attrs }]));\n          }]);\n        }]\n      )]\n    );\n  }\n};\n\nvar pluginDependencies$h = [{ name: 'DxTableColumnVisibility' }, { name: 'DxToolbar' }];\nvar DxColumnChooser = {\n  name: 'DxColumnChooser',\n  props: {\n    overlayComponent: {\n      type: Object,\n      required: true\n    },\n    containerComponent: {\n      type: Object,\n      required: true\n    },\n    itemComponent: {\n      type: Object,\n      required: true\n    },\n    toggleButtonComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  data: function data() {\n    return {\n      visible: false\n    };\n  },\n\n  methods: {\n    setButtonRef: function setButtonRef(button) {\n      this.button = button;\n    },\n    handleToggle: function handleToggle() {\n      this.visible = !this.visible;\n    },\n    handleHide: function handleHide() {\n      this.visible = false;\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var Overlay = this.overlayComponent,\n        Container = this.containerComponent,\n        Item = this.itemComponent,\n        ToggleButton = this.toggleButtonComponent,\n        visible = this.visible;\n\n\n    return h(\n      DxPlugin,\n      {\n        attrs: {\n          name: 'DxColumnChooser',\n          dependencies: pluginDependencies$h\n        }\n      },\n      [h(\n        DxTemplate,\n        {\n          attrs: { name: 'toolbarContent' }\n        },\n        [h(\n          'div',\n          { style: { display: 'flex', flex: 1 } },\n          [h(DxTemplatePlaceholder), h(DxTemplateConnector, [function (_ref) {\n            var _ref$getters = _ref.getters,\n                columns = _ref$getters.columns,\n                hiddenColumnNames = _ref$getters.hiddenColumnNames,\n                isColumnTogglingEnabled = _ref$getters.isColumnTogglingEnabled,\n                toggleColumnVisibility = _ref.actions.toggleColumnVisibility;\n            return h(\n              'div',\n              { style: { display: 'flex', alignItems: 'center', position: 'relative' } },\n              [h(ToggleButton, {\n                attrs: {\n                  buttonRef: _this.setButtonRef,\n\n                  active: visible\n                },\n                on: {\n                  'toggle': _this.handleToggle\n                }\n              }), h(\n                Overlay,\n                {\n                  attrs: {\n                    visible: visible,\n                    target: _this.button\n                  },\n                  on: {\n                    'hide': _this.handleHide\n                  }\n                },\n                [h(Container, [columnChooserItems(columns, hiddenColumnNames).map(function (item) {\n                  var columnName = item.column.name;\n\n                  var togglingEnabled = isColumnTogglingEnabled(columnName);\n                  return h(Item, {\n                    key: columnName,\n                    attrs: { item: item,\n                      disabled: !togglingEnabled\n                    },\n                    on: {\n                      'toggle': function toggle() {\n                        return toggleColumnVisibility(columnName);\n                      }\n                    }\n                  });\n                })])]\n              )]\n            );\n          }])]\n        )]\n      )]\n    );\n  }\n};\n\nexport { DxGrid, DxTable, DxTableHeaderRow, DxIntegratedSorting, DxSortingState, DxToolbar, TableLayout, StaticTableLayout, VirtualTableLayout, DxFilteringState, DxIntegratedFiltering, DxTableFilterRow, DxGroupingState, DxIntegratedGrouping, DxCustomGrouping, DxGroupingPanel, DxTableGroupRow, GroupPanelLayout, DxSearchState, DxSearchPanel, DxSelectionState, DxIntegratedSelection, DxTableSelection, DxPagingState, DxIntegratedPaging, DxCustomPaging, DxPagingPanel, DxDataTypeProvider, DxRowDetailState, DxTableRowDetail, DxEditingState, DxTableEditColumn, DxTableEditRow, DxTreeDataState, DxCustomTreeData, DxTableTreeColumn, DxTableBandHeader, DxTableColumnVisibility, DxColumnChooser };\n//# sourceMappingURL=dx-vue-grid.es.js.map\n","/**\n * Bundle of @devexpress/dx-vue-grid-bootstrap4\n * Generated: 2018-11-07\n * Version: 1.9.0\n * License: https://js.devexpress.com/Licensing\n */\n\nimport { DxGrid, TableLayout, StaticTableLayout, DxTable, DxTableHeaderRow, DxTableFilterRow, DxToolbar, DxGroupingPanel, GroupPanelLayout, DxTableGroupRow, DxSearchPanel, DxTableSelection, DxPagingPanel, DxTableEditColumn, DxTableEditRow, DxTableRowDetail, DxTableTreeColumn, DxTableBandHeader, DxColumnChooser, DxTableColumnVisibility, VirtualTableLayout } from '@devexpress/dx-vue-grid';\nimport { calculateStartPage, firstRowOnPage, lastRowOnPage } from '@devexpress/dx-grid-core';\nimport { createRenderComponent } from '@devexpress/dx-vue-core';\n\nvar nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/;\n\nvar babelHelperVueJsxMergeProps = function mergeJSXProps(objs) {\n  return objs.reduce(function (a, b) {\n    var aa, bb, key, nestedKey, temp;\n    for (key in b) {\n      aa = a[key];\n      bb = b[key];\n      if (aa && nestRE.test(key)) {\n        // normalize class\n        if (key === 'class') {\n          if (typeof aa === 'string') {\n            temp = aa;\n            a[key] = aa = {};\n            aa[temp] = true;\n          }\n          if (typeof bb === 'string') {\n            temp = bb;\n            b[key] = bb = {};\n            bb[temp] = true;\n          }\n        }\n        if (key === 'on' || key === 'nativeOn' || key === 'hook') {\n          // merge functions\n          for (nestedKey in bb) {\n            aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey]);\n          }\n        } else if (Array.isArray(aa)) {\n          a[key] = aa.concat(bb);\n        } else if (Array.isArray(bb)) {\n          a[key] = [aa].concat(bb);\n        } else {\n          for (nestedKey in bb) {\n            aa[nestedKey] = bb[nestedKey];\n          }\n        }\n      } else {\n        a[key] = b[key];\n      }\n    }\n    return a;\n  }, {});\n};\n\nfunction mergeFn(a, b) {\n  return function () {\n    a && a.apply(this, arguments);\n    b && b.apply(this, arguments);\n  };\n}\n\nvar GridRoot = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"div\", [this.$slots.default]);\n  }\n};\n\nvar DxGrid$1 = {\n  name: 'DxGrid',\n  functional: true,\n  render: function render(h, context) {\n    return h(\n      DxGrid,\n      babelHelperVueJsxMergeProps([{\n        attrs: {\n          rootComponent: GridRoot\n        }\n      }, context.data]),\n      [context.children]\n    );\n  },\n\n  components: {\n    DxRoot: GridRoot\n  }\n};\n\nvar MINIMAL_COLUMN_WIDTH = 150;\n\nvar TableLayout$1 = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(TableLayout, babelHelperVueJsxMergeProps([{ attrs: this.$attrs }, {\n      attrs: {\n        layoutComponent: StaticTableLayout,\n        minColumnWidth: MINIMAL_COLUMN_WIDTH\n      }\n    }]));\n  }\n};\n\nvar TableContainer = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      babelHelperVueJsxMergeProps([{\n        \"class\": \"table-responsive\"\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default]\n    );\n  }\n};\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar Table = {\n  name: 'Table',\n  props: {\n    use: {\n      type: String\n    },\n    minWidth: {\n      type: String\n    }\n  },\n  data: function data() {\n    return {\n      backgroundColor: 'white'\n    };\n  },\n  mounted: function mounted() {\n    this.checkStyles();\n  },\n\n  methods: {\n    checkStyles: function checkStyles() {\n      var body = document.getElementsByTagName('body')[0];\n\n      var _window$getComputedSt = window.getComputedStyle(body),\n          backgroundColor = _window$getComputedSt.backgroundColor;\n\n      if (this.backgroundColor !== backgroundColor) {\n        this.backgroundColor = backgroundColor;\n      }\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'table',\n      babelHelperVueJsxMergeProps([{\n        'class': {\n          'table mb-0 dx-g-bs4-overflow-hidden dx-g-bs4-table': true,\n          'dx-g-bs4-table-head': this.use === 'head',\n          'dx-g-bs4-table-sticky': !!this.use\n        },\n        style: _extends({\n          minWidth: this.minWidth\n        }, this.use === 'head' ? {\n          backgroundColor: this.backgroundColor\n        } : null)\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default]\n    );\n  }\n};\n\nvar TableHead = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"thead\",\n      { attrs: this.$attrs, on: this.$listeners },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar TableBody = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"tbody\",\n      { attrs: this.$attrs, on: this.$listeners },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar TableRow = {\n  name: 'TableRow',\n  props: {\n    row: null,\n    tableRow: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'tr',\n      { attrs: this.$attrs, on: this.$listeners },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar TableCell = {\n  name: 'TableCell',\n  props: {\n    row: null,\n    tableRow: {\n      type: Object\n    },\n    column: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    },\n    value: null\n  },\n  render: function render() {\n    var h = arguments[0];\n    var tableColumn = this.tableColumn;\n\n    var align = tableColumn && tableColumn.align || 'left';\n\n    return h(\n      'td',\n      babelHelperVueJsxMergeProps([{\n        'class': defineProperty({\n          'dx-g-bs4-table-cell': true,\n          'text-nowrap': !(tableColumn && tableColumn.wordWrapEnabled)\n        }, 'text-' + align, align !== 'left')\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default || this.value]\n    );\n  }\n};\n\nvar TableNoDataCell = {\n  props: {\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"td\",\n      babelHelperVueJsxMergeProps([{\n        \"class\": \"py-5 text-center\"\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [h(\n        \"big\",\n        {\n          attrs: { className: \"text-muted\" }\n        },\n        [this.getMessage('noData')]\n      )]\n    );\n  }\n};\n\nvar TableStubRow = {\n  name: 'TableStubRow',\n  props: {\n    tableRow: {\n      type: Object\n    },\n    height: {\n      type: String\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'tr',\n      {\n        style: {\n          height: this.height\n        }\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar TableHeaderStubCell = {\n  props: {\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"th\", {\n      \"class\": \"py-0\"\n    });\n  }\n};\n\nvar TableStubCell = {\n  name: 'TableStubCell',\n  props: {\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"td\", { \"class\": \"py-0\" });\n  }\n};\n\nvar defaultMessages = {\n  noData: 'No data'\n};\n\nvar DxTable$1 = {\n  name: 'DxTable',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxTable, babelHelperVueJsxMergeProps([{\n      attrs: {\n        layoutComponent: TableLayout$1,\n        containerComponent: TableContainer,\n        tableComponent: Table,\n        headComponent: TableHead,\n        bodyComponent: TableBody,\n        rowComponent: TableRow,\n        cellComponent: TableCell,\n        noDataCellComponent: TableNoDataCell,\n        noDataRowComponent: TableRow,\n        stubRowComponent: TableStubRow,\n        stubCellComponent: TableStubCell,\n        stubHeaderCellComponent: TableHeaderStubCell,\n        messages: _extends({}, defaultMessages, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxContainer: TableContainer,\n    DxTable: Table,\n    DxTableHead: TableHead,\n    DxTableBody: TableBody,\n    DxRow: TableRow,\n    DxCell: TableCell,\n    DxNoDataCell: TableNoDataCell,\n    DxNoDataRow: TableRow,\n    DxStubCell: TableStubCell,\n    DxStubHeaderCell: TableHeaderStubCell,\n    DxStubRow: TableStubRow\n  }\n};\n\nvar SortingIndicator = {\n  props: {\n    direction: {\n      type: String,\n      default: null\n    },\n    disabled: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var direction = this.direction;\n\n    var classes = {\n      'oi dx-g-bs4-sorting-indicator mx-2': true,\n      'oi-arrow-thick-bottom': direction === 'desc',\n      'oi-arrow-thick-top': direction !== 'desc',\n      invisible: !direction\n    };\n    return h('span', {\n      'class': classes\n    });\n  }\n};\n\nvar ENTER_KEY_CODE = 13;\nvar SPACE_KEY_CODE = 32;\n\nvar SortingControl = {\n  props: {\n    align: {\n      type: String,\n      required: true\n    },\n    direction: {\n      type: String,\n      default: null\n    },\n    disabled: {\n      type: Boolean\n    }\n  },\n  methods: {\n    handleMouseDown: function handleMouseDown(e) {\n      e.currentTarget.style.outline = 'none';\n    },\n    handleBlur: function handleBlur(e) {\n      e.currentTarget.style.outline = '';\n    },\n    handleClick: function handleClick(e) {\n      this.emitChange(e);\n    },\n    handleKeyDown: function handleKeyDown(e) {\n      var isActionKeyDown = e.keyCode === ENTER_KEY_CODE || e.keyCode === SPACE_KEY_CODE;\n      if (!isActionKeyDown) return;\n\n      this.emitChange(e);\n    },\n    emitChange: function emitChange(e) {\n      if (this.disabled) return;\n\n      var cancelSortingRelatedKey = e.metaKey || e.ctrlKey;\n      var direction = cancelSortingRelatedKey ? null : undefined;\n\n      e.preventDefault();\n      this.$emit('change', {\n        direction: direction,\n        keepOther: e.shiftKey || cancelSortingRelatedKey\n      });\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'span',\n      {\n        'class': {\n          'd-inline-flex flex-direction-row align-items-center mw-100': true,\n          'dx-g-bs4-cursor-pointer': !this.disabled,\n          'flex-row-reverse': this.align === 'right',\n          'text-primary': this.direction\n        },\n        on: {\n          'click': this.handleClick,\n          'keydown': this.handleKeyDown,\n          'blur': this.handleBlur,\n          'mousedown': this.handleMouseDown\n        },\n        attrs: {\n          tabIndex: this.disabled ? -1 : 0\n        }\n      },\n      [h(\n        'span',\n        {\n          'class': 'dx-g-bs4-sorting-control-text'\n        },\n        [this.$slots.default]\n      ), this.direction && h(SortingIndicator, {\n        attrs: {\n          direction: this.direction\n        }\n      })]\n    );\n  }\n};\n\nvar GroupingControl = {\n  props: {\n    align: {\n      type: String,\n      required: true\n    },\n    disabled: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var align = this.align,\n        disabled = this.disabled;\n\n    var invertedAlign = align === 'left';\n\n    return h(\n      'div',\n      {\n        'class': {\n          'dx-g-bs4-grouping-control': true,\n          'float-right text-right': invertedAlign,\n          'float-left text-left': !invertedAlign\n        },\n        on: {\n          'click': function click(e) {\n            if (disabled) return;\n            e.stopPropagation();\n            _this.$emit('group');\n          }\n        }\n      },\n      [h('span', {\n        'class': {\n          'oi oi-list dx-g-bs4-grouping-control-icon': true,\n          'dx-g-bs4-cursor-pointer': !disabled,\n          'dx-g-bs4-inactive': disabled\n        }\n      })]\n    );\n  }\n};\n\nvar TableHeaderCell = {\n  props: {\n    tableRow: {\n      type: Object\n    },\n    column: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    },\n    sortingDirection: {\n      type: String\n    },\n    showSortingControls: {\n      type: Boolean,\n      default: false\n    },\n    showGroupingControls: {\n      type: Boolean,\n      default: false\n    },\n    sortingEnabled: {\n      type: Boolean,\n      default: false\n    },\n    groupingEnabled: {\n      type: Boolean,\n      default: false\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var tableColumn = this.tableColumn,\n        column = this.column,\n        showSortingControls = this.showSortingControls,\n        showGroupingControls = this.showGroupingControls,\n        sortingEnabled = this.sortingEnabled,\n        groupingEnabled = this.groupingEnabled,\n        sortingDirection = this.sortingDirection;\n\n    var isCellInteractive = showSortingControls && sortingEnabled;\n    var align = tableColumn && tableColumn.align || 'left';\n    var columnTitle = column && (column.title || column.name);\n    return h(\n      'th',\n      {\n        'class': {\n          'position-relative dx-g-bs4-header-cell': true,\n          'dx-g-bs4-user-select-none': isCellInteractive\n        },\n        attrs: { scope: 'col'\n        }\n      },\n      [h(\n        'div',\n        {\n          'class': 'd-flex flex-direction-row align-items-center'\n        },\n        [this.$slots.before, h(\n          'div',\n          {\n            'class': defineProperty({\n              'dx-g-bs4-table-header-cell-wrapper': true,\n              'text-nowrap': !(tableColumn && tableColumn.wordWrapEnabled)\n            }, 'text-' + align, align !== 'left')\n          },\n          [showSortingControls ? h(\n            SortingControl,\n            {\n              attrs: {\n                align: align,\n                disabled: !sortingEnabled,\n                direction: sortingDirection\n              },\n              on: {\n                'change': this.$emit.bind(this, 'sort')\n              }\n            },\n            [columnTitle]\n          ) : columnTitle]\n        ), showGroupingControls && h('div', [h(GroupingControl, {\n          attrs: {\n            align: align,\n            disabled: !groupingEnabled\n          },\n          on: {\n            'group': this.$emit.bind(this, 'group')\n          }\n        })])]\n      )]\n    );\n  }\n};\n\nvar DxTableHeaderRow$1 = {\n  name: 'DxTableHeaderRow',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableHeaderRow, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: TableHeaderCell,\n        rowComponent: TableRow\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: TableHeaderCell,\n    DxRow: TableRow\n  }\n};\n\nvar TableFilterCell = {\n  name: 'TableFilterCell',\n  props: {\n    column: {\n      type: Object\n    },\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    },\n    getMessage: {\n      type: Function\n    },\n    filter: {\n      type: Object,\n      default: null\n    },\n    filteringEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"th\",\n      { attrs: _extends({}, this.$attrs), on: _extends({}, this.$listeners) },\n      [h(\n        \"div\",\n        { \"class\": \"input-group\" },\n        [this.$slots.default]\n      )]\n    );\n  }\n};\n\nvar Editor = {\n  name: 'Editor',\n  inheritAttrs: false,\n  props: {\n    value: {\n      type: [Number, String],\n      default: ''\n    },\n    disabled: {\n      type: Boolean,\n      default: false\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  methods: {\n    handleChange: function handleChange(e) {\n      this.$emit('changeValue', e.target.value);\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var value = this.value,\n        disabled = this.disabled,\n        getMessage = this.getMessage;\n\n\n    return h('input', babelHelperVueJsxMergeProps([{ attrs: _extends({}, this.$attrs), on: _extends({}, this.$listeners) }, {\n      attrs: {\n        type: 'text',\n\n        readOnly: disabled,\n        placeholder: getMessage('filterPlaceholder')\n      },\n      'class': 'form-control',\n      domProps: {\n        'value': value\n      },\n      on: {\n        'input': this.handleChange\n      }\n    }]));\n  }\n};\n\nvar offsetX = 5;\nvar offsetY = 5;\nvar Popover = {\n  name: 'Popover',\n  props: {\n    target: null,\n    container: null,\n    width: {\n      type: Number,\n      default: 0\n    },\n    visible: {\n      type: Boolean\n    }\n  },\n  methods: {\n    handleDocumentClick: function handleDocumentClick(e) {\n      if (e.target !== this.$el && !this.$el.contains(e.target)) {\n        this.$emit('toggle', e);\n      }\n    },\n    setElementTranslate: function setElementTranslate() {\n      var _target$getBoundingCl = this.target.getBoundingClientRect(),\n          targetHeight = _target$getBoundingCl.height,\n          targetWidth = _target$getBoundingCl.width,\n          targetLeft = _target$getBoundingCl.left;\n\n      var _container = this.container,\n          container = _container === undefined ? document.body : _container,\n          width = this.width;\n\n      var popoverWidth = width || this.$el.offsetWidth;\n      var x = (targetWidth - popoverWidth) / 2;\n      var popoverRight = targetLeft + (targetWidth + popoverWidth) / 2;\n      if (popoverRight > container.offsetWidth) {\n        x -= popoverRight - container.offsetWidth + offsetX;\n      }\n      if (targetLeft - Math.abs(x) < 0) {\n        x = offsetX - targetLeft;\n      }\n      this.$el.style.transform = 'translate(' + x + 'px, ' + (targetHeight + offsetY) + 'px)';\n    }\n  },\n  created: function created() {\n    document.addEventListener('click', this.handleDocumentClick);\n  },\n  destroyed: function destroyed() {\n    document.removeEventListener('click', this.handleDocumentClick);\n  },\n  mounted: function mounted() {\n    this.setElementTranslate();\n  },\n  updated: function updated() {\n    this.setElementTranslate();\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'div',\n      {\n        'class': {\n          popover: true,\n          'd-none': !this.visible\n        }\n      },\n      [h(\n        'div',\n        { 'class': 'popover-inner' },\n        [this.$slots.default]\n      )]\n    );\n  }\n};\n\nvar FilterSelector = {\n  name: 'FilterSelector',\n  props: {\n    value: {\n      type: String\n    },\n    availableValues: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    disabled: {\n      type: Boolean,\n      default: false\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    },\n    iconComponent: {\n      type: Object,\n      required: true\n    }\n  },\n  data: function data() {\n    return {\n      opened: false\n    };\n  },\n\n  methods: {\n    handleButtonClick: function handleButtonClick(e) {\n      e.stopPropagation();\n      this.opened = !this.opened;\n    },\n    handleOverlayToggle: function handleOverlayToggle() {\n      if (this.opened) this.opened = false;\n    },\n    handleMenuItemClick: function handleMenuItemClick(nextValue) {\n      this.opened = false;\n      this.$emit('changeValue', nextValue);\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var value = this.value,\n        availableValues = this.availableValues,\n        disabled = this.disabled,\n        getMessage = this.getMessage,\n        Icon = this.iconComponent,\n        opened = this.opened;\n\n    return availableValues.length ? h(\n      'div',\n      { 'class': 'input-group-prepend' },\n      [h(\n        'button',\n        {\n          'class': 'btn btn-outline-secondary',\n          attrs: { disabled: disabled || availableValues.length === 1\n          },\n          on: {\n            'click': this.handleButtonClick\n          },\n\n          ref: 'buttonRef'\n        },\n        [h(Icon, {\n          attrs: { type: value }\n        })]\n      ), this.$refs.buttonRef ? h(\n        Popover,\n        {\n          attrs: {\n            visible: opened,\n            target: this.$refs.buttonRef\n          },\n          on: {\n            'toggle': this.handleOverlayToggle\n          }\n        },\n        [h(\n          'div',\n          { 'class': 'py-2' },\n          [availableValues.map(function (valueItem) {\n            return h(\n              'button',\n              {\n                key: valueItem,\n                'class': {\n                  'dropdown-item d-flex align-items-center': true,\n                  'dx-g-bs4-cursor-pointer dx-g-bs4-filter-selector-item': true,\n                  active: valueItem === value\n                },\n                on: {\n                  'click': function click() {\n                    return _this.handleMenuItemClick(valueItem);\n                  }\n                }\n              },\n              [h(Icon, {\n                attrs: { type: valueItem }\n              }), h(\n                'span',\n                { 'class': 'dx-g-bs4-filter-selector-item-text' },\n                [getMessage(valueItem)]\n              )]\n            );\n          })]\n        )]\n      ) : null]\n    ) : null;\n  }\n};\n\nvar AVAILABLE_PATHS = {\n  contains: 'M6.094 19.563l-2.031 0.281c-0.646 0.094-1.13 0.266-1.453 0.516-0.302 0.24-0.453 0.646-0.453 1.219 0 0.438 0.138 0.799 0.414 1.086s0.664 0.419 1.164 0.398c0.708 0 1.281-0.24 1.719-0.719 0.427-0.49 0.641-1.125 0.641-1.906v-0.875zM8.234 24.641h-2.172v-1.641c-0.677 1.24-1.661 1.859-2.953 1.859-0.927 0-1.682-0.276-2.266-0.828-0.552-0.552-0.828-1.292-0.828-2.219 0-1.927 1.068-3.052 3.203-3.375l2.875-0.438c0-1.469-0.656-2.203-1.969-2.203-1.177 0-2.224 0.427-3.141 1.281v-2.078c1.010-0.656 2.198-0.984 3.563-0.984 2.458 0 3.687 1.302 3.687 3.906v6.719zM14.734 16.797c0.521-0.583 1.167-0.875 1.938-0.875 0.74 0 1.323 0.281 1.75 0.844 0.448 0.583 0.672 1.38 0.672 2.391 0 1.188-0.24 2.13-0.719 2.828-0.49 0.677-1.13 1.016-1.922 1.016-0.719 0-1.302-0.271-1.75-0.813-0.427-0.51-0.641-1.141-0.641-1.891v-1.266c-0.021-0.906 0.203-1.651 0.672-2.234zM16.969 24.859c1.375 0 2.443-0.521 3.203-1.562 0.781-1.042 1.172-2.427 1.172-4.156 0-1.542-0.354-2.771-1.063-3.688-0.688-0.958-1.651-1.438-2.891-1.438-1.427 0-2.531 0.693-3.313 2.078v-6.781h-2.156v15.328h2.172v-1.5c0.677 1.146 1.635 1.719 2.875 1.719zM22.266 6.125c0.135 0 0.245 0.063 0.328 0.188 0.104 0.073 0.156 0.182 0.156 0.328v22.953c0 0.125-0.052 0.24-0.156 0.344-0.083 0.115-0.193 0.172-0.328 0.172h-12.281c-0.146 0-0.266-0.057-0.359-0.172-0.115-0.115-0.172-0.229-0.172-0.344v-22.953c0-0.135 0.057-0.245 0.172-0.328 0.094-0.125 0.214-0.188 0.359-0.188h12.281zM31.531 24.141c-0.76 0.479-1.693 0.719-2.797 0.719-1.427 0-2.589-0.479-3.484-1.438-0.865-0.958-1.286-2.198-1.266-3.719 0-1.688 0.448-3.052 1.344-4.094 0.917-1.042 2.208-1.573 3.875-1.594 0.854 0 1.63 0.177 2.328 0.531v2.156c-0.677-0.531-1.391-0.792-2.141-0.781-0.938 0-1.714 0.339-2.328 1.016-0.594 0.677-0.891 1.552-0.891 2.625 0 1.042 0.297 1.88 0.891 2.516 0.521 0.615 1.25 0.922 2.188 0.922 0.813 0 1.573-0.297 2.281-0.891v2.031z',\n  notContains: 'M5.828 20.469v0.328c0 0.385-0.057 0.667-0.172 0.844-0.052 0.083-0.117 0.177-0.195 0.281s-0.174 0.224-0.289 0.359c-0.458 0.521-1.031 0.771-1.719 0.75-0.521 0-0.927-0.141-1.219-0.422-0.292-0.292-0.438-0.661-0.438-1.109 0-0.156 0.010-0.273 0.031-0.352s0.052-0.141 0.094-0.188 0.094-0.086 0.156-0.117 0.141-0.078 0.234-0.141c0.031-0.031 0.078-0.070 0.141-0.117s0.146-0.086 0.25-0.117h3.125zM14.016 18.328c0.010-0.406 0.070-0.729 0.18-0.969s0.289-0.49 0.539-0.75c0.479-0.604 1.13-0.906 1.953-0.906 0.75 0 1.344 0.292 1.781 0.875 0.198 0.25 0.349 0.495 0.453 0.734s0.172 0.578 0.203 1.016h-5.109zM19.078 20.469c-0.063 0.427-0.146 0.708-0.25 0.844-0.052 0.073-0.109 0.159-0.172 0.258l-0.219 0.352c-0.469 0.688-1.135 1.031-2 1.031-0.708 0-1.297-0.271-1.766-0.813l-0.305-0.359c-0.089-0.104-0.159-0.198-0.211-0.281-0.104-0.167-0.156-0.448-0.156-0.844v-0.188h5.078zM33.344 18.328l-6.875 0c0.031-0.198 0.070-0.372 0.117-0.523s0.107-0.284 0.18-0.398 0.154-0.224 0.242-0.328l0.305-0.344c0.604-0.688 1.391-1.031 2.359-1.031 0.771 0 1.51 0.266 2.219 0.797v-2.234c-0.75-0.333-1.552-0.5-2.406-0.5-1.667 0-2.974 0.531-3.922 1.594-0.396 0.427-0.708 0.859-0.938 1.297s-0.385 0.995-0.469 1.672h-2.719c-0.021-0.719-0.117-1.31-0.289-1.773s-0.424-0.914-0.758-1.352c-0.729-0.938-1.719-1.417-2.969-1.438-1.479 0-2.615 0.708-3.406 2.125v-6.953h-2.266v9.391h-3.75v-0.594c0-2.646-1.25-3.969-3.75-3.969-1.365 0-2.583 0.328-3.656 0.984v2.125c0.99-0.865 2.063-1.297 3.219-1.297 1.344 0 2.016 0.75 2.016 2.25l-2.953 0.125c-0.25 0.021-0.487 0.070-0.711 0.148l-0.633 0.227h-3.328v2.141h1.828l-0.281 0.594c-0.073 0.135-0.109 0.37-0.109 0.703 0 0.938 0.276 1.682 0.828 2.234 0.542 0.573 1.313 0.859 2.313 0.859 1.281 0 2.297-0.635 3.047-1.906v1.656h2.172v-4.141h3.75v4.141h2.297v-1.516c0.677 1.188 1.661 1.776 2.953 1.766 1.385 0 2.464-0.531 3.234-1.594 0.302-0.385 0.557-0.792 0.766-1.219 0.198-0.385 0.339-0.911 0.422-1.578h2.703c0.021 0.708 0.141 1.25 0.359 1.625 0.115 0.198 0.253 0.401 0.414 0.609s0.346 0.427 0.555 0.656c0.906 1 2.099 1.5 3.578 1.5 1.104 0 2.057-0.245 2.859-0.734v-2.109c-0.75 0.604-1.526 0.917-2.328 0.938-0.979 0-1.74-0.318-2.281-0.953l-0.328-0.328c-0.094-0.094-0.177-0.195-0.25-0.305s-0.13-0.234-0.172-0.375-0.073-0.315-0.094-0.523h6.906v-2.141zM33.297 5.688c0.146 0 0.266 0.047 0.359 0.141 0.104 0.104 0.156 0.229 0.156 0.375v23.484c0 0.135-0.052 0.255-0.156 0.359-0.094 0.115-0.214 0.172-0.359 0.172h-35.078c-0.135 0-0.26-0.057-0.375-0.172-0.094-0.115-0.135-0.234-0.125-0.359v-23.484c0-0.104 0.042-0.229 0.125-0.375 0.104-0.094 0.229-0.141 0.375-0.141h35.078z',\n  startsWith: 'M6.109 20.688c0 0.813-0.219 1.474-0.656 1.984-0.448 0.531-1.010 0.786-1.688 0.766-0.51 0-0.896-0.141-1.156-0.422-0.302-0.292-0.443-0.667-0.422-1.125 0-0.615 0.151-1.042 0.453-1.281 0.177-0.135 0.378-0.245 0.602-0.328s0.497-0.146 0.82-0.188l2.047-0.313v0.906zM8.203 18.063c0-2.688-1.219-4.031-3.656-4.031-1.333 0-2.51 0.339-3.531 1.016v2.141c0.917-0.885 1.948-1.328 3.094-1.328 1.333 0 2 0.766 2 2.297l-2.891 0.453c-2.115 0.333-3.161 1.516-3.141 3.547 0 0.958 0.266 1.724 0.797 2.297 0.542 0.573 1.292 0.859 2.25 0.859 1.292 0 2.26-0.641 2.906-1.922v1.688h2.172v-7.016zM14.703 16.906c0.479-0.604 1.109-0.906 1.891-0.906 0.76 0 1.344 0.297 1.75 0.891 0.438 0.615 0.656 1.443 0.656 2.484 0 1.219-0.229 2.198-0.688 2.938-0.469 0.719-1.109 1.078-1.922 1.078-0.719 0-1.286-0.281-1.703-0.844-0.448-0.542-0.672-1.208-0.672-2v-1.313c-0.010-0.938 0.219-1.714 0.688-2.328zM16.906 25.313c1.365 0 2.422-0.542 3.172-1.625 0.771-1.115 1.156-2.563 1.156-4.344 0-1.604-0.339-2.885-1.016-3.844-0.698-0.979-1.661-1.469-2.891-1.469-1.438 0-2.531 0.719-3.281 2.156v-7.078h-2.188v15.969h2.172v-1.563c0.667 1.198 1.625 1.797 2.875 1.797zM31.375 24.563c-0.75 0.5-1.672 0.75-2.766 0.75-1.427 0-2.583-0.505-3.469-1.516-0.885-0.969-1.318-2.26-1.297-3.875 0-1.74 0.464-3.161 1.391-4.266 0.927-1.063 2.198-1.604 3.813-1.625 0.844 0 1.62 0.172 2.328 0.516v2.25c-0.688-0.563-1.406-0.828-2.156-0.797-0.927 0-1.688 0.349-2.281 1.047-0.583 0.698-0.875 1.609-0.875 2.734 0 1.094 0.281 1.969 0.844 2.625 0.542 0.656 1.286 0.984 2.234 0.984 0.781 0 1.526-0.323 2.234-0.969v2.141zM22.172 5.844c0.115 0 0.224 0.052 0.328 0.156 0.094 0.125 0.141 0.25 0.141 0.375v23.844c0 0.156-0.047 0.286-0.141 0.391-0.115 0.094-0.224 0.141-0.328 0.141h-23.469c-0.125 0-0.24-0.047-0.344-0.141-0.094-0.104-0.141-0.234-0.141-0.391v-23.844c0-0.125 0.047-0.25 0.141-0.375 0.104-0.104 0.219-0.156 0.344-0.156h23.469z',\n  endsWith: 'M6.234 19.344l-2.047 0.313c-0.625 0.083-1.104 0.26-1.438 0.531-0.302 0.24-0.453 0.651-0.453 1.234 0 0.469 0.141 0.852 0.422 1.148s0.672 0.435 1.172 0.414c0.677 0 1.234-0.25 1.672-0.75 0.448-0.51 0.672-1.167 0.672-1.969v-0.922zM8.359 24.578h-2.141v-1.656c-0.667 1.26-1.656 1.891-2.969 1.891-0.938 0-1.698-0.276-2.281-0.828-0.542-0.573-0.813-1.328-0.813-2.266 0-2.021 1.063-3.188 3.188-3.5l2.891-0.484c0-1.51-0.661-2.266-1.984-2.266-1.167 0-2.214 0.443-3.141 1.328v-2.125c1.042-0.677 2.224-1.016 3.547-1.016 2.469 0 3.703 1.333 3.703 4v6.922zM14.906 16.516c0.49-0.615 1.13-0.922 1.922-0.922 0.76 0 1.339 0.297 1.734 0.891 0.438 0.615 0.656 1.438 0.656 2.469 0 1.208-0.229 2.182-0.688 2.922-0.469 0.698-1.115 1.047-1.938 1.047-0.708 0-1.276-0.276-1.703-0.828-0.458-0.552-0.688-1.214-0.688-1.984v-1.281c-0.010-0.948 0.224-1.719 0.703-2.313zM17.125 24.813c1.354 0 2.417-0.531 3.188-1.594 0.781-1.073 1.172-2.505 1.172-4.297 0-1.604-0.349-2.87-1.047-3.797-0.698-0.979-1.661-1.469-2.891-1.469-1.438 0-2.542 0.714-3.313 2.141v-7h-2.203v15.781h2.188v-1.531c0.677 1.177 1.646 1.766 2.906 1.766zM31.688 21.969c-0.698 0.635-1.453 0.953-2.266 0.953-0.958 0-1.703-0.323-2.234-0.969-0.563-0.667-0.849-1.536-0.859-2.609 0-1.115 0.297-2.016 0.891-2.703 0.594-0.698 1.359-1.047 2.297-1.047 0.76 0 1.484 0.266 2.172 0.797v-2.219c-0.708-0.344-1.49-0.516-2.344-0.516-1.625 0-2.906 0.536-3.844 1.609-0.938 1.083-1.406 2.495-1.406 4.234 0 1.594 0.438 2.875 1.313 3.844 0.885 0.979 2.052 1.469 3.5 1.469 1.083 0 2.010-0.245 2.781-0.734v-2.109zM33.188 5.563c0.104 0 0.219 0.047 0.344 0.141 0.094 0.146 0.141 0.276 0.141 0.391v23.578c0 0.146-0.047 0.281-0.141 0.406-0.125 0.094-0.24 0.141-0.344 0.141h-23.625c-0.125 0-0.24-0.047-0.344-0.141-0.094-0.135-0.135-0.271-0.125-0.406v-23.578c0-0.115 0.042-0.245 0.125-0.391 0.094-0.094 0.208-0.141 0.344-0.141h23.625z',\n  equal: 'M29.438 11.797v2.75h-26.922v-2.75h26.922zM29.438 17.406v2.75h-26.922v-2.75h26.922z',\n  notEqual: 'M16.906 11.797l3.016-6.547 2.094 1-2.547 5.547h9.969v2.75h-11.234l-1.328 2.859h12.563v2.75h-13.828l-2.875 6.281-2.094-0.984 2.438-5.297h-10.563v-2.75h11.828l1.297-2.859h-13.125v-2.75h14.391z',\n  greaterThan: 'M24.125 16.047l-14.906 8.625-1.375-2.375 10.781-6.25-10.781-6.234 1.375-2.375z',\n  greaterThanOrEqual: 'M23.031 14.328l-14.906 8.625-1.375-2.375 10.797-6.25-10.797-6.234 1.375-2.375zM23.828 15.641l1.375 2.391-14.938 8.609-1.375-2.375z',\n  lessThan: 'M22.75 7.438l1.375 2.375-10.781 6.234 10.781 6.25-1.375 2.375-14.906-8.609z',\n  lessThanOrEqual: 'M23.828 5.719l1.375 2.375-10.813 6.234 10.813 6.25-1.375 2.375-14.922-8.609zM23.047 24.266l-1.375 2.375-14.922-8.609 1.375-2.391z'\n};\n\nvar Icon = {\n  name: 'Icon',\n  props: {\n    type: {\n      type: String\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    var path = AVAILABLE_PATHS[this.type];\n    return path ? h(\n      'svg',\n      babelHelperVueJsxMergeProps([{\n        'class': 'd-block dx-g-bs4-filter-selector-icon',\n        attrs: { viewBox: '0 0 32 32'\n        }\n      }, { attrs: _extends({}, this.$attrs), on: _extends({}, this.$listeners) }]),\n      [h('path', {\n        attrs: { d: path }\n      })]\n    ) : h('span', babelHelperVueJsxMergeProps([{\n      'class': 'd-block oi oi-magnifying-glass dx-g-bs4-filter-selector-icon'\n    }, { attrs: _extends({}, this.$attrs), on: _extends({}, this.$listeners) }]));\n  }\n};\n\nvar defaultMessages$1 = {\n  filterPlaceholder: 'Filter...',\n  contains: 'Contains',\n  notContains: 'Does not contain',\n  startsWith: 'Starts with',\n  endsWith: 'Ends with',\n  equal: 'Equals',\n  notEqual: 'Does not equal',\n  greaterThan: 'Greater than',\n  greaterThanOrEqual: 'Greater than or equal to',\n  lessThan: 'Less than',\n  lessThanOrEqual: 'Less than or equal to'\n};\n\nvar DxTableFilterRow$1 = {\n  name: 'DxTableFilterRow',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxTableFilterRow, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: TableFilterCell,\n        rowComponent: TableRow,\n        filterSelectorComponent: FilterSelector,\n        iconComponent: Icon,\n        editorComponent: Editor,\n        messages: _extends({}, defaultMessages$1, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: TableFilterCell,\n    DxRow: TableRow,\n    DxEditor: Editor,\n    DxFilterSelector: FilterSelector,\n    DxIcon: Icon\n  }\n};\n\nvar DxToolbar$1 = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      {\n        \"class\": \"card-header py-2 d-flex position-relative dx-g-bs4-toolbar\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar FlexibleSpace = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"div\", { \"class\": \"d-flex ml-auto\" });\n  }\n};\n\nvar DxToolbar$2 = {\n  name: 'DxToolbar',\n  render: function render() {\n    var h = arguments[0];\n\n    return h(DxToolbar, babelHelperVueJsxMergeProps([{\n      attrs: {\n        rootComponent: DxToolbar$1,\n        flexibleSpaceComponent: FlexibleSpace\n      }\n    }, this.props]));\n  },\n\n  components: {\n    DxRoot: DxToolbar$1\n  }\n};\n\nvar GroupPanelContainer = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      {\n        \"class\": \"w-100 mt-1\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar ENTER_KEY_CODE$1 = 13;\nvar SPACE_KEY_CODE$1 = 32;\n\nvar isActionKey = function isActionKey(keyCode) {\n  return keyCode === ENTER_KEY_CODE$1 || keyCode === SPACE_KEY_CODE$1;\n};\n\nvar GroupPanelItem = {\n  props: {\n    item: {\n      type: Object,\n      required: true\n    },\n    showSortingControls: {\n      type: Boolean\n    },\n    sortingDirection: {\n      type: String\n    },\n    showGroupingControls: {\n      type: Boolean\n    },\n    groupingEnabled: {\n      type: Boolean\n    },\n    sortingEnabled: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var showSortingControls = this.showSortingControls,\n        showGroupingControls = this.showGroupingControls,\n        sortingEnabled = this.sortingEnabled,\n        groupingEnabled = this.groupingEnabled,\n        column = this.item.column,\n        sortingDirection = this.sortingDirection;\n\n    var handleSortingChange = function handleSortingChange(e) {\n      var isActionKeyDown = isActionKey(e.keyCode);\n      var isMouseClick = e.keyCode === undefined;\n      if (!showSortingControls || !sortingEnabled || !(isActionKeyDown || isMouseClick)) return;\n\n      var cancelSortingRelatedKey = e.metaKey || e.ctrlKey;\n      var direction = (isMouseClick || isActionKeyDown) && cancelSortingRelatedKey ? null : undefined;\n\n      e.preventDefault();\n      _this.$emit('sort', {\n        direction: direction,\n        keepOther: cancelSortingRelatedKey\n      });\n    };\n    var handleUngroup = function handleUngroup(e) {\n      if (!groupingEnabled) return;\n      var isActionKeyDown = isActionKey(e.keyCode);\n      var isMouseClick = e.keyCode === undefined;\n\n      if (!isActionKeyDown && !isMouseClick) return;\n      _this.$emit('group');\n    };\n    return h(\n      'div',\n      {\n        'class': {\n          'btn-group mb-1 mr-1': true\n        }\n      },\n      [h(\n        'span',\n        babelHelperVueJsxMergeProps([{\n          'class': {\n            'btn btn-outline-secondary': true,\n            disabled: !sortingEnabled && (showSortingControls || !groupingEnabled)\n          },\n          on: {\n            'click': handleSortingChange,\n            'keydown': handleSortingChange\n          }\n        }, sortingEnabled ? { tabIndex: 0 } : null]),\n        [column.title || column.name, showSortingControls && sortingDirection && h('span', ['\\xA0', h(SortingIndicator, {\n          attrs: {\n            direction: sortingDirection\n          }\n        })])]\n      ), showGroupingControls && h(\n        'span',\n        {\n          'class': {\n            'btn btn-outline-secondary': true,\n            disabled: !groupingEnabled\n          },\n          on: {\n            'click': handleUngroup\n          }\n        },\n        ['\\xA0', h('span', {\n          'class': 'oi oi-x dx-g-bs4-group-panel-item-icon'\n        })]\n      )]\n    );\n  }\n};\n\nvar GroupPanelEmptyMessage = {\n  props: {\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      {\n        \"class\": \"dx-g-bs4-group-panel-empty-message\"\n      },\n      [this.getMessage('groupByColumn') || h(\"span\", [\"Click the \", h(\"span\", { \"class\": \"oi oi-list dx-g-bs4-grouping-control-icon\" }), \" icon in the column header to group by that column\"])]\n    );\n  }\n};\n\nvar defaultMessages$2 = {\n  groupByColumn: ''\n};\n\nvar DxGroupingPanel$1 = {\n  name: 'DxGroupingPanel',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxGroupingPanel, babelHelperVueJsxMergeProps([{\n      attrs: {\n        layoutComponent: GroupPanelLayout,\n        containerComponent: GroupPanelContainer,\n        itemComponent: GroupPanelItem,\n        emptyMessageComponent: GroupPanelEmptyMessage,\n        messages: _extends({}, defaultMessages$2, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxContainer: GroupPanelContainer,\n    DxItem: GroupPanelItem,\n    DxEmptyMessage: GroupPanelEmptyMessage\n  }\n};\n\nvar ENTER_KEY_CODE$2 = 13;\nvar SPACE_KEY_CODE$2 = 32;\n\nvar handleMouseDown = function handleMouseDown(e) {\n  e.target.style.outline = 'none';\n};\nvar handleBlur = function handleBlur(e) {\n  e.target.style.outline = '';\n};\n\nvar ExpandButton = {\n  props: {\n    visible: {\n      type: Boolean,\n      default: true\n    },\n    expanded: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var expanded = this.expanded,\n        visible = this.visible;\n\n    var fireToggle = function fireToggle() {\n      if (!visible) return;\n      _this.$emit('toggle', !expanded);\n    };\n    var handleClick = function handleClick(e) {\n      e.stopPropagation();\n      fireToggle();\n    };\n    var handleKeyDown = function handleKeyDown(e) {\n      if (e.keyCode === ENTER_KEY_CODE$2 || e.keyCode === SPACE_KEY_CODE$2) {\n        e.preventDefault();\n        fireToggle();\n      }\n    };\n    return h('i', {\n      'class': {\n        'oi p-2 text-center dx-g-bs4-toggle-button': true,\n        'oi-chevron-bottom': expanded,\n        'oi-chevron-right': !expanded,\n        'dx-g-bs4-toggle-button-hidden': !visible\n      }\n      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex\n      , attrs: { tabIndex: visible ? 0 : undefined\n      },\n      on: {\n        'keydown': handleKeyDown,\n        'mousedown': handleMouseDown,\n        'blur': handleBlur,\n        'click': handleClick\n      }\n    });\n  }\n};\n\nvar TableGroupCell = {\n  props: {\n    colSpan: {\n      type: Number\n    },\n    row: null,\n    column: {\n      type: Object\n    },\n    expanded: {\n      type: Boolean\n    },\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var colSpan = this.colSpan,\n        expanded = this.expanded,\n        column = this.column,\n        row = this.row;\n\n    var handleClick = function handleClick() {\n      return _this.$emit('toggle');\n    };\n    return h(\n      'td',\n      {\n        attrs: {\n          colSpan: colSpan\n        },\n        'class': 'dx-g-bs4-cursor-pointer',\n        on: {\n          'click': handleClick\n        }\n      },\n      [h(ExpandButton, {\n        attrs: {\n          expanded: expanded\n        },\n        on: {\n          'toggle': handleClick\n        },\n\n        'class': 'mr-2'\n      }), h('strong', [column.title || column.name, ': ']), this.$slots.default || row.value]\n    );\n  }\n};\n\nvar DxTableGroupRow$1 = {\n  name: 'DxTableGroupRow',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableGroupRow, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: TableGroupCell,\n        rowComponent: TableRow,\n        indentColumnWidth: 33\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxRow: TableRow,\n    DxCell: TableGroupCell\n  }\n};\n\nvar SearchPanelInput = {\n  name: 'SearchPanelInput',\n  props: {\n    value: {\n      type: [Number, String],\n      default: null\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var value = this.value,\n        getMessage = this.getMessage;\n    var onValueChange = this.$listeners.valueChange;\n\n    return h(\"input\", {\n      attrs: {\n        type: \"text\",\n\n        placeholder: getMessage('searchPlaceholder')\n      },\n      \"class\": \"form-control w-25\",\n      on: {\n        \"input\": function input(e) {\n          return onValueChange(e.target.value);\n        }\n      },\n      domProps: {\n        \"value\": value\n      }\n    });\n  }\n};\n\nvar defaultMessages$3 = {\n  searchPlaceholder: 'Search...'\n};\n\nvar DxSearchPanel$1 = {\n  name: 'DxSearchPanel',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxSearchPanel, babelHelperVueJsxMergeProps([{\n      attrs: {\n        inputComponent: SearchPanelInput,\n        messages: _extends({}, defaultMessages$3, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxInput: SearchPanelInput\n  }\n};\n\nvar SelectionControl = {\n  props: {\n    disabled: {\n      type: Boolean\n    },\n    checked: {\n      type: Boolean\n    },\n    indeterminate: {\n      type: Boolean\n    }\n  },\n  updated: function updated() {\n    this.applyIndeterminate();\n  },\n  mounted: function mounted() {\n    this.applyIndeterminate();\n  },\n\n  methods: {\n    applyIndeterminate: function applyIndeterminate() {\n      this.$refs['selection-control-ref'].indeterminate = this.indeterminate;\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var disabled = this.disabled,\n        checked = this.checked;\n    var onChange = this.$listeners.change;\n\n    return h('input', {\n      'class': {\n        'd-inline-block': true,\n        'dx-g-bs4-cursor-pointer': !disabled\n      },\n      attrs: { type: 'checkbox',\n        disabled: disabled\n      },\n      domProps: {\n        'checked': checked\n      },\n\n      ref: 'selection-control-ref',\n      on: {\n        'change': function change() {\n          if (disabled) return;\n          onChange();\n        },\n        'click': function click(e) {\n          return e.stopPropagation();\n        }\n      }\n    });\n  }\n};\n\nvar TableSelectAllCell = {\n  props: {\n    allSelected: {\n      type: Boolean,\n      default: false\n    },\n    someSelected: {\n      type: Boolean,\n      default: false\n    },\n    disabled: {\n      type: Boolean,\n      default: false\n    },\n    rowSpan: {\n      type: Number\n    },\n    tableColumn: {\n      type: Object\n    },\n    tableRow: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var rowSpan = this.rowSpan,\n        disabled = this.disabled,\n        allSelected = this.allSelected,\n        someSelected = this.someSelected;\n    var onToggle = this.$listeners.toggle;\n\n    return h(\n      'th',\n      {\n        'class': {\n          'text-center': true,\n          'align-middle': !rowSpan,\n          'align-bottom': !!rowSpan\n        },\n        attrs: { rowSpan: rowSpan\n        }\n      },\n      [h(SelectionControl, {\n        attrs: {\n          disabled: disabled,\n          checked: allSelected,\n          indeterminate: someSelected\n        },\n        on: {\n          'change': onToggle\n        }\n      })]\n    );\n  }\n};\n\nvar TableSelectCell = {\n  props: {\n    selected: {\n      type: Boolean,\n      default: false\n    },\n    row: null,\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var onToggle = this.$listeners.toggle;\n    var selected = this.selected;\n\n    return h(\n      \"td\",\n      {\n        \"class\": \"text-center align-middle\"\n      },\n      [h(SelectionControl, {\n        attrs: {\n          checked: selected\n        },\n        on: {\n          \"change\": onToggle\n        }\n      })]\n    );\n  }\n};\n\nvar TableSelectRow = {\n  props: {\n    selected: {\n      type: Boolean\n    },\n    selectByRowClick: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var selected = this.selected,\n        selectByRowClick = this.selectByRowClick;\n    var onToggle = this.$listeners.toggle;\n\n    return h(\n      'tr',\n      {\n        'class': selected ? 'table-active' : '',\n        on: {\n          'click': function click(e) {\n            if (!selectByRowClick) return;\n            e.stopPropagation();\n            onToggle();\n          }\n        }\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar DxTableSelection$1 = {\n  name: 'DxTableSelection',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableSelection, babelHelperVueJsxMergeProps([{\n      attrs: {\n        rowComponent: TableSelectRow,\n        cellComponent: TableSelectCell,\n        headerCellComponent: TableSelectAllCell,\n        selectionColumnWidth: 40\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: TableSelectCell,\n    DxHeaderCell: TableSelectAllCell\n  }\n};\n\nvar PageSizeSelector = {\n  props: {\n    pageSize: {\n      type: Number,\n      required: true\n    },\n    pageSizes: {\n      type: Array,\n      required: true\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var pageSize = this.pageSize,\n        pageSizes = this.pageSizes,\n        getMessage = this.getMessage;\n    var pageSizeChange = this.$listeners.pageSizeChange;\n\n    var showAll = getMessage('showAll');\n\n    return h(\n      \"div\",\n      { \"class\": \"d-inline-block\" },\n      [h(\n        \"select\",\n        {\n          \"class\": \"form-control d-sm-none\",\n          domProps: {\n            \"value\": pageSize\n          },\n          on: {\n            \"change\": function change(e) {\n              pageSizeChange(parseInt(e.target.value, 10));\n            }\n          }\n        },\n        [pageSizes.map(function (val) {\n          return h(\n            \"option\",\n            { key: val, domProps: {\n                \"value\": val\n              }\n            },\n            [val || showAll]\n          );\n        })]\n      ), h(\n        \"ul\",\n        { \"class\": \"pagination d-none d-sm-flex m-0\" },\n        [pageSizes.map(function (item) {\n          return h(\n            \"li\",\n            {\n              \"class\": {\n                'page-item': true,\n                active: item === pageSize\n              }\n            },\n            [h(\n              \"a\",\n              {\n                \"class\": \"page-link\",\n                attrs: { href: \"#\"\n                },\n                on: {\n                  \"click\": function click(e) {\n                    e.preventDefault();\n                    pageSizeChange(item);\n                  }\n                }\n              },\n              [item || showAll]\n            )]\n          );\n        })]\n      )]\n    );\n  }\n};\n\nvar PageButtons = {\n  name: 'PageButtons',\n  functional: true,\n  props: {\n    currentPage: {\n      type: Number,\n      required: true\n    },\n    totalPageCount: {\n      type: Number,\n      required: true\n    },\n    currentPageChange: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render(h, context) {\n    var _context$props = context.props,\n        totalPageCount = _context$props.totalPageCount,\n        currentPage = _context$props.currentPage,\n        currentPageChange = _context$props.currentPageChange;\n\n\n    var pageButtons = [];\n    var maxButtonCount = 3;\n    var startPage = 1;\n    var endPage = totalPageCount || 1;\n\n    if (maxButtonCount < totalPageCount) {\n      startPage = calculateStartPage(currentPage + 1, maxButtonCount, totalPageCount);\n      endPage = startPage + maxButtonCount - 1;\n    }\n    if (startPage > 1) {\n      pageButtons.push(h(\n        'li',\n        { 'class': 'page-item', key: 1 },\n        [h(\n          'a',\n          {\n            'class': 'page-link',\n            attrs: { href: '#'\n            },\n            on: {\n              'click': function click(e) {\n                return currentPageChange(e, 0);\n              }\n            }\n          },\n          [1]\n        )]\n      ));\n\n      if (startPage > 2) {\n        pageButtons.push(h(\n          'li',\n          { 'class': 'page-item disabled', key: 'ellipsisStart', attrs: { disabled: true }\n          },\n          [h(\n            'a',\n            { 'class': 'page-link' },\n            ['...']\n          )]\n        ));\n      }\n    }\n\n    var _loop = function _loop(page) {\n      pageButtons.push(h(\n        'li',\n        {\n          key: page,\n          'class': {\n            'page-item': true,\n            active: page === currentPage + 1,\n            disabled: startPage === endPage\n          }\n        },\n        [h(\n          'a',\n          {\n            'class': 'page-link',\n            attrs: { href: '#'\n            },\n            on: {\n              'click': function click(e) {\n                return currentPageChange(e, page - 1);\n              }\n            }\n          },\n          [page]\n        )]\n      ));\n    };\n\n    for (var page = startPage; page <= endPage; page += 1) {\n      _loop(page);\n    }\n\n    if (endPage < totalPageCount) {\n      if (endPage < totalPageCount - 1) {\n        pageButtons.push(h(\n          'li',\n          { 'class': 'page-item disabled', key: 'ellipsisEnd', attrs: { disabled: true }\n          },\n          [h(\n            'a',\n            { 'class': 'page-link' },\n            ['...']\n          )]\n        ));\n      }\n\n      pageButtons.push(h(\n        'li',\n        { 'class': 'page-item', key: totalPageCount },\n        [h(\n          'a',\n          {\n            'class': 'page-link',\n            attrs: { href: '#'\n            },\n            on: {\n              'click': function click(e) {\n                return currentPageChange(e, totalPageCount - 1);\n              }\n            }\n          },\n          [totalPageCount]\n        )]\n      ));\n    }\n\n    return pageButtons;\n  }\n};\n\nvar Pagination = {\n  props: {\n    totalPages: {\n      type: Number,\n      required: true\n    },\n    currentPage: {\n      type: Number,\n      required: true\n    },\n    totalCount: {\n      type: Number,\n      required: true\n    },\n    pageSize: {\n      type: Number,\n      required: true\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var totalPages = this.totalPages,\n        currentPage = this.currentPage,\n        totalCount = this.totalCount,\n        pageSize = this.pageSize,\n        getMessage = this.getMessage;\n    var onCurrentPageChange = this.$listeners.currentPageChange;\n\n\n    var from = firstRowOnPage(currentPage, pageSize, totalCount);\n    var to = lastRowOnPage(currentPage, pageSize, totalCount);\n    var currentPageChange = function currentPageChange(e, nextPage) {\n      e.preventDefault();\n      onCurrentPageChange(nextPage);\n    };\n\n    return h(\n      'div',\n      { 'class': 'd-inline-block float-right' },\n      [h(\n        'ul',\n        { 'class': 'pagination float-right d-none d-sm-flex m-0' },\n        [h(\n          'li',\n          { 'class': {\n              'page-item': true,\n              disabled: currentPage === 0\n            } },\n          [h(\n            'a',\n            {\n              'class': 'page-link',\n              attrs: { 'aria-label': 'Previous',\n                href: '#'\n              },\n              on: {\n                'click': function click(e) {\n                  return currentPageChange(e, currentPage - 1);\n                }\n              }\n            },\n            [h(\n              'span',\n              {\n                attrs: { 'aria-hidden': 'true' }\n              },\n              ['\\xAB']\n            )]\n          )]\n        ), h(PageButtons, {\n          attrs: {\n            currentPage: currentPage,\n            totalPageCount: totalPages,\n            currentPageChange: currentPageChange\n          }\n        }), h(\n          'li',\n          { 'class': {\n              'page-item': true,\n              disabled: currentPage === totalPages - 1 || totalCount === 0\n            } },\n          [h(\n            'a',\n            {\n              'class': 'page-link',\n              attrs: { 'aria-label': 'Next',\n                href: '#'\n              },\n              on: {\n                'click': function click(e) {\n                  return currentPageChange(e, currentPage + 1);\n                }\n              }\n            },\n            [h(\n              'span',\n              {\n                attrs: { 'aria-hidden': 'true' }\n              },\n              ['\\xBB']\n            )]\n          )]\n        )]\n      ), h(\n        'ul',\n        { 'class': 'pagination float-right d-sm-none m-0' },\n        [h(\n          'li',\n          { 'class': {\n              'page-item': true,\n              disabled: currentPage === 0\n            }\n          },\n          [h(\n            'a',\n            {\n              'class': 'page-link',\n              attrs: { 'aria-label': 'Previous',\n                href: '#'\n              },\n              on: {\n                'click': function click(e) {\n                  return currentPageChange(e, currentPage - 1);\n                }\n              }\n            },\n            [h(\n              'span',\n              {\n                attrs: { 'aria-hidden': 'true' }\n              },\n              ['\\xAB']\n            )]\n          )]\n        ), '\\xA0', h(\n          'li',\n          { 'class': {\n              'page-item': true,\n              disabled: currentPage === totalPages - 1 || totalCount === 0\n            }\n          },\n          [h(\n            'a',\n            {\n              'class': 'page-link',\n              attrs: { 'aria-label': 'Next',\n                href: '#'\n              },\n              on: {\n                'click': function click(e) {\n                  return currentPageChange(e, currentPage + 1);\n                }\n              }\n            },\n            [h(\n              'span',\n              {\n                attrs: { 'aria-hidden': 'true' }\n              },\n              ['\\xBB']\n            )]\n          )]\n        )]\n      ), h(\n        'span',\n        { 'class': 'float-right d-sm-none mr-4' },\n        [h(\n          'span',\n          { 'class': 'd-inline-block align-middle' },\n          [getMessage('info', { from: from, to: to, count: totalCount })]\n        )]\n      )]\n    );\n  }\n};\n\nvar Pager = {\n  props: {\n    currentPage: {\n      type: Number,\n      required: true\n    },\n    totalPages: {\n      type: Number,\n      required: true\n    },\n    pageSize: {\n      type: Number,\n      required: true\n    },\n    pageSizes: {\n      type: Array,\n      required: true\n    },\n    totalCount: {\n      type: Number,\n      required: true\n    },\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var currentPage = this.currentPage,\n        totalPages = this.totalPages,\n        pageSize = this.pageSize,\n        pageSizes = this.pageSizes,\n        totalCount = this.totalCount,\n        getMessage = this.getMessage;\n    var _$listeners = this.$listeners,\n        pageSizeChange = _$listeners.pageSizeChange,\n        _currentPageChange = _$listeners.currentPageChange;\n\n\n    return h(\n      'div',\n      babelHelperVueJsxMergeProps([{\n        'class': 'clearfix card-footer'\n      }, this.$attrs]),\n      [!!pageSizes.length && h(PageSizeSelector, {\n        attrs: {\n          pageSize: pageSize,\n\n          pageSizes: pageSizes,\n          getMessage: getMessage\n        },\n        on: {\n          'pageSizeChange': pageSizeChange\n        }\n      }), h(Pagination, {\n        attrs: {\n          totalPages: totalPages,\n          totalCount: totalCount,\n          currentPage: currentPage,\n\n          pageSize: pageSize,\n          getMessage: getMessage\n        },\n        on: {\n          'currentPageChange': function currentPageChange(page) {\n            return _currentPageChange(page);\n          }\n        }\n      })]\n    );\n  }\n};\n\nvar defaultMessages$4 = {\n  showAll: 'All',\n  info: function info(_ref) {\n    var from = _ref.from,\n        to = _ref.to,\n        count = _ref.count;\n    return '' + from + (from < to ? '-' + to : '') + ' of ' + count;\n  }\n};\n\nvar DxPagingPanel$1 = {\n  name: 'DxPagingPanel',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxPagingPanel, babelHelperVueJsxMergeProps([{\n      attrs: {\n        containerComponent: Pager,\n        messages: _extends({}, defaultMessages$4, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxContainer: Pager\n  }\n};\n\nvar CommandButton = {\n  props: {\n    text: {\n      type: String,\n      required: true\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n\n    return h(\n      \"button\",\n      {\n        \"class\": \"btn btn-link dx-g-bs4-table-edit-command-cell\",\n        on: {\n          \"click\": function click() {\n            _this.$emit('execute');\n          }\n        }\n      },\n      [this.text]\n    );\n  }\n};\n\nvar EditCommandHeadingCell = {\n  props: {\n    tableColumn: {\n      type: Object\n    },\n    tableRow: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"th\",\n      {\n        \"class\": \"text-center p-0 text-nowrap\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar EditCommandCell = {\n  props: {\n    row: null,\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"td\",\n      {\n        \"class\": \"text-center p-0 text-nowrap\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar defaultMessages$5 = {\n  addCommand: 'New',\n  editCommand: 'Edit',\n  deleteCommand: 'Delete',\n  commitCommand: 'Save',\n  cancelCommand: 'Cancel'\n};\n\nvar DxTableEditColumn$1 = {\n  name: 'DxTableEditColumn',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxTableEditColumn, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: EditCommandCell,\n        headerCellComponent: EditCommandHeadingCell,\n        commandComponent: CommandButton,\n        messages: _extends({}, defaultMessages$5, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCommand: CommandButton,\n    DxCell: EditCommandCell,\n    DxHeaderCell: EditCommandHeadingCell\n  }\n};\n\nvar EditCell = {\n  props: {\n    tableRow: {\n      type: Object\n    },\n    column: {\n      type: Object\n    },\n    row: null,\n    tableColumn: {\n      type: Object\n    },\n    value: null,\n    editingEnabled: {\n      type: Boolean,\n      default: true\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var value = this.value,\n        editingEnabled = this.editingEnabled,\n        tableColumn = this.tableColumn;\n\n    return h(\n      \"td\",\n      { \"class\": \"align-middle dx-g-bs4-table-edit-cell\" },\n      [this.$slots.default || h(\"input\", {\n        attrs: {\n          type: \"text\",\n\n          readOnly: !editingEnabled\n        },\n        \"class\": {\n          'form-control w-100': true,\n          'text-right': tableColumn && tableColumn.align === 'right',\n          'text-center': tableColumn && tableColumn.align === 'center'\n        }, domProps: {\n          \"value\": value\n        },\n        on: {\n          \"change\": function change(e) {\n            return _this.$emit('valueChange', e.target.value);\n          }\n        }\n      })]\n    );\n  }\n};\n\nvar DxTableEditRow$1 = {\n  name: 'DxTableEditRow',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableEditRow, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: EditCell,\n        rowComponent: TableRow\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: EditCell,\n    DxRow: TableRow\n  }\n};\n\nvar TableDetailToggleCell = {\n  props: {\n    expanded: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n\n    var toggle = function toggle() {\n      return _this.$emit('toggle');\n    };\n    return h(\n      'td',\n      {\n        'class': 'text-center align-middle'\n      },\n      [h(ExpandButton, {\n        attrs: {\n          expanded: this.expanded\n        },\n        on: {\n          'toggle': toggle\n        }\n      })]\n    );\n  }\n};\n\nvar TableDetailCell = {\n  props: {\n    colSpan: {\n      type: Number\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"td\",\n      {\n        attrs: {\n          colSpan: this.colSpan\n        },\n        \"class\": \"table-active\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar DxTableRowDetail$1 = {\n  name: 'DxTableRowDetail',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableRowDetail, babelHelperVueJsxMergeProps([{\n      attrs: {\n        toggleCellComponent: TableDetailToggleCell,\n        cellComponent: TableDetailCell,\n        rowComponent: TableRow,\n        toggleColumnWidth: 48\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: TableDetailCell,\n    DxToggleCell: TableDetailToggleCell,\n    DxRow: TableRow\n  }\n};\n\nvar TableTreeExpandButton = {\n  props: {\n    visible: {},\n    expanded: {}\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n\n    return h(ExpandButton, babelHelperVueJsxMergeProps([{\n      attrs: {\n        visible: this.visible,\n        expanded: this.expanded\n      },\n      on: {\n        'toggle': function toggle() {\n          return _this.$emit('toggle');\n        }\n      },\n\n      'class': 'mr-3'\n    }, { attrs: this.$attrs, on: this.$listeners }]));\n  }\n};\n\nvar TableTreeCheckbox = {\n  props: {\n    checked: {},\n    indeterminate: {},\n    disabled: {}\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n\n    return h(SelectionControl, babelHelperVueJsxMergeProps([{\n      attrs: {\n        disabled: this.disabled,\n        checked: this.checked,\n        indeterminate: this.indeterminate\n      },\n      on: {\n        'change': function change() {\n          return _this.$emit('change');\n        }\n      },\n\n      'class': 'mr-4'\n    }, { attrs: this.$attrs, on: this.$listeners }]));\n  }\n};\n\nvar TableTreeIndent = {\n  functional: true,\n  props: {\n    level: {\n      type: Number,\n      default: 0\n    }\n  },\n  render: function render(h, context) {\n    return Array.from({ length: context.props.level }).map(function (value, currentLevel) {\n      return h(\"span\", {\n        key: currentLevel,\n        \"class\": \"d-inline-block mr-4\"\n      });\n    });\n  }\n};\n\nvar TableTreeCell = {\n  props: {\n    column: {},\n    tableRow: {},\n    tableColumn: {},\n    row: {}\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"td\",\n      { attrs: this.$attrs, on: this.$listeners },\n      [h(\n        \"div\",\n        {\n          \"class\": \"d-flex flex-direction-row align-items-center\"\n        },\n        [this.$slots.default]\n      )]\n    );\n  }\n};\n\nvar TableTreeContent = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      babelHelperVueJsxMergeProps([{\n        \"class\": \"text-nowrap w-100 dx-g-bs4-table-tree-content\"\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default]\n    );\n  }\n};\n\nvar DxTableTreeColumn$1 = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(DxTableTreeColumn, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: TableTreeCell,\n        contentComponent: TableTreeContent,\n        indentComponent: TableTreeIndent,\n        expandButtonComponent: TableTreeExpandButton,\n        checkboxComponent: TableTreeCheckbox\n      }\n    }, { attrs: this.$attrs, on: this.$listeners }]));\n  }\n};\n\nvar Cell = {\n  props: {\n    column: {\n      type: Object\n    },\n    row: null,\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"th\",\n      babelHelperVueJsxMergeProps([{\n        \"class\": \"dx-g-bs4-banded-cell dx-g-bs4-table-cell text-nowrap border-left border-right border-bottom\"\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default]\n    );\n  }\n};\n\nvar BandedHeaderCell = {\n  props: {\n    component: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var HeaderCellComponent = this.component;\n\n    return h(HeaderCellComponent, babelHelperVueJsxMergeProps([{\n      \"class\": \"dx-g-bs4-banded-header-cell border-left border-right\"\n    }, { attrs: this.$attrs, on: this.$listeners }]));\n  }\n};\n\nvar InvisibleCell = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"th\", { \"class\": \"d-none\" });\n  }\n};\n\nvar DxTableBandHeader$1 = {\n  name: 'DxTableBandHeader',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxTableBandHeader, babelHelperVueJsxMergeProps([{\n      attrs: {\n        cellComponent: Cell,\n        rowComponent: TableRow,\n        bandedHeaderCellComponent: BandedHeaderCell,\n        invisibleCellComponent: InvisibleCell\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxCell: Cell,\n    DxRow: TableRow,\n    DxBandedHeaderCell: BandedHeaderCell\n  }\n};\n\nvar Overlay = {\n  name: 'Overlay',\n  props: {\n    visible: {\n      type: Boolean\n    },\n    target: null\n  },\n  render: function render() {\n    var _this = this;\n\n    var h = arguments[0];\n    var visible = this.visible,\n        target = this.target;\n\n    var handleToggle = function handleToggle() {\n      if (visible) _this.$emit('hide');\n    };\n    return target ? h(\n      Popover,\n      {\n        attrs: {\n          visible: visible,\n          target: target\n        },\n        on: {\n          'toggle': handleToggle\n        }\n      },\n      [this.$slots.default]\n    ) : null;\n  }\n};\n\nvar Container = {\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      {\n        \"class\": \"py-2\"\n      },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar handleMouseDown$1 = function handleMouseDown(e) {\n  e.currentTarget.style.outline = 'none';\n};\nvar handleBlur$1 = function handleBlur(e) {\n  e.currentTarget.style.outline = '';\n};\n\nvar Item = {\n  name: 'Item',\n  props: {\n    item: {\n      type: Object,\n      required: true\n    },\n    disabled: {\n      type: Boolean\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n    var disabled = this.disabled,\n        _item = this.item,\n        column = _item.column,\n        hidden = _item.hidden;\n    var onToggle = this.$listeners.toggle;\n\n    return h(\n      'button',\n      {\n        'class': {\n          'dropdown-item dx-g-bs4-column-chooser-item': true,\n          'dx-g-bs4-cursor-pointer': !disabled\n        },\n        attrs: { type: 'button',\n\n          disabled: disabled\n        },\n        on: {\n          'click': onToggle,\n          'mouseDown': handleMouseDown$1,\n          'blur': handleBlur$1\n        }\n      },\n      [h('input', {\n        attrs: {\n          type: 'checkbox',\n\n          tabIndex: -1,\n\n          disabled: disabled\n        },\n        'class': {\n          'dx-g-bs4-cursor-pointer': !disabled,\n          'dx-g-bs4-column-chooser-checkbox': true\n        }, domProps: {\n          'checked': !hidden\n        },\n        on: {\n          'change': onToggle,\n          'click': function click(e) {\n            return e.stopPropagation();\n          }\n        }\n      }), column.title || column.name]\n    );\n  }\n};\n\nvar ToggleButton = {\n  name: 'ToggleButton',\n  props: {\n    buttonRef: {\n      type: Function,\n      required: true\n    },\n    active: {\n      type: Boolean\n    }\n  },\n  mounted: function mounted() {\n    this.buttonRef(this.$el);\n  },\n  render: function render() {\n    var h = arguments[0];\n    var onToggle = this.$listeners.toggle;\n\n    return h(\n      'button',\n      {\n        'class': {\n          'btn btn-outline-secondary border-0': true,\n          active: this.active\n        },\n        on: {\n          'click': onToggle\n        }\n      },\n      [h('span', { 'class': 'oi oi-eye' })]\n    );\n  }\n};\n\nvar DxColumnChooser$1 = {\n  name: 'DxColumnChooser',\n  functional: true,\n  render: function render(h, context) {\n    return h(DxColumnChooser, babelHelperVueJsxMergeProps([{\n      attrs: {\n        overlayComponent: Overlay,\n        containerComponent: Container,\n        itemComponent: Item,\n        toggleButtonComponent: ToggleButton\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxContainer: Container,\n    DxItem: Item,\n    DxOverlay: Overlay,\n    DxToggleButton: ToggleButton\n  }\n};\n\nvar EmptyMessage = {\n  name: 'EmptyMessage',\n  props: {\n    getMessage: {\n      type: Function,\n      required: true\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      \"div\",\n      {\n        \"class\": \"py-5 text-center\"\n      },\n      [h(\n        \"big\",\n        { \"class\": \"text-muted\" },\n        [this.getMessage('noColumns')]\n      )]\n    );\n  }\n};\n\nvar defaultMessages$6 = {\n  noColumns: 'Nothing to show'\n};\n\nvar DxTableColumnVisibility$1 = {\n  name: 'DxTableColumnVisibility',\n  functional: true,\n  props: {\n    messages: {\n      type: Object\n    }\n  },\n  render: function render(h, context) {\n    return h(DxTableColumnVisibility, babelHelperVueJsxMergeProps([{\n      attrs: {\n        emptyMessageComponent: EmptyMessage,\n        messages: _extends({}, defaultMessages$6, context.props.messages)\n      }\n    }, context.data]));\n  },\n\n  components: {\n    DxEmptyMessage: EmptyMessage\n  }\n};\n\nvar MINIMAL_COLUMN_WIDTH$1 = 150;\n\nvar VirtualTableLayout$1 = {\n  name: 'VirtualTableLayout',\n  inheritAttrs: false,\n  render: function render() {\n    var h = arguments[0];\n\n    return h(TableLayout, babelHelperVueJsxMergeProps([{\n      attrs: {\n        layoutComponent: VirtualTableLayout,\n        minColumnWidth: MINIMAL_COLUMN_WIDTH$1\n      }\n    }, { attrs: _extends({}, this.$attrs), on: _extends({}, this.$listeners) }]));\n  }\n};\n\nvar TableStubHeaderCell = {\n  name: 'TableStubHeaderCell',\n  props: {\n    tableRow: {\n      type: Object\n    },\n    tableColumn: {\n      type: Object\n    }\n  },\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\"th\", babelHelperVueJsxMergeProps([{ attrs: this.$attrs, on: this.$listeners }, {\n      \"class\": \"p-0\"\n    }]));\n  }\n};\n\nvar FixedHeader = {\n  name: 'FixedHeader',\n  render: function render() {\n    var h = arguments[0];\n    return h(\n      Table,\n      babelHelperVueJsxMergeProps([{\n        attrs: { use: 'head' }\n      }, { attrs: this.$attrs, on: this.$listeners }]),\n      [this.$slots.default]\n    );\n  }\n};\nvar TableHead$1 = {\n  name: 'TableHead',\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'thead',\n      { attrs: this.$attrs, on: this.$listeners },\n      [this.$slots.default]\n    );\n  }\n};\nvar TableBody$1 = {\n  name: 'TableBody',\n  render: function render() {\n    var h = arguments[0];\n\n    return h(\n      'tbody',\n      { attrs: this.$attrs, on: this.$listeners },\n      [this.$slots.default]\n    );\n  }\n};\n\nvar defaultMessages$7 = {\n  noData: 'No data'\n};\n\nvar DxVirtualTable = {\n  name: 'DxVirtualTable',\n  props: {\n    estimatedRowHeight: {\n      type: Number,\n      default: 49\n    },\n    height: {\n      type: Number,\n      default: 530\n    },\n    headTableComponent: {\n      type: Object,\n      default: function _default() {\n        return FixedHeader;\n      }\n    },\n    messages: {\n      type: Object,\n      default: function _default() {\n        return {};\n      }\n    }\n  },\n  created: function created() {\n    var height = this.height,\n        estimatedRowHeight = this.estimatedRowHeight,\n        headTableComponent = this.headTableComponent;\n\n    this.layoutRenderComponent = createRenderComponent(VirtualTableLayout$1, { height: height, estimatedRowHeight: estimatedRowHeight, headTableComponent: headTableComponent });\n  },\n  beforeUpdate: function beforeUpdate() {\n    var height = this.height,\n        estimatedRowHeight = this.estimatedRowHeight,\n        headTableComponent = this.headTableComponent;\n\n    this.layoutRenderComponent.update({ height: height, estimatedRowHeight: estimatedRowHeight, headTableComponent: headTableComponent });\n  },\n  render: function render() {\n    var h = arguments[0];\n    var messages = this.messages;\n\n\n    return h(DxTable, babelHelperVueJsxMergeProps([{\n      attrs: {\n        layoutComponent: this.layoutRenderComponent.component,\n        tableComponent: Table,\n        headComponent: TableHead$1,\n        bodyComponent: TableBody$1,\n        containerComponent: TableContainer,\n        rowComponent: TableRow,\n        cellComponent: TableCell,\n        noDataRowComponent: TableRow,\n        noDataCellComponent: TableNoDataCell,\n        stubRowComponent: TableStubRow,\n        stubCellComponent: TableStubCell,\n        stubHeaderCellComponent: TableStubHeaderCell,\n        messages: _extends({}, defaultMessages$7, { messages: messages })\n      }\n    }, { attrs: this.$attrs, on: this.$listeners }]));\n  },\n\n  components: {\n    DxCell: TableCell,\n    DxRow: TableRow,\n    DxNoDataCell: TableNoDataCell,\n    DxNoDataRow: TableRow,\n    DxStubRow: TableStubRow,\n    DxStubCell: TableStubCell,\n    DxStubHeaderCell: TableStubCell,\n    DxTable: Table,\n    DxTableHead: TableHead$1,\n    DxTableBody: TableBody$1,\n    DxFixedHeader: FixedHeader,\n    DxContainer: TableContainer\n  }\n};\n\nexport { DxGrid$1 as DxGrid, DxTable$1 as DxTable, DxTableHeaderRow$1 as DxTableHeaderRow, DxTableFilterRow$1 as DxTableFilterRow, DxToolbar$2 as DxToolbar, DxGroupingPanel$1 as DxGroupingPanel, DxTableGroupRow$1 as DxTableGroupRow, DxSearchPanel$1 as DxSearchPanel, DxTableSelection$1 as DxTableSelection, DxPagingPanel$1 as DxPagingPanel, DxTableEditColumn$1 as DxTableEditColumn, DxTableEditRow$1 as DxTableEditRow, DxTableRowDetail$1 as DxTableRowDetail, DxTableTreeColumn$1 as DxTableTreeColumn, DxTableBandHeader$1 as DxTableBandHeader, DxColumnChooser$1 as DxColumnChooser, DxTableColumnVisibility$1 as DxTableColumnVisibility, DxVirtualTable };\n//# sourceMappingURL=dx-vue-grid-bootstrap4.es.js.map\n","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\nexports.blobConstructor = false\ntry {\n\tnew Blob([new ArrayBuffer(1)])\n\texports.blobConstructor = true\n} catch (e) {}\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\n// Safari 7.1 appears to have fixed this bug.\nvar haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'\nvar haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&\n\tcheckTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nexports.vbArray = isFunction(global.VBArray)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","/**\r\n * DevExtreme (data/odata/store.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nvar isDefined = require(\"../../core/utils/type\").isDefined,\r\n    config = require(\"../../core/config\"),\r\n    odataUtils = require(\"./utils\"),\r\n    proxyUrlFormatter = require(\"../proxy_url_formatter\"),\r\n    errors = require(\"../errors\").errors,\r\n    query = require(\"../query\"),\r\n    Store = require(\"../abstract_store\"),\r\n    mixins = require(\"./mixins\"),\r\n    deferredUtils = require(\"../../core/utils/deferred\"),\r\n    when = deferredUtils.when,\r\n    Deferred = deferredUtils.Deferred;\r\nrequire(\"./query_adapter\");\r\nvar ANONYMOUS_KEY_NAME = \"5d46402c-7899-4ea9-bd81-8b73c47c7683\";\r\n\r\nfunction expandKeyType(key, keyType) {\r\n    var result = {};\r\n    result[key] = keyType;\r\n    return result\r\n}\r\n\r\nfunction mergeFieldTypesWithKeyType(fieldTypes, keyType) {\r\n    var result = {};\r\n    for (var field in fieldTypes) {\r\n        result[field] = fieldTypes[field]\r\n    }\r\n    for (var keyName in keyType) {\r\n        if (keyName in result) {\r\n            if (result[keyName] !== keyType[keyName]) {\r\n                errors.log(\"W4001\", keyName)\r\n            }\r\n        } else {\r\n            result[keyName] = keyType[keyName]\r\n        }\r\n    }\r\n    return result\r\n}\r\nvar ODataStore = Store.inherit({\r\n    ctor: function(options) {\r\n        this.callBase(options);\r\n        this._extractServiceOptions(options);\r\n        var key = this.key(),\r\n            fieldTypes = options.fieldTypes,\r\n            keyType = options.keyType;\r\n        if (keyType) {\r\n            var keyTypeIsString = \"string\" === typeof keyType;\r\n            if (!key) {\r\n                key = keyTypeIsString ? ANONYMOUS_KEY_NAME : Object.keys(keyType);\r\n                this._legacyAnonymousKey = key\r\n            }\r\n            if (keyTypeIsString) {\r\n                keyType = expandKeyType(key, keyType)\r\n            }\r\n            fieldTypes = mergeFieldTypesWithKeyType(fieldTypes, keyType)\r\n        }\r\n        this._fieldTypes = fieldTypes || {};\r\n        if (2 === this.version()) {\r\n            this._updateMethod = \"MERGE\"\r\n        } else {\r\n            this._updateMethod = \"PATCH\"\r\n        }\r\n    },\r\n    _customLoadOptions: function() {\r\n        return [\"expand\", \"customQueryParams\"]\r\n    },\r\n    _byKeyImpl: function(key, extraOptions) {\r\n        var params = {};\r\n        if (extraOptions) {\r\n            params.$expand = odataUtils.generateExpand(this._version, extraOptions.expand, extraOptions.select) || void 0;\r\n            params.$select = odataUtils.generateSelect(this._version, extraOptions.select) || void 0\r\n        }\r\n        return this._sendRequest(this._byKeyUrl(key), \"GET\", params)\r\n    },\r\n    createQuery: function(loadOptions) {\r\n        var url, queryOptions;\r\n        loadOptions = loadOptions || {};\r\n        queryOptions = {\r\n            adapter: \"odata\",\r\n            beforeSend: this._beforeSend,\r\n            errorHandler: this._errorHandler,\r\n            jsonp: this._jsonp,\r\n            version: this._version,\r\n            withCredentials: this._withCredentials,\r\n            expand: loadOptions.expand,\r\n            requireTotalCount: loadOptions.requireTotalCount,\r\n            deserializeDates: this._deserializeDates,\r\n            fieldTypes: this._fieldTypes\r\n        };\r\n        if (isDefined(loadOptions.urlOverride)) {\r\n            url = loadOptions.urlOverride\r\n        } else {\r\n            url = this._url\r\n        }\r\n        if (isDefined(this._filterToLower)) {\r\n            queryOptions.filterToLower = this._filterToLower\r\n        }\r\n        if (loadOptions.customQueryParams) {\r\n            var params = mixins.escapeServiceOperationParams(loadOptions.customQueryParams, this.version());\r\n            if (4 === this.version()) {\r\n                url = mixins.formatFunctionInvocationUrl(url, params)\r\n            } else {\r\n                queryOptions.params = params\r\n            }\r\n        }\r\n        return query(url, queryOptions)\r\n    },\r\n    _insertImpl: function(values) {\r\n        this._requireKey();\r\n        var that = this,\r\n            d = new Deferred;\r\n        when(this._sendRequest(this._url, \"POST\", null, values)).done(function(serverResponse) {\r\n            d.resolve(config().useLegacyStoreResult ? values : serverResponse || values, that.keyOf(serverResponse))\r\n        }).fail(d.reject);\r\n        return d.promise()\r\n    },\r\n    _updateImpl: function(key, values) {\r\n        var d = new Deferred;\r\n        when(this._sendRequest(this._byKeyUrl(key), this._updateMethod, null, values)).done(function(serverResponse) {\r\n            if (config().useLegacyStoreResult) {\r\n                d.resolve(key, values)\r\n            } else {\r\n                d.resolve(serverResponse || values, key)\r\n            }\r\n        }).fail(d.reject);\r\n        return d.promise()\r\n    },\r\n    _removeImpl: function(key) {\r\n        var d = new Deferred;\r\n        when(this._sendRequest(this._byKeyUrl(key), \"DELETE\")).done(function() {\r\n            d.resolve(key)\r\n        }).fail(d.reject);\r\n        return d.promise()\r\n    },\r\n    _convertKey: function(value) {\r\n        var result = value,\r\n            fieldTypes = this._fieldTypes,\r\n            key = this.key() || this._legacyAnonymousKey;\r\n        if (Array.isArray(key)) {\r\n            result = {};\r\n            for (var i = 0; i < key.length; i++) {\r\n                var keyName = key[i];\r\n                result[keyName] = odataUtils.convertPrimitiveValue(fieldTypes[keyName], value[keyName])\r\n            }\r\n        } else {\r\n            if (fieldTypes[key]) {\r\n                result = odataUtils.convertPrimitiveValue(fieldTypes[key], value)\r\n            }\r\n        }\r\n        return result\r\n    },\r\n    _byKeyUrl: function(value, useOriginalHost) {\r\n        var baseUrl = useOriginalHost ? proxyUrlFormatter.formatLocalUrl(this._url) : this._url;\r\n        var convertedKey = this._convertKey(value);\r\n        return baseUrl + \"(\" + encodeURIComponent(odataUtils.serializeKey(convertedKey, this._version)) + \")\"\r\n    }\r\n}, \"odata\").include(mixins.SharedMethods);\r\nmodule.exports = ODataStore;\r\nmodule.exports.default = module.exports;\r\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(new Buffer(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tif (result.done) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(new Buffer(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text:vbarray': // For IE9\n\t\t\tif (xhr.readyState !== rStates.DONE)\n\t\t\t\tbreak\n\t\t\ttry {\n\t\t\t\t// This fails in IE8\n\t\t\t\tresponse = new global.VBArray(xhr.responseBody).toArray()\n\t\t\t} catch (e) {}\n\t\t\tif (response !== null) {\n\t\t\t\tself.push(new Buffer(response))\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t// Falls through in IE8\t\n\t\tcase 'text':\n\t\t\ttry { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\n\t\t\t\tresponse = xhr.responseText\n\t\t\t} catch (e) {\n\t\t\t\tself._mode = 'text:vbarray'\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = new Buffer(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tself.push(null)\n\t}\n}\n","/**\r\n * DevExtreme (data/odata/mixins.js)\r\n * Version: 19.2.3\r\n * Build date: Tue Oct 22 2019\r\n *\r\n * Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED\r\n * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/\r\n */\r\n\"use strict\";\r\nvar stringUtils = require(\"../../core/utils/string\"),\r\n    iteratorUtils = require(\"../../core/utils/iterator\"),\r\n    odataUtils = require(\"./utils\");\r\nrequire(\"./query_adapter\");\r\nvar DEFAULT_PROTOCOL_VERSION = 2;\r\nvar formatFunctionInvocationUrl = function(baseUrl, args) {\r\n    return stringUtils.format(\"{0}({1})\", baseUrl, iteratorUtils.map(args || {}, function(value, key) {\r\n        return stringUtils.format(\"{0}={1}\", key, value)\r\n    }).join(\",\"))\r\n};\r\nvar escapeServiceOperationParams = function(params, version) {\r\n    if (!params) {\r\n        return params\r\n    }\r\n    var result = {};\r\n    iteratorUtils.each(params, function(k, v) {\r\n        result[k] = odataUtils.serializeValue(v, version)\r\n    });\r\n    return result\r\n};\r\nvar SharedMethods = {\r\n    _extractServiceOptions: function(options) {\r\n        options = options || {};\r\n        this._url = String(options.url).replace(/\\/+$/, \"\");\r\n        this._beforeSend = options.beforeSend;\r\n        this._jsonp = options.jsonp;\r\n        this._version = options.version || DEFAULT_PROTOCOL_VERSION;\r\n        this._withCredentials = options.withCredentials;\r\n        this._deserializeDates = options.deserializeDates;\r\n        this._filterToLower = options.filterToLower\r\n    },\r\n    _sendRequest: function(url, method, params, payload) {\r\n        return odataUtils.sendRequest(this.version(), {\r\n            url: url,\r\n            method: method,\r\n            params: params || {},\r\n            payload: payload\r\n        }, {\r\n            beforeSend: this._beforeSend,\r\n            jsonp: this._jsonp,\r\n            withCredentials: this._withCredentials,\r\n            deserializeDates: this._deserializeDates\r\n        })\r\n    },\r\n    version: function() {\r\n        return this._version\r\n    }\r\n};\r\nexports.SharedMethods = SharedMethods;\r\nexports.escapeServiceOperationParams = escapeServiceOperationParams;\r\nexports.formatFunctionInvocationUrl = formatFunctionInvocationUrl;\r\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","var Buffer = require('buffer').Buffer\n\nmodule.exports = function (buf) {\n\t// If the buffer is backed by a Uint8Array, a faster version will work\n\tif (buf instanceof Uint8Array) {\n\t\t// If the buffer isn't a subarray, return the underlying ArrayBuffer\n\t\tif (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {\n\t\t\treturn buf.buffer\n\t\t} else if (typeof buf.buffer.slice === 'function') {\n\t\t\t// Otherwise we need to get a proper copy\n\t\t\treturn buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)\n\t\t}\n\t}\n\n\tif (Buffer.isBuffer(buf)) {\n\t\t// This is the slow version that will work with any Buffer\n\t\t// implementation (even in old browsers)\n\t\tvar arrayCopy = new Uint8Array(buf.length)\n\t\tvar len = buf.length\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tarrayCopy[i] = buf[i]\n\t\t}\n\t\treturn arrayCopy.buffer\n\t} else {\n\t\tthrow new Error('Argument must be a Buffer')\n\t}\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n"],"sourceRoot":""}