{"version":3,"file":"kendo.pivot.common.min.js","names":["factory","define","amd","window","kendo","pivotgrid","common","exports","filterFunctionFormats","contains","doesnotcontain","endswith","eq","neq","startswith","operators","serializeExpression","expression","command","value","String","field","operator","str","arguments$1","arguments","values","_i","length","forEach","index","replace","RegExp","formatString","serializeMembers","members","measures","sort","memberName","parsed","found","expanded","child","root","idx","member","name_1","name","push","hierarchyName","baseHierarchyPath","j","l","indexOf","expand","concat","parseDescriptors","rootNames","some","n","getRootNames","crossJoinCommands","names","crossJoinCommand","mapNames","expandMemberDescriptor","join","measureNames","measure","result","undefined","rootLength","slice","name_2","rootName","tmp","crossJoin","sortDescriptor","length_1","sortDescriptorForMember","dir","parts","split","pop","shift","createRequestBody","options","_a","columnAxes","_b","rowAxes","_c","measureAxes","_d","_e","filter","measuresRowAxis","measuresAxis","filters","cube","current","serializeFilters","connection","catalog","__assign","Object","assign","t","s","i","p","prototype","hasOwnProperty","call","apply","this","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","throw","return","Symbol","iterator","v","op","TypeError","__spreadArrays","il","r","Array","k","a","jl","parseResponse","response","xmlDoc","DOMParser","parseFromString","axes","from","querySelectorAll","cells","map","cell","fmtValue","getPropertyValue","ordinal","parseInt","getAttribute","columns","tuples","rows","data","axis","tuple","lNum","hasChildren","caption","children","hierarchy","levelName","levelNum","parentName","translateAxis","indexedData","fill","c","counter","rowTuple","colTuple","columnTuple","node","querySelector","textContent","discoverCommands","schemaCatalogs","schemaCubes","schemaDimensions","schemaHierarchies","schemaKPIs","schemaLevels","schemaMeasures","schemaMembers","createDiscoverBody","properties","serializeOptions","restrictions","Catalog","parentTagName","capitalize","key","toUpperCase","discoverParser","row","description","type","defaultHierarchy","uniqueName","dimensionUniqueName","displayFolder","origin","defaultMember","goal","status","trend","statusGraphic","trendGraphic","groupName","orderingProperty","hierarchyUniqueName","aggregator","defaultFormat","levelUniqueName","childrenCardinality","getMaxNesting","set","Set","add","size","getMaxExpansion","generateNormalizedPath","parent","normalizedPath","Boolean","toMatrix","rowIndex","colIndex","maxDepth","maxBreadth","matrix","leafs","branchDepth","branchBreadth","depth","breadth","matrixResult","leafsResult","findIndex","level","inject","total","path","splice","collOffset","newMatrix","newLeafs","childBreadth","withTotal","alt","childIndex","childHierarchy","copy","obj","JSON","parse","stringify","kpiMeasure","kpi","buildKPIMeasures","HEADERS_ACTION","compareAxisWithField","b","compareAxes","filterField","out","_loop_2","startsWith","duplicatedAxisIndex","ax","insertAxis","toInsert","state","dropTarget","dropDirection","offset","PIVOT_CONFIGURATOR_ACTION","findPath","matchFn","matched","match","h","headersReducer","action","toggle","existing","find","payload","collapse","existing_1","nextState","filtered_1","tree","configuratorReducer","newRows","newColumns","newMeasures","newSort","newFilter","newDragitem","newDropZone","newDropDirection","newDropTarget","toggleSelection","isArray","payload_1","removeMeasureAxis","addMeasureAxis","every","m","removeMeasureAxes","addMeasureAxes","removeColumnAxis","removeRowAxis","addColumnAxis","addRowAxis","addColumnAxes","removeColumnAxes","addRowAxes","removeRowAxes","remove","setDragItem","setDropZone","setDropTarget","setDropDirection","drop","dragItem","dropZone","currentColumn","currentRow","currentMeasure","setSort","setFilter","addFilter","changeFilter","removeFilter","minAggregate","init","min","Number","POSITIVE_INFINITY","merge","src","dest","Math","accumulate","acc","isFinite","NaN","format","toFixed","maxAggregate","max","NEGATIVE_INFINITY","isPresent","isBlank","isFunction","isString","isNotNullOrEmptyString","trim","isNullOrEmptyString","isDate","getTime","ifElse","predicate","right","left","compose","args","reduceRight","curr","getterCache","FIELD_REGEX","what","getter","safe","fields","indexAccessor","pairwise","empty","isNotEmptyArray","formatDescriptors","accessor","formatter","sanitizeDateLiterals","removeAfterDot","directionFormatter","take","aggregates","group","formatSort","formatGroup","formatAggregates","aggregate","formatDateValue","date","Date","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","skip","floor","transformSort","filterFormatter","x","ignoreCase","target","convert","mapper","keys","reduce","bind","translateAggregate","source","toLowerCase","translateAggregates","valueOrDefault","defaultValue","translateGroup","hasSubgroups","items","Aggregates","Member","HasSubgroups","Items","Key","logic","or","fn","identity","and","operatorsMap","doesnotendwith","doesnotstartwith","lastIndexOf","gt","gte","isempty","isnotempty","isnotnull","isnull","lt","lte","dateRegExp","typedGetter","prop","exec","isNaN","parseFloat","isNumeric","transformFilter","itemProp","convertValue","transformCompositeFilter","combiner","forEachDesc","desc","callbackfn","filterFields","callback","initializeFiltering","descriptor","compositeFilter","fieldValues","hasFilter","filteringAxes","filteringFields_1","subNode","initialNode","childNode","get","Map","splitKeyValue","keyValue","separatorIndex","substring","calculateColumnData","dataField","childData_1","parentData_1","mergeTrees","srcChild","destChild","calculateColumns","columnsData","srcColumns","destColumns","createPath","caption_1","membersNode","axisSettings","cache","cacheData","has","currentLevel","currentLevelNode","levelField_1","_loop_1","d","item","newDest","currentPath","readData","dataTree","rowTuples","columnTuples","columnSettings","rowSettings","rowsCache","rowNode","rowColumnsNode","col","measuresMember_1","colNode","mergeData","exclude","rootFields","definitions","createTuples","axesSettings","sortDescriptors","excludeFields","parentFields","flatMembers","topTuple","allTuple","topField","getTopMembersTuple","currDef","axe","keysToAdd","currDefMembers","element","delete","nodeData","curLevel_1","childrenByKeys","order","sortableA","sortValue","sortableB","sortFunc","leafValue","leafTuple","axisCaption","curCaption","addMeasure","measureMember","tupleCopy","addMultipleMeasures","tupleWithMeasure","addKPI","averageAggregate","sumA","count","cloneDataTree","createAxisDescriptors","expandTree","descriptors","createDataState","createDataTree","leafNodes","dataItem","filteringDataItem_1","displayValue","dataKey","node_1","eachAxis","leaf","createFlatSchemaDimensions","dimensions","dim","createLocalDataState","fetchData","fetchOptions","headers","method","fetch","url","text","fetchDiscover","stringResponse","sumAggregate","sum","toColumns","rowSpan","colSpan","toData","hash","membersNames","columnsIndexes","rowsIndexes","colMembers","rowMembers","toRows","rotateMatrix","toTree","tupleIndex","memberIndex","parent_1","parentKey","intruderIndex","defineProperty"],"sources":["kendo.pivot.common.js"],"mappings":"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","sourcesContent":["(function (factory) {\n    typeof define === 'function' && define.amd ? define(['kendo.core'], factory) :\n    factory();\n})((function () {\n    (function () {\n\n    window.kendo.pivotgrid = window.kendo.pivotgrid || {};\n    window.kendo.pivotgrid.common = (function (exports) {\n        \n\n        var filterFunctionFormats = {\n            contains: \", InStr({0}.CurrentMember.MEMBER_CAPTION,\\\"{1}\\\") > 0\",\n            doesnotcontain: \", InStr({0}.CurrentMember.MEMBER_CAPTION,\\\"{1}\\\")\",\n            endswith: \", Right({0}.CurrentMember.MEMBER_CAPTION,Len(\\\"{1}\\\"))=\\\"{1}\\\"\",\n            eq: \", {0}.CurrentMember.MEMBER_CAPTION = \\\"{1}\\\"\",\n            neq: \", {0}.CurrentMember.MEMBER_CAPTION = \\\"{1}\\\"\",\n            startswith: \", Left({0}.CurrentMember.MEMBER_CAPTION,Len(\\\"{1}\\\"))=\\\"{1}\\\"\"\n        };\n        var operators = {\n            doesnotcontain: 'doesnotcontain',\n            in: 'in',\n            neq: \"neq\"\n        };\n        /**\n         * @hidden\n         */\n        function serializeFilters(filters, cube) {\n            var command = \"\";\n            var current = \"\";\n            for (var idx = filters.length - 1; idx >= 0; idx--) {\n                current = \"SELECT (\";\n                current += serializeExpression(filters[idx]);\n                current += \") ON 0\";\n                if (idx === filters.length - 1) {\n                    current += \" FROM [\" + cube + \"]\";\n                    command = current;\n                }\n                else {\n                    command = current + \" FROM ( \" + command + \" )\";\n                }\n            }\n            return command;\n        }\n        function serializeExpression(expression) {\n            var command = '';\n            var value = String(expression.value);\n            var field = expression.field;\n            var operator = expression.operator;\n            if (operator === operators.in) {\n                command += \"{\";\n                command += value;\n                command += \"}\";\n            }\n            else {\n                command += operator === operators.neq || operator === operators.doesnotcontain ? '-' : '';\n                command += \"Filter(\";\n                command += field + \".MEMBERS\";\n                command += formatString(filterFunctionFormats[operator], field, value);\n                command += \")\";\n            }\n            return command;\n        }\n        function formatString(str) {\n            var arguments$1 = arguments;\n\n            var values = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                values[_i - 1] = arguments$1[_i];\n            }\n            values.forEach(function (value, index) {\n                str = str.replace(new RegExp(\"\\\\{\" + index + \"\\\\}\", 'g'), value);\n            });\n            return str;\n        }\n\n        /**\n         * @hidden\n         */\n        function serializeMembers(members, measures, sort) {\n            var command = \"\";\n            members = members || [];\n            var parsed = parseDescriptors(members);\n            var expanded = parsed.expanded;\n            var rootNames = getRootNames(parsed.root);\n            var crossJoinCommands = [];\n            var length = expanded.length;\n            var idx = 0;\n            var memberName;\n            var names = [];\n            if (rootNames.length > 1 || measures.length > 1) {\n                crossJoinCommands.push(crossJoinCommand(rootNames, measures));\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names = mapNames(memberName, rootNames);\n                    crossJoinCommands.push(crossJoinCommand(names, measures));\n                }\n                command += crossJoinCommands.join(\",\");\n            }\n            else {\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names.push(memberName[0]);\n                }\n                command += rootNames.concat(names).join(\",\");\n            }\n            return command;\n        }\n        /**\n         * @hidden\n         */\n        function measureNames(measures) {\n            var length = measures.length;\n            var result = [];\n            var measure;\n            for (var idx = 0; idx < length; idx++) {\n                measure = measures[idx];\n                result.push(measure.name !== undefined ? measure.name : measure);\n            }\n            return result;\n        }\n        function getRootNames(members) {\n            var root = [];\n            members.forEach(function (member) {\n                var name = member.name[0];\n                var hierarchyName = baseHierarchyPath(name);\n                if (!root.some(function (n) { return n.indexOf(hierarchyName) === 0; })) {\n                    root.push(name);\n                }\n            });\n            return root;\n        }\n        function parseDescriptors(members) {\n            var expanded = [];\n            var child = [];\n            var root = [];\n            var idx = 0;\n            var found;\n            for (; idx < members.length; idx++) {\n                var member = members[idx];\n                var name_1 = member.name;\n                found = false;\n                if (name_1.length > 1) {\n                    child.push(member);\n                }\n                else {\n                    var hierarchyName = baseHierarchyPath(name_1[0]);\n                    for (var j = 0, l = root.length; j < l; j++) {\n                        if (root[j].name[0].indexOf(hierarchyName) === 0) {\n                            found = true;\n                            break;\n                        }\n                    }\n                    if (!found) {\n                        root.push(member);\n                    }\n                    if (member.expand) {\n                        expanded.push(member);\n                    }\n                }\n            }\n            expanded = expanded.concat(child);\n            return {\n                expanded: expanded,\n                root: root\n            };\n        }\n        function mapNames(names, rootNames) {\n            var rootLength = rootNames.length;\n            rootNames = rootNames.slice(0);\n            for (var idx = 0; idx < names.length; idx++) {\n                var name_2 = names[idx];\n                for (var j = 0; j < rootLength; j++) {\n                    var rootName = baseHierarchyPath(rootNames[j]);\n                    if (name_2.indexOf(rootName) !== -1) {\n                        rootNames[j] = name_2;\n                        break;\n                    }\n                }\n            }\n            return rootNames;\n        }\n        function crossJoinCommand(members, measures) {\n            var tmp = members.slice(0);\n            if (measures.length > 1) {\n                tmp.push(\"{\" + measureNames(measures).join(\",\") + \"}\");\n            }\n            return crossJoin(tmp);\n        }\n        function expandMemberDescriptor(names, sort) {\n            var idx = names.length - 1;\n            var name = names[idx];\n            var sortDescriptor = sortDescriptorForMember(sort, name);\n            if (sortDescriptor && sortDescriptor.dir) {\n                name = \"ORDER(\" + name + \".Children,\" + sortDescriptor.field + \".CurrentMember.MEMBER_CAPTION,\" + sortDescriptor.dir + \")\";\n            }\n            else {\n                name += \".Children\";\n            }\n            names[idx] = name;\n            return names;\n        }\n        function sortDescriptorForMember(sort, member) {\n            for (var idx = 0, length_1 = sort.length; idx < length_1; idx++) {\n                if (member.indexOf(sort[idx].field) === 0) {\n                    return sort[idx];\n                }\n            }\n            return null;\n        }\n        function baseHierarchyPath(memberName) {\n            var parts = memberName.split(\".\");\n            if (parts.length > 2) {\n                return parts[0] + \".\" + parts[1];\n            }\n            return memberName;\n        }\n        function crossJoin(names) {\n            var result = \"CROSSJOIN({\";\n            var name;\n            if (names.length > 2) {\n                name = names.pop();\n                result += crossJoin(names);\n            }\n            else {\n                result += names.shift();\n                name = names.pop();\n            }\n            result += \"},{\";\n            result += name;\n            result += \"})\";\n            return result;\n        }\n\n        /**\n         * @hidden\n         */\n        function createRequestBody(options) {\n            var command = '<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"><Header/><Body><Execute xmlns=\"urn:schemas-microsoft-com:xml-analysis\"><Command><Statement>';\n            var _a = options.columnAxes, columnAxes = _a === void 0 ? [] : _a, _b = options.rowAxes, rowAxes = _b === void 0 ? [] : _b;\n            var _c = options.measureAxes, measureAxes = _c === void 0 ? [] : _c, _d = options.sort, sort = _d === void 0 ? [] : _d, _e = options.filter, filter = _e === void 0 ? [] : _e;\n            var measuresRowAxis = options.measuresAxis === \"rows\";\n            command += \"SELECT NON EMPTY {\";\n            if (!columnAxes.length && rowAxes.length && (!measureAxes.length || (measureAxes.length && measuresRowAxis))) {\n                columnAxes = rowAxes;\n                rowAxes = [];\n                measuresRowAxis = false;\n            }\n            if (!columnAxes.length && !rowAxes.length) {\n                measuresRowAxis = false;\n            }\n            if (columnAxes.length) {\n                command += serializeMembers(columnAxes, !measuresRowAxis ? measureAxes : [], sort);\n            }\n            else if (measureAxes.length && !measuresRowAxis) {\n                command += measureNames(measureAxes).join(\",\");\n            }\n            command += \"} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON COLUMNS\";\n            if (rowAxes.length || (measuresRowAxis && measureAxes.length > 1)) {\n                command += \", NON EMPTY {\";\n                if (rowAxes.length) {\n                    command += serializeMembers(rowAxes, measuresRowAxis ? measureAxes : [], sort);\n                }\n                else {\n                    command += measureNames(measureAxes).join(\",\");\n                }\n                command += \"} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON ROWS\";\n            }\n            if (filter.length) {\n                command += \" FROM \";\n                command += \"(\";\n                command += serializeFilters(filter, options.connection.cube);\n                command += \")\";\n            }\n            else {\n                command += \" FROM [\" + options.connection.cube + \"]\";\n            }\n            if (measureAxes.length === 1 && columnAxes.length) {\n                command += \" WHERE (\" + measureNames(measureAxes).join(\",\") + \")\";\n            }\n            command += '</Statement></Command><Properties><PropertyList><Catalog>' + options.connection.catalog + '</Catalog><Format>Multidimensional</Format></PropertyList></Properties></Execute></Body></Envelope>';\n            return command.replace(/&/g, \"&amp;\");\n        }\n\n        /******************************************************************************\n        Copyright (c) Microsoft Corporation.\n\n        Permission to use, copy, modify, and/or distribute this software for any\n        purpose with or without fee is hereby granted.\n\n        THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n        REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n        AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n        INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n        LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n        OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n        PERFORMANCE OF THIS SOFTWARE.\n        ***************************************************************************** */\n\n        var __assign = function() {\n            __assign = Object.assign || function __assign(t) {\n                var arguments$1 = arguments;\n\n                for (var s, i = 1, n = arguments.length; i < n; i++) {\n                    s = arguments$1[i];\n                    for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p)) { t[p] = s[p]; } }\n                }\n                return t;\n            };\n            return __assign.apply(this, arguments);\n        };\n\n        function __awaiter(thisArg, _arguments, P, generator) {\n            function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n            return new (P || (P = Promise))(function (resolve, reject) {\n                function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n                function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n                function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n                step((generator = generator.apply(thisArg, _arguments || [])).next());\n            });\n        }\n\n        function __generator(thisArg, body) {\n            var _ = { label: 0, sent: function() { if (t[0] & 1) { throw t[1]; } return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n            return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n            function verb(n) { return function (v) { return step([n, v]); }; }\n            function step(op) {\n                if (f) { throw new TypeError(\"Generator is already executing.\"); }\n                while (_) { try {\n                    if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) { return t; }\n                    if (y = 0, t) { op = [op[0] & 2, t.value]; }\n                    switch (op[0]) {\n                        case 0: case 1: t = op; break;\n                        case 4: _.label++; return { value: op[1], done: false };\n                        case 5: _.label++; y = op[1]; op = [0]; continue;\n                        case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                        default:\n                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                            if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                            if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                            if (t[2]) { _.ops.pop(); }\n                            _.trys.pop(); continue;\n                    }\n                    op = body.call(thisArg, _);\n                } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } }\n                if (op[0] & 5) { throw op[1]; } return { value: op[0] ? op[1] : void 0, done: true };\n            }\n        }\n\n        /** @deprecated */\n        function __spreadArrays() {\n            var arguments$1 = arguments;\n\n            for (var s = 0, i = 0, il = arguments.length; i < il; i++) { s += arguments$1[i].length; }\n            for (var r = Array(s), k = 0, i = 0; i < il; i++)\n                { for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n                    { r[k] = a[j]; } }\n            return r;\n        }\n\n        /**\n         * @hidden\n         */\n        function parseResponse(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var axes = Array.from(xmlDoc.querySelectorAll(\"Axis\"));\n            var cells = Array.from(xmlDoc.querySelectorAll(\"CellData > Cell\"))\n                .map(function (cell) { return ({\n                fmtValue: getPropertyValue(cell, \"FmtValue\"),\n                ordinal: parseInt(cell.getAttribute(\"CellOrdinal\"), 10),\n                value: getPropertyValue(cell, \"Value\")\n            }); });\n            var columns = { tuples: [] };\n            var rows = { tuples: [] };\n            var data = [];\n            axes.forEach(function (axis) {\n                if (axis.getAttribute('name') !== \"SlicerAxis\") {\n                    var tuples = columns.tuples.length === 0 ? columns.tuples : rows.tuples;\n                    Array.prototype.push.apply(tuples, translateAxis(axis));\n                }\n            });\n            var indexedData = new Array(rows.tuples.length * columns.tuples.length).fill(null);\n            cells.forEach(function (c) { indexedData[c.ordinal] = c; });\n            var counter = 0;\n            rows.tuples.forEach(function (rowTuple) {\n                columns.tuples.forEach(function (colTuple) {\n                    data.push({\n                        columnTuple: colTuple,\n                        data: indexedData[counter],\n                        rowTuple: rowTuple\n                    });\n                    counter++;\n                });\n            });\n            return { columns: columns, data: data, rows: rows };\n        }\n        /**\n         * @hidden\n         */\n        function getPropertyValue(member, name) {\n            var node = member.querySelector(name);\n            return node ? node.textContent : \"\";\n        }\n        function translateAxis(axis) {\n            var tuples = Array.from(axis.querySelectorAll(\"Tuple\"));\n            return tuples.map(function (tuple) {\n                var memberElements = Array.from(tuple.querySelectorAll(\"Member\"));\n                var members = memberElements.map(function (member) {\n                    var lNum = parseInt(getPropertyValue(member, \"LNum\") || \"0\", 10);\n                    var hasChildren = parseInt(getPropertyValue(member, \"CHILDREN_CARDINALITY\") || \"0\", 10) > 0;\n                    return {\n                        caption: getPropertyValue(member, \"Caption\"),\n                        children: [],\n                        hasChildren: hasChildren,\n                        hierarchy: member.getAttribute('Hierarchy'),\n                        levelName: getPropertyValue(member, \"LName\"),\n                        levelNum: lNum,\n                        name: getPropertyValue(member, \"UName\"),\n                        parentName: getPropertyValue(member, \"PARENT_UNIQUE_NAME\")\n                    };\n                });\n                return { members: members };\n            });\n        }\n\n        /**\n         * @hidden\n         */\n        var discoverCommands = {\n            schemaCatalogs: \"DBSCHEMA_CATALOGS\",\n            schemaCubes: \"MDSCHEMA_CUBES\",\n            schemaDimensions: \"MDSCHEMA_DIMENSIONS\",\n            schemaHierarchies: \"MDSCHEMA_HIERARCHIES\",\n            schemaKPIs: \"MDSCHEMA_KPIS\",\n            schemaLevels: \"MDSCHEMA_LEVELS\",\n            schemaMeasures: \"MDSCHEMA_MEASURES\",\n            schemaMembers: \"MDSCHEMA_MEMBERS\"\n        };\n        /**\n         * @hidden\n         */\n        function createDiscoverBody(options) {\n            var properties = {};\n            var command = '<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"><Header/><Body><Discover xmlns=\"urn:schemas-microsoft-com:xml-analysis\">';\n            command += \"<RequestType>\" + (discoverCommands[options.command] || options.command) + \"</RequestType>\";\n            command += \"<Restrictions>\" + serializeOptions(\"RestrictionList\", options.restrictions, true) + \"</Restrictions>\";\n            if (options.connection && options.connection.catalog) {\n                properties.Catalog = options.connection.catalog;\n            }\n            command += \"<Properties>\" + serializeOptions(\"PropertyList\", properties, false) + \"</Properties>\";\n            command += '</Discover></Body></Envelope>';\n            return command;\n        }\n        function serializeOptions(parentTagName, options, capitalize) {\n            var result = \"\";\n            if (options) {\n                result += \"<\" + parentTagName + \">\";\n                var value = void 0;\n                for (var key in options) {\n                    if (options[key]) {\n                        value = options[key];\n                        if (capitalize) {\n                            key = key.replace(/([A-Z]+(?=$|[A-Z][a-z])|[A-Z]?[a-z]+)/g, \"$1_\").toUpperCase().replace(/_$/, \"\");\n                        }\n                        result += \"<\" + key + \">\" + value + \"</\" + key + \">\";\n                    }\n                }\n                result += \"</\" + parentTagName + \">\";\n            }\n            else {\n                result += \"<\" + parentTagName + \"/>\";\n            }\n            return result;\n        }\n\n        /**\n         * @hidden\n         */\n        function parseCubes(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"CUBE_NAME\"),\n                caption: getPropertyValue(row, \"CUBE_CAPTION\"),\n                description: getPropertyValue(row, \"DESCRIPTION\"),\n                type: getPropertyValue(row, \"CUBE_TYPE\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseCatalogs(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"CATALOG_NAME\"),\n                description: getPropertyValue(row, \"DESCRIPTION\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseMeasures(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"MEASURE_NAME\"),\n                caption: getPropertyValue(row, \"MEASURE_CAPTION\"),\n                uniqueName: getPropertyValue(row, \"MEASURE_UNIQUE_NAME\"),\n                description: getPropertyValue(row, \"DESCRIPTION\"),\n                aggregator: getPropertyValue(row, \"MEASURE_AGGREGATOR\"),\n                groupName: getPropertyValue(row, \"MEASUREGROUP_NAME\"),\n                displayFolder: getPropertyValue(row, \"MEASURE_DISPLAY_FOLDER\"),\n                defaultFormat: getPropertyValue(row, \"DEFAULT_FORMAT_STRING\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseKPIs(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"KPI_NAME\"),\n                uniqueName: getPropertyValue(row, \"KPI_NAME\"),\n                caption: getPropertyValue(row, \"KPI_CAPTION\"),\n                value: getPropertyValue(row, \"KPI_VALUE\"),\n                goal: getPropertyValue(row, \"KPI_GOAL\"),\n                status: getPropertyValue(row, \"KPI_STATUS\"),\n                trend: getPropertyValue(row, \"KPI_TREND\"),\n                statusGraphic: getPropertyValue(row, \"KPI_STATUS_GRAPHIC\"),\n                trendGraphic: getPropertyValue(row, \"KPI_TREND_GRAPHIC\"),\n                description: getPropertyValue(row, \"KPI_DESCRIPTION\"),\n                groupName: getPropertyValue(row, \"MEASUREGROUP_NAME\"),\n                type: \"kpi\"\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseDimensions(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                caption: getPropertyValue(row, \"DIMENSION_CAPTION\"),\n                defaultHierarchy: getPropertyValue(row, \"DEFAULT_HIERARCHY\"),\n                description: getPropertyValue(row, \"DESCRIPTION\"),\n                name: getPropertyValue(row, \"DIMENSION_NAME\"),\n                type: parseInt(getPropertyValue(row, \"DIMENSION_TYPE\"), 10),\n                uniqueName: getPropertyValue(row, \"DIMENSION_UNIQUE_NAME\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseHierarchies(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"HIERARCHY_NAME\"),\n                caption: getPropertyValue(row, \"HIERARCHY_CAPTION\"),\n                description: getPropertyValue(row, \"DESCRIPTION\"),\n                uniqueName: getPropertyValue(row, \"HIERARCHY_UNIQUE_NAME\"),\n                dimensionUniqueName: getPropertyValue(row, \"DIMENSION_UNIQUE_NAME\"),\n                displayFolder: getPropertyValue(row, \"HIERARCHY_DISPLAY_FOLDER\"),\n                origin: getPropertyValue(row, \"HIERARCHY_ORIGIN\"),\n                defaultMember: getPropertyValue(row, \"DEFAULT_MEMBER\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseLevels(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"LEVEL_NAME\"),\n                caption: getPropertyValue(row, \"LEVEL_CAPTION\"),\n                description: getPropertyValue(row, \"DESCRIPTION\"),\n                uniqueName: getPropertyValue(row, \"LEVEL_UNIQUE_NAME\"),\n                dimensionUniqueName: getPropertyValue(row, \"DIMENSION_UNIQUE_NAME\"),\n                displayFolder: getPropertyValue(row, \"LEVEL_DISPLAY_FOLDER\"),\n                orderingProperty: getPropertyValue(row, \"LEVEL_ORDERING_PROPERTY\"),\n                origin: getPropertyValue(row, \"LEVEL_ORIGIN\"),\n                hierarchyUniqueName: getPropertyValue(row, \"HIERARCHY_UNIQUE_NAME\")\n            }); });\n            return rows;\n        }\n        /**\n         * @hidden\n         */\n        function parseMembers(response) {\n            var xmlDoc = new DOMParser().parseFromString(response, \"text/xml\");\n            var rows = Array.from(xmlDoc.querySelectorAll(\"DiscoverResponse > return > root > row\"))\n                .map(function (row) { return ({\n                name: getPropertyValue(row, \"MEMBER_NAME\"),\n                caption: getPropertyValue(row, \"MEMBER_CAPTION\"),\n                uniqueName: getPropertyValue(row, \"MEMBER_UNIQUE_NAME\"),\n                dimensionUniqueName: getPropertyValue(row, \"DIMENSION_UNIQUE_NAME\"),\n                hierarchyUniqueName: getPropertyValue(row, \"HIERARCHY_UNIQUE_NAME\"),\n                levelUniqueName: getPropertyValue(row, \"LEVEL_UNIQUE_NAME\"),\n                childrenCardinality: getPropertyValue(row, \"CHILDREN_CARDINALITY\")\n            }); });\n            return rows;\n        }\n\n        var discoverParser = {\n            schemaCatalogs: parseCatalogs,\n            schemaCubes: parseCubes,\n            schemaDimensions: parseDimensions,\n            schemaHierarchies: parseHierarchies,\n            schemaKPIs: parseKPIs,\n            schemaLevels: parseLevels,\n            schemaMeasures: parseMeasures,\n            schemaMembers: parseMembers\n        };\n        /**\n         * Fetches the data.\n         *\n         * @param options RequestOptions\n         * @returns Promise<ResponseData>\n         *\n         * @example\n         * const options: RequestOptions = { ... };\n         *\n         * fetchData(options).then(createDataState).then((dataState: DataState) => {\n         *  // Update the UI\n         * });\n         */\n        /**\n         * @hidden\n         */\n        var fetchData = function (fetchOptions, options) { return __awaiter(void 0, void 0, void 0, function () {\n            var init, response, stringResponse;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        init = __assign({ body: createRequestBody(options), headers: { 'Content-Type': 'text/xml' }, method: 'POST' }, fetchOptions.init);\n                        return [4 /*yield*/, fetch(fetchOptions.url, init)];\n                    case 1:\n                        response = _a.sent();\n                        return [4 /*yield*/, response.text()];\n                    case 2:\n                        stringResponse = _a.sent();\n                        return [2 /*return*/, parseResponse(stringResponse)];\n                }\n            });\n        }); };\n        /**\n         * @hidden\n         */\n        var fetchDiscover = function (fetchOptions, options) { return __awaiter(void 0, void 0, void 0, function () {\n            var init, response, stringResponse;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        init = __assign({ body: createDiscoverBody(options), headers: { 'Content-Type': 'text/xml' }, method: 'POST' }, fetchOptions.init);\n                        return [4 /*yield*/, fetch(fetchOptions.url, init)];\n                    case 1:\n                        response = _a.sent();\n                        return [4 /*yield*/, response.text()];\n                    case 2:\n                        stringResponse = _a.sent();\n                        return [2 /*return*/, discoverParser[options.command](stringResponse)];\n                }\n            });\n        }); };\n\n        /**\n         * Creates the state object. See `fetchData`.\n         *\n         * @param response - ResponseData\n         * @returns DataState\n         */\n        /**\n         * @hidden\n         */\n        var createDataState = function (response) {\n            var state = {\n                columns: response.columns.tuples,\n                data: response.data,\n                rows: response.rows.tuples\n            };\n            return state;\n        };\n\n        /**\n         * Creates a collection of AxisDescriptor base on the expandTree.\n         * @param expandTree - { [key: string]: boolean }\n         * @returns AxisDescriptor[]\n         *\n         * @example\n         * See `setRowExpand` or `setColumnExpand` functions.\n         */\n        /**\n         * @hidden\n         */\n        function createAxisDescriptors(expandTree) {\n            var descriptors = [];\n            for (var _i = 0, _a = Object.keys(expandTree); _i < _a.length; _i++) {\n                var key = _a[_i];\n                descriptors.push({ name: JSON.parse(key), expand: expandTree[key] });\n            }\n            return descriptors;\n        }\n\n        /**\n         * Sets sort descriptors to request options.\n         *\n         * @param options - RequestOptions\n         * @param sort - SortDescriptor[]\n         *\n         * @example\n         * const options: RequestOptions = { ... };\n         * const sort: SortDescriptor[] = [{ ... }, { ... }];\n         * setSort(options, sort);\n         * // skip the sort parameter to clear current filter - setSort(options);\n         *\n         * fetchData(options).then(createDataState).then((dataState: DataState) => {\n         *  // Update the UI\n         * });\n         */\n        /**\n         * @hidden\n         */\n        var setSort = function (options, sort) {\n            if (sort === void 0) { sort = []; }\n            options.sort = sort;\n        };\n\n        /**\n         * Sets filter descriptors to request options.\n         *\n         * @param options - RequestOptions\n         * @param filter - FilterDescriptor[]\n         *\n         * @example\n         * const options: RequestOptions = { ... };\n         * const filter: FilterDescriptor[] = [{ ... }, { ... }];\n         * setFilter(options, filter);\n         * // skip the filter parameter to clear current filter - setFilter(options);\n         *\n         * fetchData(options).then(createDataState).then((dataState: DataState) => {\n         *  // Update the UI\n         * });\n         */\n        /**\n         * @hidden\n         */\n        var setFilter = function (options, filter) {\n            if (filter === void 0) { filter = []; }\n            options.filter = filter;\n        };\n\n        // A typical tree depth count won't work for the Pivot,\n        // as each branch can have lower number of nodes than the total number of levels\n        /**\n         * @hidden\n         */\n        var getMaxNesting = function (node, set) {\n            if (set === void 0) { set = new Set(); }\n            (node.children || []).forEach(function (child) {\n                set.add(child.levelName);\n                getMaxNesting(child, set);\n            });\n            return set.size;\n        };\n        /**\n         * @hidden\n         */\n        var getMaxExpansion = function (node) {\n            var expanded = 0;\n            (node.children || []).forEach(function (child) {\n                expanded += (getMaxExpansion(child) || 1);\n            });\n            return expanded;\n        };\n        /**\n         * @hidden\n         */\n        var generateNormalizedPath = function (node, parent) {\n            return (parent && (parent.hierarchy === node.hierarchy)\n                ? __spreadArrays((parent.normalizedPath || []).slice(0, -1), [node.name || null]) : __spreadArrays(((parent && parent.normalizedPath) ? parent.normalizedPath : []), [node.name])).filter(Boolean);\n        };\n        /**\n         * @hidden\n         */\n        var generatePath = function (node, parent) {\n            return (parent && (parent.hierarchy === node.hierarchy)\n                ? __spreadArrays((parent.path || []).slice(0, -1), [((node.levelNum === 0 ? node.hierarchy : node.name) || null)]) : __spreadArrays(((parent && parent.path) ? parent.path : []), [node.levelNum === 0 ? node.hierarchy : node.name])).filter(Boolean);\n        };\n        /**\n         * @hidden\n         */\n        var toMatrix = function (node, rowIndex, colIndex, maxDepth, maxBreadth, matrix, leafs, parent) {\n            if (rowIndex === void 0) { rowIndex = -1; }\n            if (colIndex === void 0) { colIndex = 0; }\n            if (maxDepth === void 0) { maxDepth = undefined; }\n            if (maxBreadth === void 0) { maxBreadth = undefined; }\n            if (matrix === void 0) { matrix = undefined; }\n            if (leafs === void 0) { leafs = undefined; }\n            if (parent === void 0) { parent = undefined; }\n            var branchDepth = getMaxNesting(node);\n            var branchBreadth = getMaxExpansion(node);\n            var depth = maxDepth || branchDepth;\n            var breadth = maxBreadth || branchBreadth;\n            var matrixResult = matrix ? matrix.slice() : [];\n            var leafsResult = leafs ? leafs.slice() : new Array(breadth);\n            var index = matrixResult.findIndex(function (l) { return l && l.name === node.levelName && l.level === node.levelNum; });\n            var level = matrixResult[index];\n            var row = {\n                name: node.levelName,\n                level: node.levelNum,\n                index: rowIndex,\n                cells: new Array(breadth).fill(null)\n            };\n            var inject = rowIndex !== -1 && colIndex !== -1;\n            var cell = {\n                caption: node.caption,\n                name: node.name,\n                levelName: node.levelName,\n                levelNum: node.levelNum,\n                hasChildren: node.hasChildren,\n                parentName: node.parentName,\n                hierarchy: node.hierarchy,\n                total: (node.total !== undefined ? node.total : false) || (parent && parent.children.length <= 1 && parent.total),\n                parent: parent,\n                rowIndex: rowIndex,\n                colIndex: colIndex,\n                depth: 1,\n                breadth: 1,\n                path: node.path || [],\n                normalizedPath: node.normalizedPath || [],\n                children: node.children.filter(function (c) { return c.hierarchy === node.hierarchy; })\n            };\n            if (inject) {\n                if (level) {\n                    level.cells[colIndex] = cell;\n                    if (level.index >= rowIndex) {\n                        rowIndex = level.index;\n                    }\n                }\n                else {\n                    if (matrixResult[rowIndex] && matrixResult[rowIndex].cells.length) {\n                        for (var idx = rowIndex; idx < matrixResult.length; idx++) {\n                            var shiftedRow = matrixResult[idx];\n                            shiftedRow.index++;\n                        }\n                        matrixResult.splice(rowIndex, 0, row);\n                        matrixResult[rowIndex].cells[colIndex] = cell;\n                    }\n                    else {\n                        matrixResult[rowIndex] = row;\n                        matrixResult[rowIndex].cells[colIndex] = cell;\n                    }\n                }\n            }\n            var collOffset = 0;\n            if (node.children && node.children.length) {\n                node.children.forEach(function (child) {\n                    var _a = toMatrix(child, rowIndex + 1, colIndex + collOffset, depth, breadth, matrixResult, leafsResult, cell), newMatrix = _a[0], newLeafs = _a[1], childBreadth = _a[3];\n                    collOffset += (childBreadth || 1);\n                    matrixResult = newMatrix.slice();\n                    leafsResult = newLeafs.slice();\n                });\n            }\n            else if (node.normalizedPath) {\n                leafsResult[colIndex] = { total: cell.total, path: node.normalizedPath };\n            }\n            cell.depth = branchDepth;\n            cell.breadth = branchBreadth;\n            return [\n                matrixResult,\n                leafsResult,\n                branchDepth,\n                branchBreadth\n            ];\n        };\n        var withTotal = function (root, parent, index) {\n            if (parent === void 0) { parent = null; }\n            if (index === void 0) { index = 0; }\n            var hierarchy;\n            var alt = __assign(__assign({}, root), { total: true, hasChildren: false, children: [] });\n            for (var childIndex = 0; childIndex < root.children.length; childIndex++) {\n                var child = withTotal(root.children[childIndex], root, childIndex);\n                hierarchy = hierarchy || child.hierarchy;\n                if (child.hierarchy !== hierarchy\n                    && parent\n                    && !parent.children.some(function (c) { return c.total && c.name === alt.name; })\n                    && !root.total) {\n                    alt.children.push(child);\n                    root.children.splice(childIndex, 1);\n                    childIndex--;\n                }\n            }\n            if (root.children.filter(function (c) { return !c.total; }).length >= 1\n                && parent\n                && !parent.children.some(function (c) { return c.total && c.name === alt.name; })\n                && !root.total) {\n                var childHierarchy = root.children[0].hierarchy;\n                if (root.hierarchy === childHierarchy) {\n                    parent.children.splice(index + 1, 0, alt);\n                }\n            }\n            return root;\n        };\n        /**\n         * @hidden\n         */\n        var toTree = function (tuples) {\n            var root = { children: [] };\n            var map = {};\n            for (var tupleIndex = 0; tupleIndex < tuples.length; tupleIndex++) {\n                var tuple = copy(tuples[tupleIndex]);\n                var key = \"\";\n                var _loop_1 = function (memberIndex) {\n                    var member = tuple.members[memberIndex];\n                    var parent_1;\n                    if (root.children && root.children.length === 0) {\n                        parent_1 = root;\n                    }\n                    else if (map[key] && !map[key + member.name] && member.levelNum === 0) {\n                        parent_1 = map[key];\n                    }\n                    else if (map[key + member.parentName] && member.levelNum > 0 && !map[key + member.parentName + member.name]) {\n                        parent_1 = map[key + member.parentName];\n                    }\n                    else if (!map[key + member.parentName] && member.levelNum > 0 && !map[key + member.parentName + member.name]) {\n                        var parentKey = Object.keys(map).find(function (e) { return member.parentName === map[e].name; });\n                        if (parentKey) {\n                            parent_1 = map[parentKey];\n                        }\n                    }\n                    if (parent_1) {\n                        member.path = generatePath(member, parent_1);\n                        member.normalizedPath = generateNormalizedPath(member, parent_1);\n                        var intruderIndex = parent_1.children.findIndex(function (c) { return c.hierarchy !== parent_1.hierarchy; });\n                        if (intruderIndex !== -1) {\n                            parent_1.children.splice(intruderIndex, 0, member);\n                        }\n                        else {\n                            parent_1.children.push(member);\n                        }\n                    }\n                    member.parentName += member.name;\n                    key += member.parentName;\n                    if (!map[key]) {\n                        map[key] = member;\n                    }\n                };\n                for (var memberIndex = 0; memberIndex < tuple.members.length; memberIndex++) {\n                    _loop_1(memberIndex);\n                }\n            }\n            return copy(withTotal(root));\n        };\n        /**\n         * @hidden\n         */\n        var toData = function (data, columns, rows, breadth, depth) {\n            var result = Array.from(new Array(depth), function () { return ({ cells: Array.from(new Array(breadth), function () { return null; }) }); });\n            var hash = function (names) { return names.join('|'); };\n            var membersNames = function (tuple) { return tuple.members.map(function (m) { return m.name; }); };\n            var columnsIndexes = new Map();\n            var rowsIndexes = new Map();\n            columns.forEach(function (colMembers, idx) { columnsIndexes.set(hash(colMembers.path), idx); });\n            rows.forEach(function (rowMembers, idx) { rowsIndexes.set(hash(rowMembers.path), idx); });\n            data.forEach(function (item) {\n                var colIndex = columnsIndexes.get(hash(membersNames(item.columnTuple)));\n                var rowIndex = rowsIndexes.get(hash(membersNames(item.rowTuple)));\n                if (colIndex !== undefined && rowIndex !== undefined) {\n                    if (!result[rowIndex].cells[colIndex]) {\n                        result[rowIndex].row = rows[rowIndex].path;\n                        result[rowIndex].cells[colIndex] = item;\n                    }\n                }\n            });\n            return result;\n        };\n        var rotateMatrix = function (matrix, leafs, depth, breadth) {\n            var result = new Array(breadth);\n            for (var colIndex = 0; colIndex < breadth; colIndex++) {\n                for (var rowIndex = 0; rowIndex < depth; rowIndex++) {\n                    if (matrix[rowIndex] && matrix[rowIndex].cells[colIndex]) {\n                        var cell = matrix[rowIndex].cells[colIndex];\n                        if (!result[colIndex]) {\n                            result[colIndex] = {\n                                cells: new Array(depth).fill(null)\n                            };\n                        }\n                        result[colIndex].cells[rowIndex] = __assign(__assign({}, cell), { rowSpan: cell.colSpan, colSpan: cell.rowSpan });\n                    }\n                }\n            }\n            return [result, leafs, breadth, depth];\n        };\n        /**\n         * @hidden\n         */\n        var toColumns = function (root) {\n            var _a = toMatrix(root), matrix = _a[0], leafs = _a[1], depth = _a[2], breadth = _a[3];\n            for (var colIndex = 0; colIndex < breadth; colIndex++) {\n                var cell = null;\n                for (var rowIndex = 0; rowIndex < depth; rowIndex++) {\n                    if (matrix[rowIndex]) {\n                        var next = matrix[rowIndex].cells[colIndex];\n                        if (!next && cell) {\n                            cell.rowSpan = (cell.rowSpan || 1) + 1;\n                        }\n                        if (cell) {\n                            cell.colSpan = cell.breadth || 1;\n                        }\n                        if (next) {\n                            cell = next;\n                        }\n                    }\n                }\n            }\n            return [matrix, leafs, depth, breadth];\n        };\n        /**\n         * @hidden\n         */\n        var toRows = function (root) {\n            var _a = toMatrix(root), matrix = _a[0], leafs = _a[1], depth = _a[2], breadth = _a[3];\n            for (var colIndex = 0; colIndex < breadth; colIndex++) {\n                var cell = null;\n                for (var rowIndex = 0; rowIndex < depth; rowIndex++) {\n                    if (matrix[rowIndex]) {\n                        var next = matrix[rowIndex].cells[colIndex];\n                        if (!next && cell) {\n                            cell.rowSpan = (cell.rowSpan || 1) + 1;\n                        }\n                        if (cell) {\n                            cell.colSpan = cell.breadth;\n                        }\n                        if (next) {\n                            cell = next;\n                        }\n                    }\n                }\n            }\n            return rotateMatrix(matrix, leafs, depth, breadth);\n        };\n        /**\n         * @hidden\n         */\n        function copy(obj) {\n            return JSON.parse(JSON.stringify(obj));\n        }\n        var kpiMeasure = function (name, measure, type) {\n            return {\n                hierarchyUniqueName: name,\n                uniqueName: measure,\n                caption: measure,\n                measure: measure,\n                name: measure,\n                type: type,\n                kpi: true\n            };\n        };\n        /**\n         * @hidden\n         */\n        function buildKPIMeasures(node) {\n            var name = node.name;\n            return [\n                kpiMeasure(name, node.value, \"value\"),\n                kpiMeasure(name, node.goal, \"goal\"),\n                kpiMeasure(name, node.status, \"status\"),\n                kpiMeasure(name, node.trend, \"trend\")\n            ];\n        }\n        /**\n         * @hidden\n         */\n        var addKPI = function (data) {\n            var found;\n            var idx = 0;\n            for (; idx < data.length; idx++) {\n                if (data[idx].type === 2) {\n                    found = true;\n                    break;\n                }\n            }\n            if (found) {\n                data.splice(idx + 1, 0, {\n                    caption: \"KPIs\",\n                    defaultHierarchy: \"[KPIs]\",\n                    name: \"KPIs\",\n                    uniqueName: \"[KPIs]\"\n                });\n            }\n        };\n        /**\n         * @hidden\n         */\n        var compareAxisWithField = function (a, b) { return String(a.name) === String([(b.defaultHierarchy\n                ? b.defaultHierarchy\n                : b.uniqueName)]); };\n        /**\n         * @hidden\n         */\n        var compareAxes = function (a, b) { return String(a.name) === String(b.name); };\n        /**\n         * @hidden\n         */\n        var filterField = function (axes, out) {\n            var _loop_2 = function (i) {\n                var axis = axes[i];\n                var index = axis.name.findIndex(function (name) { return compareAxisWithField({ name: [name] }, out) || String(name).startsWith(out.uniqueName); });\n                if (index !== -1) {\n                    if (index === axis.name.length - 1 || axis.name.length === 1) {\n                        axes.splice(i, 1);\n                    }\n                    else {\n                        axis.name.splice(index, 1);\n                        var duplicatedAxisIndex = axes.findIndex(function (ax) { return ax !== axis && String(ax.name) === String(axis.name); });\n                        if (duplicatedAxisIndex !== -1) {\n                            axes[duplicatedAxisIndex] = __assign(__assign(__assign({}, axes[duplicatedAxisIndex]), axis), ((axes[duplicatedAxisIndex].expand || axis.expand) ? { expand: true } : {}));\n                            axes.splice(i, 1);\n                        }\n                    }\n                }\n            };\n            for (var i = axes.length - 1; i >= 0; i--) {\n                _loop_2(i);\n            }\n        };\n        /**\n         * @hidden\n         */\n        var insertAxis = function (axes, toInsert, state) {\n            var index = -1;\n            if (state.dropTarget && state.dropDirection) {\n                var offset = state.dropDirection\n                    ? (state.dropDirection === 'before'\n                        ? 0\n                        : 1)\n                    : 0;\n                index = axes.findIndex(function (c) { return compareAxes(c, state.dropTarget); }) + offset;\n            }\n            if (index !== -1) {\n                axes.forEach(function (axis) {\n                    var _a;\n                    if (axis.expand && axis.name.length > 1 && axis.name.length > index) {\n                        (_a = axis.name).splice.apply(_a, __spreadArrays([index, 0], toInsert.name));\n                    }\n                });\n                axes.splice(index, 0, toInsert);\n            }\n            else {\n                axes.push(toInsert);\n            }\n        };\n\n        /**\n         * @hidden\n         */\n        exports.HEADERS_ACTION = void 0;\n        (function (HEADERS_ACTION) {\n            HEADERS_ACTION[\"toggle\"] = \"HEADERS_ACTION_TOGGLE\";\n            HEADERS_ACTION[\"expand\"] = \"HEADERS_ACTION_EXPAND\";\n            HEADERS_ACTION[\"collapse\"] = \"HEADERS_ACTION_COLLAPSE\";\n        })(exports.HEADERS_ACTION || (exports.HEADERS_ACTION = {}));\n        var findPath = function (node, matchFn, matched) {\n            var result = new Set();\n            node.children.forEach(function (child) {\n                var match = matchFn(child);\n                if (matched) {\n                    result.add(String(child.path));\n                }\n                findPath(child, matchFn, (matched || match)).map(function (h) {\n                    result.add(h);\n                });\n            });\n            return Array.from(result.values());\n        };\n        /**\n         * @hidden\n         */\n        var headersReducer = function (state, action) {\n            switch (action.type) {\n                case exports.HEADERS_ACTION.toggle: {\n                    var existing = state.find((function (s) { return String(s.name) === String(action.payload); }));\n                    return headersReducer(state, __assign(__assign({}, action), { type: existing && (existing.expand)\n                            ? exports.HEADERS_ACTION.collapse\n                            : exports.HEADERS_ACTION.expand }));\n                }\n                case exports.HEADERS_ACTION.expand: {\n                    var existing_1 = state.find((function (s) { return String(s.name) === String(action.payload); }));\n                    if (existing_1 && existing_1.expand === true) {\n                        return state;\n                    }\n                    else if (existing_1 && (existing_1.expand === false || existing_1.expand === undefined)) {\n                        return state.map(function (s) { return s === existing_1 ? (__assign(__assign({}, existing_1), { expand: true })) : s; });\n                    }\n                    else {\n                        var nextState = state.slice();\n                        nextState.push({ name: action.payload, expand: true });\n                        return nextState;\n                    }\n                }\n                case exports.HEADERS_ACTION.collapse: {\n                    var filtered_1 = findPath(action.tree, function (node) { return !node.total && String(node.path) === String(action.payload); });\n                    var newState = state.slice()\n                        .filter(function (h) { return !filtered_1.some(function (f) { return f === String(h.name); }); })\n                        .map(function (h) { return (__assign(__assign({}, h), { expand: Boolean(h.expand) })); })\n                        .map(function (h) { return (String(h.name) === String(action.payload))\n                        ? action.payload.length > 1 ? undefined : { name: action.payload, expand: false }\n                        : h; })\n                        .filter(Boolean);\n                    return newState;\n                }\n                default: {\n                    return state;\n                }\n            }\n        };\n\n        /**\n         * @hidden\n         */\n        exports.PIVOT_CONFIGURATOR_ACTION = void 0;\n        (function (PIVOT_CONFIGURATOR_ACTION) {\n            // Selection\n            PIVOT_CONFIGURATOR_ACTION[\"toggleSelection\"] = \"PIVOT_CONFIGURATOR_ACTION_TOGGLE_SELECTION\";\n            PIVOT_CONFIGURATOR_ACTION[\"addColumnAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_COLUMN_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"addColumnAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_COLUMN_AXES\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeColumnAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_COLUMN_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeColumnAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_COLUMN_AXES\";\n            PIVOT_CONFIGURATOR_ACTION[\"addRowAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_ROW_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"addRowAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_ROW_AXES\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeRowAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_ROW_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeRowAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_ROW_AXES\";\n            PIVOT_CONFIGURATOR_ACTION[\"addMeasureAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_MEASURE_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"addMeasureAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_MEASURE_AXES\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeMeasureAxis\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_MEASURE_AXIS\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeMeasureAxes\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_MEASURE_AXES\";\n            // Removal\n            PIVOT_CONFIGURATOR_ACTION[\"remove\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE\";\n            // Sort\n            PIVOT_CONFIGURATOR_ACTION[\"setSort\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_SORT\";\n            // Filter\n            PIVOT_CONFIGURATOR_ACTION[\"setFilter\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_FILTER\";\n            PIVOT_CONFIGURATOR_ACTION[\"addFilter\"] = \"PIVOT_CONFIGURATOR_ACTION_ADD_FILTER\";\n            PIVOT_CONFIGURATOR_ACTION[\"changeFilter\"] = \"PIVOT_CONFIGURATOR_ACTION_CHANGE_FILTER\";\n            PIVOT_CONFIGURATOR_ACTION[\"removeFilter\"] = \"PIVOT_CONFIGURATOR_ACTION_REMOVE_FILTER\";\n            // Drag\n            PIVOT_CONFIGURATOR_ACTION[\"setDragItem\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_DRAGITEM\";\n            PIVOT_CONFIGURATOR_ACTION[\"drop\"] = \"PIVOT_CONFIGURATOR_ACTION_DROP\";\n            PIVOT_CONFIGURATOR_ACTION[\"setDropZone\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_DROP_ZONE\";\n            PIVOT_CONFIGURATOR_ACTION[\"setDropTarget\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_DROP_TARGET\";\n            PIVOT_CONFIGURATOR_ACTION[\"setDropDirection\"] = \"PIVOT_CONFIGURATOR_ACTION_SET_DROP_DIRECTION\";\n        })(exports.PIVOT_CONFIGURATOR_ACTION || (exports.PIVOT_CONFIGURATOR_ACTION = {}));\n        /**\n         * @hidden\n         */\n        var configuratorReducer = function (state, action) {\n            var newRows;\n            var newColumns;\n            var newMeasures;\n            var newSort;\n            var newFilter;\n            var newDragitem;\n            var newDropZone;\n            var newDropDirection;\n            var newDropTarget;\n            switch (action.type) {\n                case exports.PIVOT_CONFIGURATOR_ACTION.toggleSelection: {\n                    if (Array.isArray(action.payload)) { ; }\n                    else {\n                        var payload_1 = action.payload;\n                        if (payload_1.type === 2 || 'aggregator' in payload_1) {\n                            if (state.measureAxes.some(function (s) { return compareAxisWithField(s, payload_1); })) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis }));\n                            }\n                            else {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis }));\n                            }\n                        }\n                        else if (payload_1.type === 'kpi') {\n                            var measures = buildKPIMeasures(payload_1);\n                            if (measures.every(function (m) { return state.measureAxes.some(function (s) { return compareAxisWithField(s, m); }); })) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxes, payload: measures }));\n                            }\n                            else {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxes, payload: measures.filter(function (m) { return !state.measureAxes.some(function (s) { return compareAxisWithField(s, m); }); }) }));\n                            }\n                        }\n                        else if (action.payload.kpi) {\n                            if (state.measureAxes.some(function (s) { return compareAxisWithField(s, payload_1); })) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis }));\n                            }\n                            else {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis }));\n                            }\n                        }\n                        else {\n                            if (state.columnAxes.some(function (s) { return compareAxisWithField(s, payload_1); })) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxis }));\n                            }\n                            else if (state.rowAxes.some(function (s) { return compareAxisWithField(s, payload_1); })) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxis }));\n                            }\n                            else if ((state.columnAxes && state.columnAxes.length) && (!state.rowAxes || !state.rowAxes.length)) {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addRowAxis }));\n                            }\n                            else {\n                                return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addColumnAxis }));\n                            }\n                        }\n                    }\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addColumnAxis: {\n                    newColumns = __spreadArrays((state.columnAxes || []), [\n                        { name: [action.payload.defaultHierarchy || action.payload.uniqueName] }\n                    ]);\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addColumnAxes: {\n                    // TODO;\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxis: {\n                    newColumns = __spreadArrays((state.columnAxes || []).filter(function (s) { return !compareAxisWithField(s, action.payload); }));\n                    filterField(newColumns, action.payload);\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxes: {\n                    // TODO;\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addRowAxis: {\n                    newRows = __spreadArrays((state.rowAxes || []), [\n                        { name: [action.payload.defaultHierarchy || action.payload.uniqueName] }\n                    ]);\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addRowAxes: {\n                    // TODO;\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxis: {\n                    newRows = __spreadArrays((state.rowAxes || []).filter(function (s) { return !compareAxisWithField(s, action.payload); }));\n                    filterField(newRows, action.payload);\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxes: {\n                    // TODO;\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis: {\n                    newMeasures = __spreadArrays((state.measureAxes || []), [\n                        { name: [action.payload.defaultHierarchy || action.payload.uniqueName] }\n                    ]);\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis: {\n                    newMeasures = __spreadArrays((state.measureAxes || []).filter(function (s) { return !compareAxisWithField(s, action.payload); }));\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxes: {\n                    newMeasures = __spreadArrays((state.measureAxes || []), (action.payload || []).map(function (p) { return ({ name: [p.defaultHierarchy || p.uniqueName] }); }));\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxes: {\n                    newMeasures = __spreadArrays((state.measureAxes || []).filter(function (s) { return !action.payload.some(function (p) { return compareAxisWithField(s, p); }); }));\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.remove: {\n                    if (state.columnAxes.some(function (s) { return compareAxes(s, action.payload); })) {\n                        newColumns = __spreadArrays(state.columnAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                        filterField(newColumns, { uniqueName: action.payload.name });\n                    }\n                    if (state.rowAxes.some(function (s) { return compareAxes(s, action.payload); })) {\n                        newRows = __spreadArrays(state.rowAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                        filterField(newRows, { uniqueName: action.payload.name });\n                    }\n                    if (state.measureAxes.some(function (s) { return compareAxes(s, action.payload); })) {\n                        newMeasures = __spreadArrays(state.measureAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                    }\n                    break;\n                }\n                case exports.PIVOT_CONFIGURATOR_ACTION.setDragItem:\n                    newDragitem = action.payload;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.setDropZone:\n                    newDropZone = action.payload;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.setDropTarget:\n                    newDropTarget = action.payload;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.setDropDirection:\n                    newDropDirection = action.payload;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.drop:\n                    if (state.dragItem && state.dropZone) {\n                        var currentColumn = state.columnAxes.find(function (s) { return compareAxes(s, action.payload); });\n                        var currentRow = state.rowAxes.find(function (s) { return compareAxes(s, action.payload); });\n                        var currentMeasure = state.measureAxes.find(function (s) { return compareAxes(s, action.payload); });\n                        var current = void 0;\n                        if (currentColumn) {\n                            current = currentColumn;\n                            newColumns = __spreadArrays(state.columnAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                            filterField(newColumns, { uniqueName: action.payload.name });\n                        }\n                        if (currentRow) {\n                            current = currentRow;\n                            newRows = __spreadArrays(state.rowAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                            filterField(newRows, { uniqueName: action.payload.name });\n                        }\n                        if (currentMeasure) {\n                            current = currentMeasure;\n                            newMeasures = __spreadArrays(state.measureAxes.filter(function (s) { return !compareAxes(s, action.payload); }));\n                        }\n                        switch (state.dropZone) {\n                            case 'columnAxes': {\n                                newColumns = newColumns || state.columnAxes.slice();\n                                insertAxis(newColumns, current, state);\n                                break;\n                            }\n                            case 'rowAxes': {\n                                newRows = newRows || state.rowAxes.slice();\n                                insertAxis(newRows, current, state);\n                                break;\n                            }\n                            case 'measureAxes': {\n                                newMeasures = newMeasures || state.measureAxes.slice();\n                                insertAxis(newMeasures, current, state);\n                                break;\n                            }\n                        }\n                    }\n                    newDragitem = null;\n                    newDropZone = null;\n                    newDropTarget = null;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.setSort:\n                    newSort = action.payload;\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.setFilter:\n                    if (Array.isArray(action.payload)) {\n                        newFilter = action.payload;\n                    }\n                    else {\n                        newFilter = [action.payload];\n                    }\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.addFilter:\n                    newFilter = (state.filter || []).slice();\n                    if (Array.isArray(action.payload)) {\n                        newFilter.push.apply(newFilter, action.payload);\n                    }\n                    else {\n                        newFilter.push(action.payload);\n                    }\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.changeFilter:\n                    newFilter = (Array.isArray(action.payload)\n                        ? (state.filter || []).map(function (f) { return action.payload.some(function (a) { return a.field === f.field; })\n                            ? action.payload.find(function (a) { return a.field === f.field; })\n                            : f; })\n                        : (state.filter || []).map(function (f) { return f.field === action.payload.field\n                            ? action.payload\n                            : f; }));\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeFilter:\n                    newFilter = (state.filter || []).slice();\n                    if (Array.isArray(action.payload)) {\n                        newFilter = newFilter.filter(function (f) { return !action.payload.some(function (p) { return p.field === f.field &&\n                            p.operator === f.operator; }); });\n                    }\n                    else {\n                        newFilter = newFilter.filter(function (f) { return !(f.field === action.payload.field\n                            && f.operator === action.payload.operator); });\n                    }\n                    break;\n            }\n            return {\n                dragItem: newDragitem,\n                dropTarget: newDropTarget,\n                dropDirection: newDropDirection,\n                dropZone: newDropZone,\n                columnAxes: newColumns,\n                rowAxes: newRows,\n                measureAxes: newMeasures,\n                filter: newFilter,\n                sort: newSort\n            };\n        };\n\n        // tslint:disable:object-literal-sort-keys\n        /**\n         * Represents the aggregate object which calculates the total value. Applicable for local data binding.\n         */\n        var sumAggregate = {\n            init: function (data) {\n                if (('sum' in data) === false) {\n                    data.sum = 0;\n                }\n            },\n            merge: function (src, dest) {\n                dest.sum += src.sum;\n            },\n            accumulate: function (acc, value) {\n                acc.sum += value;\n            },\n            result: function (data) { return data.sum; },\n            format: function (value) { return value.toFixed(2); }\n        };\n        /**\n         * Represents the aggregate object which calculates the minimum value. Applicable for local data binding.\n         */\n        var minAggregate = {\n            init: function (data) {\n                if (('min' in data) === false) {\n                    data.min = Number.POSITIVE_INFINITY;\n                }\n            },\n            merge: function (src, dest) {\n                dest.min = Math.min(src.min, dest.min);\n            },\n            accumulate: function (acc, value) {\n                acc.min = Math.min(value, acc.min);\n            },\n            result: function (data) { return Number.isFinite(data.min) ? data.min : NaN; },\n            format: function (value) { return value.toFixed(2); }\n        };\n        /**\n         * Represents the aggregate object which calculates the maximum value. Applicable for local data binding.\n         */\n        var maxAggregate = {\n            init: function (data) {\n                if (('max' in data) === false) {\n                    data.max = Number.NEGATIVE_INFINITY;\n                }\n            },\n            merge: function (src, dest) {\n                dest.max = Math.max(src.max, dest.max);\n            },\n            accumulate: function (acc, value) {\n                acc.max = Math.max(value, acc.max);\n            },\n            result: function (data) { return Number.isFinite(data.max) ? data.max : NaN; },\n            format: function (value) { return value.toFixed(2); }\n        };\n        /**\n         * Represents the aggregate object which calculates the average value. Applicable for local data binding.\n         */\n        var averageAggregate = {\n            init: function (data) {\n                if (('count' in data) === false) {\n                    data.sumA = 0;\n                    data.count = 0;\n                }\n            },\n            merge: function (src, dest) {\n                dest.sumA += src.sumA;\n                dest.count += src.count;\n            },\n            accumulate: function (acc, value) {\n                acc.sumA += value;\n                acc.count += 1;\n            },\n            result: function (data) { return data.sumA / data.count; },\n            format: function (value) { return value.toFixed(2); }\n        };\n\n        /**\n         * @hidden\n         */\n        var isPresent = function (value) { return value !== null && value !== undefined; };\n        /**\n         * @hidden\n         */\n        var isBlank = function (value) { return value === null || value === undefined; };\n        /**\n         * @hidden\n         */\n        var isArray = function (value) { return Array.isArray(value); };\n        /**\n         * @hidden\n         */\n        var isFunction = function (value) { return typeof value === 'function'; };\n        /**\n         * @hidden\n         */\n        var isString = function (value) { return typeof value === 'string'; };\n        /**\n         * @hidden\n         */\n        var isNullOrEmptyString = function (value) { return isBlank(value) || value.trim().length === 0; };\n        /**\n         * @hidden\n         */\n        var isNotNullOrEmptyString = function (value) { return !isNullOrEmptyString(value); };\n        /**\n         * @hidden\n         */\n        var isNumeric = function (value) { return !isNaN(value - parseFloat(value)); };\n        /**\n         * @hidden\n         */\n        var isDate = function (value) { return value && value.getTime; };\n\n        // tslint:enable:max-line-length\n        /**\n         * @hidden\n         * Type guard for `CompositeFilterDescriptor`.\n         */\n        var isCompositeFilterDescriptor = function (source) {\n            return isPresent(source.filters);\n        };\n\n        /**\n         * @hidden\n         */\n        var ifElse = function (predicate, right, left) { return function (value) { return predicate(value) ? right(value) : left(value); }; };\n        /**\n         * @hidden\n         * Performs the right-to-left function composition. Functions should have a unary.\n         */\n        var compose = function () {\n            var arguments$1 = arguments;\n\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments$1[_i];\n            }\n            return function (data) { return args.reduceRight(function (acc, curr) { return curr(acc); }, data); };\n        };\n\n        /**\n         * @hidden\n         */\n        var toUTC = function (date) {\n            return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));\n        };\n        /**\n         * @hidden\n         */\n        var isDateValue = function (x) { return isDate(x.value); };\n\n        var getterCache = {};\n        var FIELD_REGEX = /\\[(?:(\\d+)|['\"](.*?)['\"])\\]|((?:(?!\\[.*?\\]|\\.).)+)/g;\n        // tslint:disable-next-line:no-string-literal\n        getterCache['undefined'] = function (obj) { return obj; };\n        /**\n         * @hidden\n         */\n        var getter = function (field, safe) {\n            var key = field + safe;\n            if (getterCache[key]) {\n                return getterCache[key];\n            }\n            var fields = [];\n            field.replace(FIELD_REGEX, function (_, index, indexAccessor, field) {\n                fields.push(isPresent(index) ? index : (indexAccessor || field));\n                return undefined;\n            });\n            getterCache[key] = function (obj) {\n                var result = obj;\n                for (var idx = 0; idx < fields.length; idx++) {\n                    result = result[fields[idx]];\n                    if (!isPresent(result) && safe) {\n                        return result;\n                    }\n                }\n                return result;\n            };\n            return getterCache[key];\n        };\n\n        var pairwise = function (key) { return function (value) { return [key, value]; }; };\n        var empty = function () { return null; };\n        var isNotEmptyArray = function (value) { return isPresent(value) && isArray(value) && value.length > 0; };\n        var isNotEmpty = function (accessor) { return function (value) { return isNotEmptyArray(accessor(value)); }; };\n        var runOrEmpty = function (predicate, fn) { return ifElse(predicate, fn, empty); };\n        var calcPage = function (_a) {\n            var skip = _a.skip, take = _a.take;\n            return Math.floor((skip || 0) / take) + 1;\n        };\n        var formatDescriptors = function (accessor, formatter) { return function (state) { return (accessor(state).map(formatter).join(\"~\")); }; };\n        var removeAfter = function (what) { return function (str) { return str.slice(0, str.indexOf(what)); }; };\n        var replace = function (patterns) {\n            return compose.apply(void 0, patterns.map(function (_a) {\n                var left = _a[0], right = _a[1];\n                return function (s) { return s.replace(new RegExp(left, \"g\"), right); };\n            }));\n        };\n        var sanitizeDateLiterals = replace([[\"\\\"\", \"\"], [\":\", \"-\"]]);\n        var removeAfterDot = removeAfter(\".\");\n        var directionFormatter = function (_a) {\n            var field = _a.field, _b = _a.dir, dir = _b === void 0 ? \"asc\" : _b;\n            return field + \"-\" + dir;\n        };\n        var aggregateFormatter = function (_a) {\n            var field = _a.field, aggregate = _a.aggregate;\n            return field + \"-\" + aggregate;\n        };\n        var take = getter(\"take\");\n        var aggregates = getter(\"aggregates\");\n        getter(\"skip\");\n        var group = getter(\"group\");\n        var sort = getter(\"sort\", true);\n        var formatSort = formatDescriptors(sort, directionFormatter);\n        var formatGroup = formatDescriptors(group, directionFormatter);\n        var formatAggregates = formatDescriptors(aggregates, aggregateFormatter);\n        var prefixDateValue = function (value) { return \"datetime'\" + value + \"'\"; };\n        var formatDateValue = compose(prefixDateValue, removeAfterDot, sanitizeDateLiterals, JSON.stringify, toUTC);\n        var formatDate = function (_a) {\n            var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n            return ({\n                value: formatDateValue(value),\n                field: field,\n                ignoreCase: ignoreCase,\n                operator: operator\n            });\n        };\n        var normalizeSort = function (state) { return Object.assign({}, state, {\n            sort: (sort(state) || []).filter(function (_a) {\n                var dir = _a.dir;\n                return isNotNullOrEmptyString(dir);\n            })\n        }); };\n        compose(pairwise('page'), calcPage);\n        compose(pairwise('pageSize'), take);\n        compose(pairwise('group'), formatGroup);\n        var transformSort = compose(pairwise('sort'), formatSort);\n        compose(pairwise('aggregate'), formatAggregates);\n        compose(runOrEmpty(isNotEmpty(sort), transformSort), normalizeSort);\n        var filterFormatter = function (_a) {\n            var field = _a.field, operator = _a.operator, value = _a.value;\n            return field + \"~\" + operator + \"~\" + value;\n        };\n        ifElse(isDateValue, compose(filterFormatter, formatDate), filterFormatter);\n\n        // tslint:enable:max-line-length\n        var set = function (field, target, value) {\n            target[field] = value;\n            return target;\n        };\n        var convert = function (mapper) { return function (values) { return Object.keys(values).reduce(mapper.bind(null, values), {}); }; };\n        var translateAggregate = convert(function (source, acc, field) { return set(field.toLowerCase(), acc, source[field]); });\n        var translateAggregates = convert(function (source, acc, field) { return set(field, acc, translateAggregate(source[field])); });\n        var valueOrDefault = function (value, defaultValue) { return isPresent(value) ? value : defaultValue; };\n        var normalizeGroup = function (group) { return ({\n            aggregates: group.Aggregates || group.aggregates,\n            field: group.Member || group.member || group.field,\n            hasSubgroups: group.HasSubgroups || group.hasSubgroups || false,\n            items: group.Items || group.items,\n            value: valueOrDefault(group.Key, valueOrDefault(group.key, group.value))\n        }); };\n        var translateGroup = compose(function (_a) {\n            var field = _a.field, hasSubgroups = _a.hasSubgroups, value = _a.value, aggregates = _a.aggregates, items = _a.items;\n            return ({\n                aggregates: translateAggregates(aggregates),\n                field: field,\n                items: hasSubgroups ? items.map(translateGroup) : items,\n                value: value\n            });\n        }, normalizeGroup);\n\n        var logic = {\n            \"or\": {\n                concat: function (acc, fn) { return function (a) { return acc(a) || fn(a); }; },\n                identity: function () { return false; }\n            },\n            \"and\": {\n                concat: function (acc, fn) { return function (a) { return acc(a) && fn(a); }; },\n                identity: function () { return true; }\n            }\n        };\n        var operatorsMap = {\n            contains: function (a, b) { return (a || \"\").indexOf(b) >= 0; },\n            doesnotcontain: function (a, b) { return (a || \"\").indexOf(b) === -1; },\n            doesnotendwith: function (a, b) { return (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) < 0; },\n            doesnotstartwith: function (a, b) { return (a || \"\").lastIndexOf(b, 0) === -1; },\n            endswith: function (a, b) { return (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) >= 0; },\n            eq: function (a, b) { return a === b; },\n            gt: function (a, b) { return a > b; },\n            gte: function (a, b) { return a >= b; },\n            isempty: function (a) { return a === ''; },\n            isnotempty: function (a) { return a !== ''; },\n            isnotnull: function (a) { return isPresent(a); },\n            isnull: function (a) { return isBlank(a); },\n            lt: function (a, b) { return a < b; },\n            lte: function (a, b) { return a <= b; },\n            neq: function (a, b) { return a != b; },\n            startswith: function (a, b) { return (a || \"\").lastIndexOf(b, 0) === 0; }\n        };\n        var dateRegExp = /^\\/Date\\((.*?)\\)\\/$/;\n        var convertValue = function (value, ignoreCase) {\n            if (value != null && isString(value)) {\n                var date = dateRegExp.exec(value);\n                if (date) {\n                    return new Date(+date[1]).getTime();\n                }\n                else if (ignoreCase) {\n                    return value.toLowerCase();\n                }\n            }\n            else if (value != null && isDate(value)) {\n                return value.getTime();\n            }\n            return value;\n        };\n        var typedGetter = function (prop, value, ignoreCase) {\n            if (!isPresent(value)) {\n                return prop;\n            }\n            var acc = prop;\n            if (isString(value)) {\n                var date = dateRegExp.exec(value);\n                if (date) {\n                    value = new Date(+date[1]);\n                }\n                else {\n                    acc = function (a) {\n                        var x = prop(a);\n                        if (typeof x === 'string' && ignoreCase) {\n                            return x.toLowerCase();\n                        }\n                        else {\n                            return isNumeric(x) ? x + \"\" : x;\n                        }\n                    };\n                }\n            }\n            if (isDate(value)) {\n                return function (a) {\n                    var x = acc(a);\n                    return isDate(x) ? x.getTime() : x;\n                };\n            }\n            return acc;\n        };\n        var transformFilter = function (_a) {\n            var field = _a.field, ignoreCase = _a.ignoreCase, value = _a.value, operator = _a.operator;\n            field = !isPresent(field) ? function (a) { return a; } : field;\n            ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;\n            var itemProp = typedGetter(isFunction(field) ? field : getter(field, true), value, ignoreCase);\n            value = convertValue(value, ignoreCase);\n            var op = isFunction(operator) ? operator : operatorsMap[operator];\n            return function (a) { return op(itemProp(a), value, ignoreCase); };\n        };\n        /**\n         * @hidden\n         */\n        var transformCompositeFilter = function (filter) {\n            var combiner = logic[filter.logic];\n            return filter.filters\n                .filter(isPresent)\n                .map(function (x) { return isCompositeFilterDescriptor(x) ? transformCompositeFilter(x) : transformFilter(x); })\n                .reduce(combiner.concat, combiner.identity);\n        };\n\n        // tslint:disable:max-line-length\n        /**\n         * Creates a [Predicate]({% slug api_kendo-data-query_predicate %}) function for the specified [CompositeFilterDescriptor]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n         *\n         * @param {CompositeFilterDescriptor} descriptor - The descriptor for which the predicate is created.\n         * @returns {Predicate} - The created function instance.\n         *\n         * @example\n         * ```ts\n         * import { compileFilter } from '@progress/kendo-data-query';\n         *\n         * const data = [{ name: \"Pork\" }, { name: \"Pepper\" }, { name: \"Beef\" } ];\n         * const predicate = compileFilter({ logic: \"and\", filters: [{ field: \"name\", operator: \"startswith\", value: \"P\" }] });\n         * const result = data.filter(predicate);\n         *\n         * ```\n         */\n        // tslint:enable:max-line-length\n        var compileFilter = function (descriptor) {\n            if (!descriptor || descriptor.filters.length === 0) {\n                return function () { return true; };\n            }\n            return transformCompositeFilter(descriptor);\n        };\n\n        function forEachDesc(desc, callbackfn) {\n            if ('filters' in desc) {\n                desc.filters.map(function (child) { return forEachDesc(child, callbackfn); });\n            }\n            else {\n                callbackfn(desc);\n            }\n        }\n        var filterFields = function (filter, callback) {\n            var descriptors = Array.isArray(filter) ? filter : filter.filters;\n            descriptors.forEach(function (desc) { return forEachDesc(desc, callback); });\n        };\n        /** @hidden */\n        var initializeFiltering = function (rows, columns, filter) {\n            var compositeFilter = filter ?\n                (Array.isArray(filter) ? { logic: 'and', filters: filter } : filter) : undefined;\n            var predicate = compositeFilter ? compileFilter(compositeFilter) : function () { return true; };\n            var axes = rows.concat(columns);\n            var fieldValues = [];\n            filterFields(filter || [], function (desc) {\n                if ('field' in desc && desc.field) {\n                    fieldValues.push(desc.field);\n                }\n            });\n            var result = { hasFilter: false, predicate: predicate, filteringAxes: [] };\n            if (fieldValues.some(function (f) { return typeof f === 'function'; })) {\n                result.filteringAxes = axes.slice();\n            }\n            else if (fieldValues.length > 0) {\n                var filteringFields_1 = Array.from(new Set(fieldValues).values());\n                var filteringAxes = axes.filter(function (a) { return filteringFields_1.indexOf(a.key) >= 0; });\n                result.filteringAxes = filteringAxes;\n            }\n            result.hasFilter = result.filteringAxes.length > 0;\n            return result;\n        };\n\n        /** @hidden */\n        var subNode = function (node, field, initialNode) {\n            var childNode = node.get(field);\n            if (!childNode) {\n                childNode = initialNode || new Map();\n                node.set(field, childNode);\n            }\n            return childNode;\n        };\n        var separator = '&';\n        /** @hidden */\n        var createKey = function (key, value) { return key + separator + value; };\n        /** @hidden */\n        var splitKeyValue = function (keyValue) {\n            var separatorIndex = keyValue.indexOf(separator);\n            if (separatorIndex !== -1) {\n                var key = keyValue.substring(0, separatorIndex);\n                var value = keyValue.substring(separatorIndex + 1);\n                return [key, value];\n            }\n            else {\n                return [keyValue, undefined];\n            }\n        };\n\n        var calculateColumnData = function (node, measures, dataField) {\n            node.forEach(function (childNode, k) {\n                if (k !== dataField) {\n                    if (childNode.size > 0) {\n                        calculateColumnData(childNode, measures, dataField);\n                    }\n                    var childData_1 = childNode.get(dataField);\n                    var parentData_1 = subNode(node, dataField, {});\n                    measures.forEach(function (m) {\n                        m.aggregate.init(parentData_1);\n                        m.aggregate.merge(childData_1, parentData_1);\n                    });\n                }\n            });\n        };\n        /** @hidden */\n        var mergeTrees = function (src, dest, measures, dataField) {\n            src.forEach(function (srcChild, k) {\n                var destChild;\n                if (k !== dataField) {\n                    destChild = subNode(dest, k);\n                    mergeTrees(srcChild, destChild, measures, dataField);\n                }\n                else {\n                    destChild = subNode(dest, k, {});\n                    measures.forEach(function (m) {\n                        m.aggregate.init(destChild);\n                        m.aggregate.merge(srcChild, destChild);\n                    });\n                }\n            });\n        };\n        var calculateColumns = function (node, measures, columnsData, dataField) {\n            node.forEach(function (childNode, k) {\n                if (k !== columnsData) {\n                    if (childNode.size > 0) {\n                        calculateColumns(childNode, measures, columnsData, dataField);\n                    }\n                    var srcColumns = subNode(childNode, columnsData);\n                    var destColumns = subNode(node, columnsData);\n                    mergeTrees(srcColumns, destColumns, measures, dataField);\n                }\n            });\n        };\n        /** @hidden */\n        var createDataTree = function (data, rows, columns, measures, fields, filter) {\n            var result = new Map();\n            var cache = new Map();\n            var axes = rows.concat(columns);\n            var leafNodes = new Set();\n            var dataField = fields.dataField, columnsData = fields.columnsData;\n            var _a = initializeFiltering(rows, columns, filter), hasFilter = _a.hasFilter, predicate = _a.predicate, filteringAxes = _a.filteringAxes;\n            var empty = '';\n            data.forEach(function (dataItem) {\n                if (hasFilter) {\n                    var filteringDataItem_1 = {};\n                    filteringAxes.forEach(function (axis) { filteringDataItem_1[axis.key] = axis.displayValue(dataItem); });\n                    if (!predicate(filteringDataItem_1)) {\n                        return;\n                    }\n                }\n                var values = axes.map(function (a) { return a.displayValue(dataItem); });\n                var dataKey = empty.concat.apply(empty, values);\n                var nodeData = cache.get(dataKey);\n                if (!nodeData) {\n                    var node_1 = result;\n                    var eachAxis = function (axis) {\n                        node_1 = subNode(node_1, createKey(axis.key, axis.displayValue(dataItem)));\n                    };\n                    rows.forEach(eachAxis);\n                    node_1 = subNode(node_1, columnsData);\n                    leafNodes.add(node_1);\n                    columns.forEach(eachAxis);\n                    nodeData = {};\n                    node_1.set(dataField, nodeData);\n                    cache.set(dataKey, nodeData);\n                    measures.forEach(function (m) {\n                        m.aggregate.init(nodeData);\n                    });\n                }\n                measures.forEach(function (m) {\n                    m.aggregate.accumulate(nodeData, m.value(dataItem));\n                });\n            });\n            leafNodes.forEach(function (leaf) { return calculateColumnData(leaf, measures, dataField); });\n            calculateColumns(result, measures, columnsData, dataField);\n            return result;\n        };\n        /** @hidden */\n        var cloneDataTree = function (dataTree, dataField, measures) {\n            var result = new Map();\n            mergeTrees(dataTree, result, measures, dataField);\n            return result;\n        };\n\n        var createPath = function (name, axes, path) {\n            var _a = splitKeyValue(name), key = _a[0], value = _a[1];\n            var result = path.slice();\n            if (key && value) {\n                var axis = axes.find(function (a) { return a.key === key; });\n                var caption_1 = axis ? axis.caption : '';\n                return result.map(function (p) { return p === caption_1 ? name : p; });\n            }\n            return result;\n        };\n        var membersNode = function (tree, members, field, axisSettings, measures, dataField, cache) {\n            var cacheData = cache || new Map();\n            var path = axisSettings.map(function (a) { return a.caption; });\n            while (members.length > 1 && axisSettings.some(function (a) { return a.caption === members[members.length - 1].caption; })) {\n                members.pop();\n                path.pop();\n            }\n            var node = tree;\n            members.forEach(function (m, i) {\n                path = createPath(m.name, axisSettings, path);\n                if (node && !axisSettings.some(function (a) { return a.caption === m.name; })) {\n                    if (!node.has(m.name) && !cacheData.has(path.slice(0, path.indexOf(m.name) + 1).join('-'))) {\n                        var currentLevel = Array.from(node).find(function (n) { return n[0] !== field; });\n                        var currentLevelNode = currentLevel && currentLevel[0];\n                        var levelField_1 = currentLevelNode && splitKeyValue(currentLevelNode)[0];\n                        var depth = levelField_1 ? i - axisSettings.findIndex(function (a) { return a.key === levelField_1; }) : 0;\n                        var _loop_1 = function (t) {\n                            var data = [];\n                            node.forEach(function (value, key) {\n                                if (key !== field) {\n                                    data.push.apply(data, Array.from(value).filter(function (d) { return d[0] !== field; }));\n                                }\n                            });\n                            var next = new Map();\n                            data.forEach(function (item) {\n                                if (next.has(item[0])) {\n                                    var dest = next.get(item[0]);\n                                    var src = item[1];\n                                    var newDest = new Map();\n                                    mergeTrees(dest, newDest, measures, dataField);\n                                    mergeTrees(src, newDest, measures, dataField);\n                                    next.set(item[0], newDest);\n                                }\n                                else {\n                                    next.set(item[0], new Map(item[1]));\n                                }\n                            });\n                            var currentPath = path.slice(0, path.indexOf(m.name));\n                            next.forEach(function (value, key) {\n                                cacheData.set(createPath(key, axisSettings, currentPath.concat([key])).join('-'), value);\n                            });\n                            next.set(field, node.get(field));\n                            node = next;\n                        };\n                        for (var t = 0; t < depth; t++) {\n                            _loop_1(t);\n                        }\n                    }\n                    node = node.get(m.name) || cacheData.get(path.slice(0, path.indexOf(m.name) + 1).join('-'));\n                }\n            });\n            return node;\n        };\n        /** @hidden */\n        var readData = function (dataTree, rowTuples, columnTuples, fields, columnSettings, rowSettings, measures) {\n            var data = [];\n            var dataField = fields.dataField, columnsData = fields.columnsData;\n            var rowsCache = new Map();\n            rowTuples.forEach(function (row) {\n                var rowNode = membersNode(dataTree, row.members.slice(), columnsData, rowSettings, measures, dataField, rowsCache);\n                var rowColumnsNode = rowNode && rowNode.get(columnsData);\n                columnTuples.forEach(function (col) {\n                    var members = col.members.slice();\n                    var measure = measures[0];\n                    if (members[members.length - 1].levelName === \"[Measures].[MeasuresLevel]\") {\n                        var measuresMember_1 = members.pop();\n                        measure = measures.find(function (m) { return String(m.name) === measuresMember_1.caption; }) || measure;\n                    }\n                    var colNode = rowColumnsNode && membersNode(rowColumnsNode, members, dataField, columnSettings, measures, dataField);\n                    var value = '', fmtValue = '', ordinal = 0;\n                    if (colNode && measure) {\n                        var result = measure.aggregate.result(colNode.get(dataField));\n                        value = String(result);\n                        fmtValue = measure.aggregate.format(result);\n                    }\n                    data.push({\n                        columnTuple: col,\n                        data: { fmtValue: fmtValue, ordinal: ordinal, value: value },\n                        rowTuple: row\n                    });\n                });\n            });\n            return data;\n        };\n\n        var getTopMembersTuple = function (parentFields, axesSettings) {\n            var allTuple = { members: [] };\n            parentFields.forEach(function (topField) {\n                var axis = axesSettings.find(function (a) { return a.key === topField; });\n                var caption = axis ? axis.caption : \"\";\n                var member = {\n                    caption: caption,\n                    children: [],\n                    hasChildren: true,\n                    parentName: \"\",\n                    levelNum: 0,\n                    levelName: caption,\n                    hierarchy: topField,\n                    name: caption\n                };\n                allTuple.members.push(member);\n            });\n            return allTuple;\n        };\n        var sortFunc = function (descriptor, axe) {\n            return function (a, b) {\n                var order = descriptor.dir;\n                var sortableA = axe.sortValue(splitKeyValue(a[0])[1]);\n                var sortableB = axe.sortValue(splitKeyValue(b[0])[1]);\n                if (sortableA < sortableB) {\n                    return order === \"asc\" ? -1 : 1;\n                }\n                if (sortableA > sortableB) {\n                    return order === \"asc\" ? 1 : -1;\n                }\n                return 0;\n            };\n        };\n        var mergeData = function (src, dest, exclude) {\n            src.forEach(function (srcChild, k) {\n                if (!exclude[k]) {\n                    var destChild = subNode(dest, k);\n                    mergeData(srcChild, destChild, exclude);\n                }\n            });\n        };\n        var childrenByKeys = function (dataTree, keys, exclude) {\n            var result = [];\n            var nodeData = function (node) { return Array.from(node).filter(function (n) { return !exclude[n[0]]; }); };\n            var element = new Map(dataTree);\n            var next;\n            var _loop_1 = function (i) {\n                next = element.get(keys[i]);\n                if (next) {\n                    element = new Map(next);\n                }\n                else if (i < keys.length - 1 && Array.from(element).some(function (e) { return splitKeyValue(e[0])[0] === keys[i]; })) {\n                    var curLevel_1 = [];\n                    element.forEach(function (child, key) {\n                        if (!exclude[key]) {\n                            curLevel_1.push.apply(curLevel_1, nodeData(new Map(child)));\n                        }\n                    });\n                    element = new Map();\n                    curLevel_1.forEach(function (item) {\n                        if (element.has(item[0])) {\n                            var dest = element.get(item[0]);\n                            var src = item[1];\n                            var newDest = new Map();\n                            mergeData(dest, newDest, exclude);\n                            mergeData(src, newDest, exclude);\n                            element.set(item[0], newDest);\n                        }\n                        else {\n                            element.set(item[0], new Map(item[1]));\n                        }\n                    });\n                }\n                else if (i === 0 || i === keys.length - 1) {\n                    if (Array.from(element).some(function (e) { return splitKeyValue(e[0])[0] === keys[i]; })) {\n                        result.push.apply(result, nodeData(element));\n                    }\n                }\n            };\n            for (var i = 0; i < keys.length; i++) {\n                _loop_1(i);\n            }\n            return result;\n        };\n        /** @hidden */\n        var rootFields = function (definitions) {\n            var fields = new Set();\n            definitions.forEach(function (item) {\n                if (item.name.length === 1 && !splitKeyValue(item.name[0])[1]) {\n                    fields.add(item.name[0]);\n                }\n            });\n            return fields;\n        };\n        /** @hidden */\n        var createTuples = function (axesSettings, definitions, dataTree, sortDescriptors, excludeFields) {\n            var parentFields = rootFields(definitions);\n            var flatMembers = [];\n            var topTuple = getTopMembersTuple(parentFields, axesSettings);\n            flatMembers.push(topTuple);\n            var _loop_2 = function (i) {\n                var currDef = definitions[i];\n                if (currDef.name.length === 1 && !currDef.expand && parentFields.has(currDef.name[0])) {\n                    return \"continue\";\n                }\n                var keysToAdd = new Set(parentFields.keys());\n                var currDefMembers = [];\n                var keys = [];\n                var tuples = [];\n                var axe;\n                currDef.name.forEach(function (element, index) {\n                    var _a;\n                    var _b = splitKeyValue(element), field = _b[0], value = _b[1];\n                    axe = axesSettings.find(function (a) { return a.key === field; });\n                    if (value) {\n                        keysToAdd.delete(field);\n                        keys.push(element);\n                        var member = {\n                            children: [],\n                            caption: value,\n                            hierarchy: field,\n                            levelNum: 1,\n                            levelName: field + \" \" + field,\n                            name: element,\n                            parentName: axe ? axe.caption : \"\"\n                        };\n                        currDefMembers.push(member);\n                    }\n                    else if (currDef.expand && currDef.name.length - 1 === index) {\n                        keysToAdd.delete(element);\n                        keys.push(element);\n                        var children = childrenByKeys(dataTree, keys, excludeFields);\n                        var descriptor = sortDescriptors.find(function (desc) { return desc.field === field; });\n                        if (descriptor && descriptor.dir) {\n                            children.sort(sortFunc(descriptor, axe));\n                        }\n                        for (var c = 0; c < children.length; c++) {\n                            var leafValue = children[c][0];\n                            var leafTuple = { members: [] };\n                            tuples.push(leafTuple);\n                            var caption = splitKeyValue(leafValue)[1];\n                            axe = axesSettings.find(function (a) { return a.key === element; });\n                            var member = {\n                                caption: caption,\n                                children: [],\n                                levelName: element + \" \" + element,\n                                levelNum: 1,\n                                parentName: axe ? axe.caption : \"\",\n                                hierarchy: element,\n                                name: leafValue\n                            };\n                            (_a = leafTuple.members).push.apply(_a, currDefMembers);\n                            leafTuple.members.push(member);\n                        }\n                    }\n                    else if (currDef.expand) {\n                        axe = axesSettings.find(function (a) { return a.key === element; });\n                        var axisCaption = axe ? axe.caption : \"\";\n                        keysToAdd.delete(element);\n                        keys.push(element);\n                        var member = {\n                            children: [],\n                            caption: axisCaption,\n                            hierarchy: element,\n                            levelName: axisCaption,\n                            levelNum: 0,\n                            name: axisCaption,\n                            parentName: \"\"\n                        };\n                        currDefMembers.push(member);\n                    }\n                    keysToAdd.forEach(function (key) {\n                        tuples.forEach(function (tuple) {\n                            axe = axesSettings.find(function (a) { return a.key === key; });\n                            var curCaption = axe ? axe.caption : \"\";\n                            var member = {\n                                children: [],\n                                hasChildren: true,\n                                caption: curCaption,\n                                hierarchy: key,\n                                levelName: curCaption,\n                                levelNum: 0,\n                                name: curCaption,\n                                parentName: \"\"\n                            };\n                            tuple.members.push(member);\n                        });\n                    });\n                    flatMembers.push.apply(flatMembers, tuples);\n                });\n            };\n            for (var i = 0; i < definitions.length; i++) {\n                _loop_2(i);\n            }\n            return flatMembers;\n        };\n        var addMeasure = function (tuple, measure) {\n            var measureMember = {\n                caption: String(measure.name),\n                children: [],\n                hasChildren: false,\n                hierarchy: \"[Measures]\",\n                levelName: \"[Measures].[MeasuresLevel]\",\n                levelNum: 0,\n                name: \"[Measures].[\" + measure.name + \"]\",\n                parentName: \"\"\n            };\n            var tupleCopy = copy(tuple);\n            tupleCopy.members.push(measureMember);\n            return tupleCopy;\n        };\n        /** @hidden */\n        var addMultipleMeasures = function (tuples, measures) {\n            if (measures.length < 2) {\n                return tuples;\n            }\n            var result = tuples.slice();\n            for (var i = result.length - 1; i >= 0; i--) {\n                var tuple = result[i];\n                result[i] = addMeasure(result[i], measures[0]);\n                for (var m = 1; m < measures.length; m++) {\n                    var tupleWithMeasure = addMeasure(tuple, measures[m]);\n                    result.splice(i + 1, 0, tupleWithMeasure);\n                }\n            }\n            return result;\n        };\n        /** @hidden */\n        var createLocalDataState = function (args) {\n            var _a;\n            var dataTree = args.dataTree, rowSettings = args.rowSettings, columnSettings = args.columnSettings, rowAxes = args.rowAxes, columnAxes = args.columnAxes, measures = args.measures, sort = args.sort, fields = args.fields;\n            var exclude = (_a = {}, _a[fields.columnsData] = fields.columnsData, _a[fields.dataField] = fields.dataField, _a);\n            var columnTuples = addMultipleMeasures(createTuples(columnSettings, columnAxes, dataTree.get(fields.columnsData), sort, exclude), measures);\n            var rowTuples = createTuples(rowSettings, rowAxes, dataTree, sort, exclude);\n            var resultData = readData(dataTree, rowTuples, columnTuples, fields, columnSettings, rowSettings, measures);\n            return {\n                columns: columnTuples,\n                data: resultData,\n                rows: rowTuples\n            };\n        };\n\n        /** @hidden */\n        var createFlatSchemaDimensions = function (dimensions, measures) {\n            var result = Object.keys(dimensions).map(function (dim) { return ({\n                caption: dim,\n                defaultHierarchy: dim,\n                description: '',\n                name: dim,\n                uniqueName: dim,\n                hierarchyUniqueName: dim,\n                measure: true,\n                type: 1 // https://github.com/telerik/kendo-pivotgrid-common/blob/develop/src/models/responseDiscover.ts#L12-L14\n            }); });\n            if (measures.length) {\n                result.push({\n                    caption: 'Measures',\n                    children: measures.map(function (m) { return ({\n                        aggregator: '1',\n                        caption: String(m.name),\n                        defaultFormat: '',\n                        description: '',\n                        displayFolder: '',\n                        groupName: String(m.name),\n                        name: String(m.name),\n                        uniqueName: String(m.name)\n                    }); }),\n                    type: 2,\n                    description: '',\n                    name: 'Measures',\n                    uniqueName: '[Measures]'\n                });\n            }\n            return result;\n        };\n\n        exports.addKPI = addKPI;\n        exports.addMultipleMeasures = addMultipleMeasures;\n        exports.averageAggregate = averageAggregate;\n        exports.buildKPIMeasures = buildKPIMeasures;\n        exports.cloneDataTree = cloneDataTree;\n        exports.compareAxes = compareAxes;\n        exports.configuratorReducer = configuratorReducer;\n        exports.createAxisDescriptors = createAxisDescriptors;\n        exports.createDataState = createDataState;\n        exports.createDataTree = createDataTree;\n        exports.createDiscoverBody = createDiscoverBody;\n        exports.createFlatSchemaDimensions = createFlatSchemaDimensions;\n        exports.createLocalDataState = createLocalDataState;\n        exports.createRequestBody = createRequestBody;\n        exports.createTuples = createTuples;\n        exports.discoverCommands = discoverCommands;\n        exports.fetchData = fetchData;\n        exports.fetchDiscover = fetchDiscover;\n        exports.headersReducer = headersReducer;\n        exports.maxAggregate = maxAggregate;\n        exports.mergeTrees = mergeTrees;\n        exports.minAggregate = minAggregate;\n        exports.parseResponse = parseResponse;\n        exports.readData = readData;\n        exports.rootFields = rootFields;\n        exports.setFilter = setFilter;\n        exports.setSort = setSort;\n        exports.sumAggregate = sumAggregate;\n        exports.toColumns = toColumns;\n        exports.toData = toData;\n        exports.toRows = toRows;\n        exports.toTree = toTree;\n\n        Object.defineProperty(exports, '__esModule', { value: true });\n\n        return exports;\n\n    })({});\n\n    })();\n\n    var __meta__ = {\n            id: \"pivot.common\",\n            name: \"PivotCommon\",\n            category: \"web\",\n            description: \"Common JS for PivotGrid\",\n            depends: [ \"core\" ]\n        };\n\n}));\n"]}