{"version":3,"sources":["kendo.pivotgrid.js"],"names":["f","define","window","kendo","pivotgrid","common","exports","serializeFilters","filters","cube","idx","command","current","length","serializeExpression","expression","value","String","field","operator","operators","neq","doesnotcontain","formatString","filterFunctionFormats","str","_i","values","arguments","forEach","index","replace","RegExp","serializeMembers","members","measures","sort","parsed","expanded","rootNames","crossJoinCommands","memberName","names","parseDescriptors","getRootNames","root","push","crossJoinCommand","expandMemberDescriptor","name","mapNames","join","concat","measureNames","measure","result","undefined","member","hierarchyName","baseHierarchyPath","some","n","indexOf","found","name_1","j","l","child","expand","name_2","rootName","rootLength","slice","tmp","crossJoin","sortDescriptor","sortDescriptorForMember","dir","length_1","parts","split","pop","shift","createRequestBody","options","_a","columnAxes","_b","rowAxes","_c","measureAxes","_d","_e","filter","measuresRowAxis","measuresAxis","connection","catalog","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","next","e","rejected","done","then","apply","__generator","body","verb","v","op","TypeError","_","y","t","call","label","ops","trys","g","sent","throw","return","Symbol","iterator","this","__spreadArrays","s","i","il","r","k","a","jl","Array","parseResponse","response","indexedData","counter","xmlDoc","DOMParser","parseFromString","axes","from","querySelectorAll","cells","map","cell","fmtValue","getPropertyValue","ordinal","parseInt","getAttribute","columns","tuples","rows","data","axis","prototype","translateAxis","fill","c","rowTuple","colTuple","columnTuple","node","querySelector","textContent","tuple","memberElements","lNum","hasChildren","caption","children","hierarchy","levelName","levelNum","parentName","createDiscoverBody","properties","discoverCommands","serializeOptions","restrictions","Catalog","parentTagName","capitalize","key","toUpperCase","parseCubes","row","description","type","parseCatalogs","parseMeasures","uniqueName","aggregator","groupName","displayFolder","defaultFormat","parseKPIs","goal","status","trend","statusGraphic","trendGraphic","parseDimensions","defaultHierarchy","parseHierarchies","dimensionUniqueName","origin","defaultMember","parseLevels","orderingProperty","hierarchyUniqueName","parseMembers","levelUniqueName","childrenCardinality","createAxisDescriptors","expandTree","descriptors","Object","keys","JSON","parse","copy","obj","stringify","buildKPIMeasures","kpiMeasure","findPath","headersReducer","configuratorReducer","contains","endswith","eq","startswith","in","__assign","assign","p","hasOwnProperty","schemaCatalogs","schemaCubes","schemaDimensions","schemaHierarchies","schemaKPIs","schemaLevels","schemaMeasures","schemaMembers","discoverParser","fetchData","fetchOptions","init","stringResponse","headers","Content-Type","method","fetch","url","text","fetchDiscover","createDataState","state","setSort","setFilter","getMaxNesting","set","Set","add","size","getMaxExpansion","generateNormalizedPath","parent","normalizedPath","Boolean","generatePath","path","toMatrix","rowIndex","colIndex","maxDepth","maxBreadth","matrix","leafs","branchDepth","branchBreadth","depth","breadth","matrixResult","leafsResult","level","inject","shiftedRow","collOffset","findIndex","total","splice","newMatrix","newLeafs","childBreadth","withTotal","alt","childIndex","childHierarchy","toTree","tupleIndex","_loop_1","memberIndex","_loop_2","parent_1","parentKey","intruderIndex","find","lastIndexOf","Math","max","toData","hash","membersNames","m","columnsIndexes","Map","rowsIndexes","colMembers","rowMembers","item","get","rotateMatrix","rowSpan","colSpan","toColumns","toRows","kpi","addKPI","compareAxisWithField","b","compareAxes","HEADERS_ACTION","matchFn","matched","match","h","action","existing","existing_1","filtered_1","newState","toggle","payload","collapse","tree","PIVOT_CONFIGURATOR_ACTION","newRows","newColumns","newMeasures","newSort","newFilter","newDragitem","newDropZone","newDropDirection","newDropTarget","payload_1","currentColumn","currentRow","currentMeasure","insertAtIndex","offset","toggleSelection","isArray","removeMeasureAxis","addMeasureAxis","every","removeMeasureAxes","addMeasureAxes","removeColumnAxis","removeRowAxis","addColumnAxis","addRowAxis","addColumnAxes","removeColumnAxes","addRowAxes","removeRowAxes","remove","setDragItem","setDropZone","setDropTarget","setDropDirection","drop","dragItem","dropZone","dropTarget","dropDirection","addFilter","changeFilter","removeFilter","defineProperty","amd","a1","a2","a3","$","normalizeMeasures","descriptor","toString","d","normalizeMembers","normalizeName","accumulateMembers","accumulator","rootTuple","buildPath","descriptorsForAxes","addMissingPathMembers","tupleMembers","firstTuple","getName","tupleToDescriptors","descriptorsForMembers","tupletoSearch","MEASURES","findExistingTuple","createAggregateGetter","measureGetter","getter","aggregatorContext","aggregate","dataItem","isNumber","val","isNaN","isDate","getTime","getScollWidth","div","scrollbar","document","createElement","style","cssText","innerHTML","appendChild","offsetWidth","scrollWidth","removeChild","flatColumns","sortItemsTree","items","sortFunction","fillSortTree","currentItem","isEmptyObject","childrenMap","extend","addEmptyDataItem","validateAxis","newAxis","membersCount","adjustDataByColumn","sourceTuples","targetTuples","rowsLength","columnIdx","rowIdx","dataIdx","columnsLength","targetColumnsLength","measuresLength","adjustDataByRow","collection","queue","normalizeAxis","findDataIndex","mergeTuples","target","source","targetMembers","sourceMembers","parsedRoot","equalTuples","first","second","equal","toFind","membersLength","addMembers","len","findParentMember","parentMember","parentPath","measurePosition","normalizeTupleMeasures","dataIndex","parseSource","measureIndex","prepareDataOnRows","indices","columnIndex","targetIndex","sourceIndex","calcIndex","buildDataIndices","prepareDataOnColumns","spliceIndex","expandedIdx","uniquePath","format","asArray","object","memberIdx","captionGetter","unameGetter","levelNameGetter","levelNumGetter","childrenGetter","hierarchyGetter","parentNameGetter","Member","xmlaDiscoverCommands","convertersMap","XmlaTransport","XmlaTransportV2","schemaDataReaderMap","xmlaReaderMethods","XmlaDataReader","sortExpr","removeExpr","PivotConfiguratorButton","PivotContainer","PivotGridV2","PivotGrid","element","htmlNode","createMetadata","tupleName","ContentBuilderV2","ColumnRowBuilder","ColumnBuilder","RowBuilder","ContentBuilder","PivotExcelMixin","ui","Class","Comparer","Widget","DataSource","outerWidth","_outerWidth","outerHeight","_outerHeight","normalizeFilter","Query","normalizeSort","identity","o","isFunction","RESIZE","READ","CHANGE","ERROR","REQUESTSTART","PROGRESS","REQUESTEND","STATERESET","AUTO","DIV","NS","ROW_TOTAL_KEY","DATABINDING","DATABOUND","EXPANDMEMBER","HEADERTEMPLATE","COLLAPSEMEMBER","STATE_EXPANDED","STATE_COLLAPSED","HEADER_TEMPLATE","KPISTATUS_TEMPLATE","KPITREND_TEMPLATE","DATACELL_TEMPLATE","LAYOUT_TABLE","AXIS_ROWS","AXIS_COLUMNS","functions","sum","count","average","min","PivotCubeBuilder","dimensions","_normalizeDescriptors","keyField","fields","_rootTuples","measureAggregators","aggregatorsLength","dimensionsSchema","measureIdx","rootNamesLength","_sortMap","sortDescriptors","mapItem","sortedMaps","sortTree","flattenTree","directParentName","create","_expandedTuples","currentKeys","memberInfo","expandedNames","accumulatorKeys","_findExpandedMember","_asTuples","rootInfo","expandedInfo","_measuresInfo","rowAxis","aggregateNames","resultFuncs","formats","_toDataArray","measuresInfo","rowKeys","columnKeys","aggregates","column","columnKey","columnMeasureNames","rowMeasureNamesLength","rowMeasureNames","rowLength","columnLength","_addData","resultFunc","_matchDescriptors","getters","parentField","expectedValue","_calculateAggregate","totalItem","_processColumns","rowTotal","updateColumn","_measureAggregators","defaultAggregate","measureDescriptors","aggregators","toLowerCase","Error","_buildGetters","_parseDescriptors","parsedDescriptors","_filter","expr","_normalizeFilter","logic","process","columnDescriptors","rowDescriptors","aggregatedData","rowValue","columnGetters","rowGetters","processed","expandedColumns","expandedRows","hasExpandedRows","rowDescriptor","rowName","columnsInfo","rowsInfo","PivotTransport","transport","discover","read","update","destroy","success","PivotDataSourceV2","transportOptions","fn","_online","_columns","_rows","_measuresAxis","_measures","serverSorting","serverPaging","serverFiltering","serverGrouping","serverAggregates","_mergeState","_data","_query","that","isPrevented","trigger","params","_params","newDataState","_saveState","_preventRefresh","error","err","catalogName","cubeName","dimensionName","_columnTuples","_rowTuples","_view","PivotDataSource","schema","cubes","catalogs","hierarchies","levels","_cubeSchema","cubeBuilder","_skipNormalize","_axes","proxy","memberUniqueName","schemaData","dataGetter","_rawData","distinct","treeOp","_clearAxesData","query","rowsAxisDescriptors","columnsAxisDescriptors","_expandPath","other","memberToExpand","_lastExpanded","_descriptorsForAxis","_process","page","pageSize","group","_updateLocalData","_pristineData","Deferred","promise","expandColumn","expandRow","originalData","reader","_processResult","processedData","columnIndexes","rowIndexes","resultAxis","axisToSkip","hasColumnTuples","_requestData","_rowMeasures","_normalizeTuples","_columnMeasures","_normalizeData","_mergeAxes","_readData","newData","_createTuple","buildRoot","_hasRoot","isRoot","sourceAxes","startIndex","mergedColumns","mergedRows","columnMeasures","rowMeasures","oldRowsLength","newRowsLength","oldColumnsLength","newColumnsLength","_mergeColumnData","_mergeRowData","toAdd","toJSON","_observe","_ranges","_addRange","_total","_pristineTotal","last","roots","indexes","_addMissingDataItems","metadata","_normalizeOrdinals","lastOrdinal","converter","deferred","_handleCustomErrors","kpis","dataSource","RemoteTransport","originalOptions","setup","dataType","contentType","parameterMap","ajax","noop","XmlDataReader","_extend","methodName","option","xml","errors","fault","faultstring","faultcode","ordinalGetter","valueGetter","fmtValueGetter","_mapSchema","transports","xmla","readers","expressions","PivotSettingTarget","addClass","_refreshHandler","refresh","template","ns","enabled","emptyTemplate","_sortable","on","closest","attr","hasClass","sortable","currentTarget","filterable","fieldMenu","PivotFieldMenu","messages","setting","empty","setDataSource","unbind","kendoSortable","connectWith","hint","cursor","start","change","move","newIndex","_isKPI","validate","isMeasure","sortExpressions","_sort","allowUnsort","skipExpr","html","sortIcon","_sortIcon","off","icon","PivotSettingTargetV2","PivotFieldMenuV2","events","_applyState","_sortState","_stateFilter","_savedState","_cancelChanges","deepExtend","_initialState","_redraw","_state","modifyInit","focus","blur","_savedFilter","_emptyState","enable","removeClass","_targetsHTML","menuenabled","_element","_attachEvents","configurator","setOptions","pivot","pivotEl","toggleClass","getKendoPivotGridV2","_setContentWidth","_updateDimensions","_addClasses","configuratorPosition","className","_dataSource","_bindConfigurator","_wrapper","_columnHeadersWrapper","_rowHeadersWrapper","_contentWrapper","wrapper","append","_columnBuilder","columnHeaderTemplate","_rowBuilder","rowHeaderTemplate","_contentBuilder","dataCellTemplate","_scrollable","reducerPayLoad","currentAxes","newHeaders","button","isRow","paths","eventName","getTree","autoBind","notify","height","columnWidth","_windowResizeHandler","_progressHandler","_errorHandler","_requestStart","_error","bind","_resize","setProperty","columnsHeader","rowsHeader","scroll","scrollLeft","scrollTop","_wheelScroll","delta","ctrlKey","wheelDeltaY","preventDefault","one","css","_progress","progress","grid-template-columns","grid-template-rows","offsetHeight","contentTable","columnTable","calculatedWidth","minWidth","ceil","width","kendoPivotConfiguratorV2","cellInfoByElement","cellInfo","contentBuilder","columnsCount","rowsCount","setTuples","build","setRowColumnInfo","columnHeaderLeafs","getHeaderLeafs","rowHeaderLeafs","columnHeaderBreadth","getBreadth","rowHeaderDepth","plugin","columnBuilder","rowBuilder","_createLayout","_templates","request","builder","eventArgs","parseJSON","is","childrenLoaded","maxChildren","reorderable","kpiStatusTemplate","kpiTrendTemplate","measureFields","columnFields","rowFields","columnTemplate","rowTemplate","dataTemplate","useWithBlock","kendoPivotConfigurator","columnInfo","rowInfo","view","measuresTarget","rowsTarget","columnsTarget","clearTimeout","_headerReflowTimeout","_stateResetHandler","_stateReset","reset","_measureFields","_createSettingTarget","icons","_initSettingTargets","layoutTable","leftContainer","rightContainer","gridWrapper","wrap","support","content","columnsHeaderTree","dom","Tree","rowsHeaderTree","contentTree","firstChild","_setSectionsWidth","_setSectionsHeight","_setContentHeight","_columnHeaderReflow","browser","mozilla","setTimeout","leftColumn","measureFieldsHeight","columnFieldsHeight","rowFieldsHeight","innerHeight","columnsHeight","padding","firstRowHeight","secondRowHeight","_resetColspan","skipScrollbar","clientHeight","_colspan","_layoutTimeout","_axisMeasures","hasMeasure","touchScroller","columnAxis","render","_indexes","contentResized","movable","sender","x","maxMembers","addColElements","table","addRowElements","addColumCell","rowEl","rowItem","cellEl","headerTemplate","columnHeaderRows","rowspan","colspan","iconClass","expandable","headerClass","treeData","headerRows","headerLeafs","rowHeaderBreadth","_tree","_breadth","_headerLeafs","tbody","_tbody","colgroup","_colGroup","_rowLength","_buildRows","_normalize","cellsLength","cellIdx","tupleAll","_rowIndex","_row","parentRow","rowKey","notFirst","collapsed","measureRow","_cell","_content","childRow","childrenLength","allCell","cellAttr","nextMember","cellChildren","memberCollapsed","rootLevelNum","maxcolSpan","allRow","firstMemberName","expandIconAttr","tuplePath","hasChild","axisInfo","axisInfoMember","skipChildren","firstEmpty","_buildRow","templateInfo","cellContent","startIdx","PivotExcelExporter","widget","columnHeaderTable","rowHeaderTable","columnHeaderLength","rowHeaderLength","autoWidth","_cells","callback","background","color","dataCallback","rowRows","rowHeaderRows","contentRows","columnRows","_freezePane","colSplit","rowSplit","workbook","sheets","freezePane","proto","excel","saveAsExcel","proxyURL","fileName","exporter","book","ooxml","Workbook","toDataURLAsync","dataURI","saveAs","forceProxy","PDFMixin","_drawPDF","_drawPDFShadow","avoidLinks","pdf","jQuery"],"mappings":"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","file":"kendo.pivotgrid.min.js","sourcesContent":["/*!\n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n\n*/\n(function (f, define) {\n    define('pivotgrid/common', ['kendo.core'], f);\n}(function () {\n    (function () {\n        window.kendo.pivotgrid = window.kendo.pivotgrid || {};\n        window.kendo.pivotgrid.common = function (exports) {\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            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                    } 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                } 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 values = [];\n                for (var _i = 1; _i < arguments.length; _i++) {\n                    values[_i - 1] = arguments[_i];\n                }\n                values.forEach(function (value, index) {\n                    str = str.replace(new RegExp('\\\\{' + index + '\\\\}', 'g'), value);\n                });\n                return str;\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                } 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            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) {\n                            return n.indexOf(hierarchyName) === 0;\n                        })) {\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                    } 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                } 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                } else {\n                    result += names.shift();\n                    name = names.pop();\n                }\n                result += '},{';\n                result += name;\n                result += '})';\n                return result;\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                } 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                    } 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                } 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            var __assign = function () {\n                __assign = Object.assign || function __assign(t) {\n                    for (var s, i = 1, n = arguments.length; i < n; i++) {\n                        s = arguments[i];\n                        for (var p in s)\n                            if (Object.prototype.hasOwnProperty.call(s, p))\n                                t[p] = s[p];\n                    }\n                    return t;\n                };\n                return __assign.apply(this, arguments);\n            };\n            function __awaiter(thisArg, _arguments, P, generator) {\n                function adopt(value) {\n                    return value instanceof P ? value : new P(function (resolve) {\n                        resolve(value);\n                    });\n                }\n                return new (P || (P = Promise))(function (resolve, reject) {\n                    function fulfilled(value) {\n                        try {\n                            step(generator.next(value));\n                        } catch (e) {\n                            reject(e);\n                        }\n                    }\n                    function rejected(value) {\n                        try {\n                            step(generator['throw'](value));\n                        } catch (e) {\n                            reject(e);\n                        }\n                    }\n                    function step(result) {\n                        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n                    }\n                    step((generator = generator.apply(thisArg, _arguments || [])).next());\n                });\n            }\n            function __generator(thisArg, body) {\n                var _ = {\n                        label: 0,\n                        sent: function () {\n                            if (t[0] & 1)\n                                throw t[1];\n                            return t[1];\n                        },\n                        trys: [],\n                        ops: []\n                    }, f, y, t, g;\n                return g = {\n                    next: verb(0),\n                    'throw': verb(1),\n                    'return': verb(2)\n                }, typeof Symbol === 'function' && (g[Symbol.iterator] = function () {\n                    return this;\n                }), g;\n                function verb(n) {\n                    return function (v) {\n                        return step([\n                            n,\n                            v\n                        ]);\n                    };\n                }\n                function step(op) {\n                    if (f)\n                        throw new TypeError('Generator is already executing.');\n                    while (_)\n                        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)\n                                return t;\n                            if (y = 0, t)\n                                op = [\n                                    op[0] & 2,\n                                    t.value\n                                ];\n                            switch (op[0]) {\n                            case 0:\n                            case 1:\n                                t = op;\n                                break;\n                            case 4:\n                                _.label++;\n                                return {\n                                    value: op[1],\n                                    done: false\n                                };\n                            case 5:\n                                _.label++;\n                                y = op[1];\n                                op = [0];\n                                continue;\n                            case 7:\n                                op = _.ops.pop();\n                                _.trys.pop();\n                                continue;\n                            default:\n                                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n                                    _ = 0;\n                                    continue;\n                                }\n                                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n                                    _.label = op[1];\n                                    break;\n                                }\n                                if (op[0] === 6 && _.label < t[1]) {\n                                    _.label = t[1];\n                                    t = op;\n                                    break;\n                                }\n                                if (t && _.label < t[2]) {\n                                    _.label = t[2];\n                                    _.ops.push(op);\n                                    break;\n                                }\n                                if (t[2])\n                                    _.ops.pop();\n                                _.trys.pop();\n                                continue;\n                            }\n                            op = body.call(thisArg, _);\n                        } catch (e) {\n                            op = [\n                                6,\n                                e\n                            ];\n                            y = 0;\n                        } finally {\n                            f = t = 0;\n                        }\n                    if (op[0] & 5)\n                        throw op[1];\n                    return {\n                        value: op[0] ? op[1] : void 0,\n                        done: true\n                    };\n                }\n            }\n            function __spreadArrays() {\n                for (var s = 0, i = 0, il = arguments.length; i < il; i++)\n                    s += arguments[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            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')).map(function (cell) {\n                    return {\n                        fmtValue: getPropertyValue(cell, 'FmtValue'),\n                        ordinal: parseInt(cell.getAttribute('CellOrdinal'), 10),\n                        value: getPropertyValue(cell, 'Value')\n                    };\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) {\n                    indexedData[c.ordinal] = c;\n                });\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 {\n                    columns: columns,\n                    data: data,\n                    rows: rows\n                };\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            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            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                } else {\n                    result += '<' + parentTagName + '/>';\n                }\n                return result;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    return {\n                        name: getPropertyValue(row, 'CATALOG_NAME'),\n                        description: getPropertyValue(row, 'DESCRIPTION')\n                    };\n                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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')).map(function (row) {\n                    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                });\n                return rows;\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            var fetchData = function (fetchOptions, options) {\n                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({\n                                body: createRequestBody(options),\n                                headers: { 'Content-Type': 'text/xml' },\n                                method: 'POST'\n                            }, fetchOptions.init);\n                            return [\n                                4,\n                                fetch(fetchOptions.url, init)\n                            ];\n                        case 1:\n                            response = _a.sent();\n                            return [\n                                4,\n                                response.text()\n                            ];\n                        case 2:\n                            stringResponse = _a.sent();\n                            return [\n                                2,\n                                parseResponse(stringResponse)\n                            ];\n                        }\n                    });\n                });\n            };\n            var fetchDiscover = function (fetchOptions, options) {\n                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({\n                                body: createDiscoverBody(options),\n                                headers: { 'Content-Type': 'text/xml' },\n                                method: 'POST'\n                            }, fetchOptions.init);\n                            return [\n                                4,\n                                fetch(fetchOptions.url, init)\n                            ];\n                        case 1:\n                            response = _a.sent();\n                            return [\n                                4,\n                                response.text()\n                            ];\n                        case 2:\n                            stringResponse = _a.sent();\n                            return [\n                                2,\n                                discoverParser[options.command](stringResponse)\n                            ];\n                        }\n                    });\n                });\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            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({\n                        name: JSON.parse(key),\n                        expand: expandTree[key]\n                    });\n                }\n                return descriptors;\n            }\n            var setSort = function (options, sort) {\n                if (sort === void 0) {\n                    sort = [];\n                }\n                options.sort = sort;\n            };\n            var setFilter = function (options, filter) {\n                if (filter === void 0) {\n                    filter = [];\n                }\n                options.filter = filter;\n            };\n            var getMaxNesting = function (node, set) {\n                if (set === void 0) {\n                    set = new Set();\n                }\n                (node.children || []).forEach(function (child) {\n                    set.add(child.levelName);\n                    getMaxNesting(child, set);\n                });\n                return set.size;\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            var generateNormalizedPath = function (node, parent) {\n                return (parent && parent.hierarchy === node.hierarchy ? __spreadArrays((parent.normalizedPath || []).slice(0, -1), [node.name || null]) : __spreadArrays(parent && parent.normalizedPath ? parent.normalizedPath : [], [node.name])).filter(Boolean);\n            };\n            var generatePath = function (node, parent) {\n                return (parent && parent.hierarchy === node.hierarchy ? __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            var toMatrix = function (node, rowIndex, colIndex, maxDepth, maxBreadth, matrix, leafs, parent) {\n                if (rowIndex === void 0) {\n                    rowIndex = -1;\n                }\n                if (colIndex === void 0) {\n                    colIndex = 0;\n                }\n                if (maxDepth === void 0) {\n                    maxDepth = undefined;\n                }\n                if (maxBreadth === void 0) {\n                    maxBreadth = undefined;\n                }\n                if (matrix === void 0) {\n                    matrix = undefined;\n                }\n                if (leafs === void 0) {\n                    leafs = undefined;\n                }\n                if (parent === void 0) {\n                    parent = undefined;\n                }\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) {\n                    return l && l.name === node.levelName && l.level === node.levelNum;\n                });\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) {\n                        return c.hierarchy === node.hierarchy;\n                    })\n                };\n                if (inject) {\n                    if (level) {\n                        level.cells[colIndex] = cell;\n                        if (level.index >= rowIndex) {\n                            rowIndex = level.index;\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                        } 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                } else if (node.normalizedPath) {\n                    leafsResult[colIndex] = {\n                        total: cell.total,\n                        path: node.normalizedPath\n                    };\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) {\n                    parent = null;\n                }\n                if (index === void 0) {\n                    index = 0;\n                }\n                var hierarchy;\n                var alt = __assign(__assign({}, root), {\n                    total: true,\n                    hasChildren: false,\n                    children: []\n                });\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 && parent && !parent.children.some(function (c) {\n                            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) {\n                        return !c.total;\n                    }).length >= 1 && parent && !parent.children.some(function (c) {\n                        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            var toTree = function (tuples) {\n                var root = { children: [] };\n                var map = {};\n                var _loop_1 = function (tupleIndex) {\n                    var tuple = copy(tuples[tupleIndex]);\n                    var key = '';\n                    var _loop_2 = 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                        } else if (map[key] && !map[key + member.name] && member.levelNum === 0) {\n                            parent_1 = map[key];\n                        } else if (map[key + member.parentName] && member.levelNum > 0 && !map[key + member.parentName + member.name]) {\n                            parent_1 = map[key + member.parentName];\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) {\n                                return e.indexOf(member.hierarchy) === 0 && e.lastIndexOf(key + member.parentName) + (key + member.parentName).length === e.length;\n                            });\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) {\n                                return c.hierarchy !== parent_1.hierarchy;\n                            });\n                            if (intruderIndex !== -1) {\n                                parent_1.children.splice(Math.max(intruderIndex, 0), 0, member);\n                            } else {\n                                parent_1.children.push(member);\n                            }\n                        }\n                        key += member.parentName += member.name;\n                        if (!map[key]) {\n                            map[key] = member;\n                        }\n                    };\n                    for (var memberIndex = 0; memberIndex < tuple.members.length; memberIndex++) {\n                        _loop_2(memberIndex);\n                    }\n                };\n                for (var tupleIndex = 0; tupleIndex < tuples.length; tupleIndex++) {\n                    _loop_1(tupleIndex);\n                }\n                return copy(withTotal(root));\n            };\n            var toData = function (data, columns, rows, breadth, depth) {\n                var result = Array.from(new Array(depth), function () {\n                    return {\n                        cells: Array.from(new Array(breadth), function () {\n                            return null;\n                        })\n                    };\n                });\n                var hash = function (names) {\n                    return names.join('|');\n                };\n                var membersNames = function (tuple) {\n                    return tuple.members.map(function (m) {\n                        return m.name;\n                    });\n                };\n                var columnsIndexes = new Map();\n                var rowsIndexes = new Map();\n                columns.forEach(function (colMembers, idx) {\n                    columnsIndexes.set(hash(colMembers.path), idx);\n                });\n                rows.forEach(function (rowMembers, idx) {\n                    rowsIndexes.set(hash(rowMembers.path), idx);\n                });\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] = { cells: new Array(depth).fill(null) };\n                            }\n                            result[colIndex].cells[rowIndex] = __assign(__assign({}, cell), {\n                                rowSpan: cell.colSpan,\n                                colSpan: cell.rowSpan\n                            });\n                        }\n                    }\n                }\n                return [\n                    result,\n                    leafs,\n                    breadth,\n                    depth\n                ];\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 [\n                    matrix,\n                    leafs,\n                    depth,\n                    breadth\n                ];\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            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            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            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            var compareAxisWithField = function (a, b) {\n                return String(a.name) === String([b.defaultHierarchy ? b.defaultHierarchy : b.uniqueName]);\n            };\n            var compareAxes = function (a, b) {\n                return String(a.name) === String(b.name);\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            var headersReducer = function (state, action) {\n                switch (action.type) {\n                case exports.HEADERS_ACTION.toggle: {\n                        var existing = state.find(function (s) {\n                            return String(s.name) === String(action.payload);\n                        });\n                        return headersReducer(state, __assign(__assign({}, action), { type: existing && existing.expand ? exports.HEADERS_ACTION.collapse : exports.HEADERS_ACTION.expand }));\n                    }\n                case exports.HEADERS_ACTION.expand: {\n                        var existing_1 = state.find(function (s) {\n                            return String(s.name) === String(action.payload);\n                        });\n                        if (existing_1 && existing_1.expand === true) {\n                            return state;\n                        } else if (existing_1 && (existing_1.expand === false || existing_1.expand === undefined)) {\n                            return state.map(function (s) {\n                                return s === existing_1 ? __assign(__assign({}, existing_1), { expand: true }) : s;\n                            });\n                        } else {\n                            return __spreadArrays(state, [{\n                                    name: action.payload,\n                                    expand: true\n                                }]);\n                        }\n                    }\n                case exports.HEADERS_ACTION.collapse: {\n                        var filtered_1 = findPath(action.tree, function (node) {\n                            return !node.total && String(node.path) === String(action.payload);\n                        });\n                        var newState = __spreadArrays(state).filter(function (h) {\n                            return !filtered_1.some(function (f) {\n                                return f === String(h.name);\n                            });\n                        }).map(function (h) {\n                            return __assign(__assign({}, h), { expand: Boolean(h.expand) });\n                        }).map(function (h) {\n                            return String(h.name) === String(action.payload) ? action.payload.length > 1 ? undefined : {\n                                name: action.payload,\n                                expand: false\n                            } : h;\n                        }).filter(Boolean);\n                        return newState;\n                    }\n                default: {\n                        return state;\n                    }\n                }\n            };\n            exports.PIVOT_CONFIGURATOR_ACTION = void 0;\n            (function (PIVOT_CONFIGURATOR_ACTION) {\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                PIVOT_CONFIGURATOR_ACTION['remove'] = 'PIVOT_CONFIGURATOR_ACTION_REMOVE';\n                PIVOT_CONFIGURATOR_ACTION['setSort'] = 'PIVOT_CONFIGURATOR_ACTION_SET_SORT';\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                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            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) {\n                                        return compareAxisWithField(s, payload_1);\n                                    })) {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis }));\n                                } else {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis }));\n                                }\n                            } else if (payload_1.type === 'kpi') {\n                                var measures = buildKPIMeasures(payload_1);\n                                if (measures.every(function (m) {\n                                        return state.measureAxes.some(function (s) {\n                                            return compareAxisWithField(s, m);\n                                        });\n                                    })) {\n                                    return configuratorReducer(state, __assign(__assign({}, action), {\n                                        type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxes,\n                                        payload: measures\n                                    }));\n                                } else {\n                                    return configuratorReducer(state, __assign(__assign({}, action), {\n                                        type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxes,\n                                        payload: measures.filter(function (m) {\n                                            return !state.measureAxes.some(function (s) {\n                                                return compareAxisWithField(s, m);\n                                            });\n                                        })\n                                    }));\n                                }\n                            } else if (action.payload.kpi) {\n                                if (state.measureAxes.some(function (s) {\n                                        return compareAxisWithField(s, payload_1);\n                                    })) {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis }));\n                                } else {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis }));\n                                }\n                            } else {\n                                if (state.columnAxes.some(function (s) {\n                                        return compareAxisWithField(s, payload_1);\n                                    })) {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxis }));\n                                } else if (state.rowAxes.some(function (s) {\n                                        return compareAxisWithField(s, payload_1);\n                                    })) {\n                                    return configuratorReducer(state, __assign(__assign({}, action), { type: exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxis }));\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                                } 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 || [], [{ name: [action.payload.defaultHierarchy || action.payload.uniqueName] }]);\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addColumnAxes: {\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxis: {\n                        newColumns = __spreadArrays((state.columnAxes || []).filter(function (s) {\n                            return !compareAxisWithField(s, action.payload);\n                        }));\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeColumnAxes: {\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addRowAxis: {\n                        newRows = __spreadArrays(state.rowAxes || [], [{ name: [action.payload.defaultHierarchy || action.payload.uniqueName] }]);\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addRowAxes: {\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxis: {\n                        newRows = __spreadArrays((state.rowAxes || []).filter(function (s) {\n                            return !compareAxisWithField(s, action.payload);\n                        }));\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeRowAxes: {\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxis: {\n                        newMeasures = __spreadArrays(state.measureAxes || [], [{ name: [action.payload.defaultHierarchy || action.payload.uniqueName] }]);\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxis: {\n                        newMeasures = __spreadArrays((state.measureAxes || []).filter(function (s) {\n                            return !compareAxisWithField(s, action.payload);\n                        }));\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.addMeasureAxes: {\n                        newMeasures = __spreadArrays(state.measureAxes || [], (action.payload || []).map(function (p) {\n                            return { name: [p.defaultHierarchy || p.uniqueName] };\n                        }));\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.removeMeasureAxes: {\n                        newMeasures = __spreadArrays((state.measureAxes || []).filter(function (s) {\n                            return !action.payload.some(function (p) {\n                                return compareAxisWithField(s, p);\n                            });\n                        }));\n                        break;\n                    }\n                case exports.PIVOT_CONFIGURATOR_ACTION.remove: {\n                        if (state.columnAxes.some(function (s) {\n                                return compareAxes(s, action.payload);\n                            })) {\n                            newColumns = __spreadArrays(state.columnAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\n                        }\n                        if (state.rowAxes.some(function (s) {\n                                return compareAxes(s, action.payload);\n                            })) {\n                            newRows = __spreadArrays(state.rowAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\n                        }\n                        if (state.measureAxes.some(function (s) {\n                                return compareAxes(s, action.payload);\n                            })) {\n                            newMeasures = __spreadArrays(state.measureAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\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) {\n                            return compareAxes(s, action.payload);\n                        });\n                        var currentRow = state.rowAxes.find(function (s) {\n                            return compareAxes(s, action.payload);\n                        });\n                        var currentMeasure = state.measureAxes.find(function (s) {\n                            return compareAxes(s, action.payload);\n                        });\n                        var current = void 0;\n                        if (currentColumn) {\n                            current = currentColumn;\n                            newColumns = __spreadArrays(state.columnAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\n                        }\n                        if (currentRow) {\n                            current = currentRow;\n                            newRows = __spreadArrays(state.rowAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\n                        }\n                        if (currentMeasure) {\n                            current = currentMeasure;\n                            newMeasures = __spreadArrays(state.measureAxes.filter(function (s) {\n                                return !compareAxes(s, action.payload);\n                            }));\n                        }\n                        switch (state.dropZone) {\n                        case 'columnAxes': {\n                                newColumns = newColumns || state.columnAxes.slice();\n                                var insertAtIndex = -1;\n                                if (state.dropTarget && state.dropDirection) {\n                                    var offset = state.dropDirection ? state.dropDirection === 'before' ? 0 : 1 : 0;\n                                    insertAtIndex = newColumns.findIndex(function (c) {\n                                        return compareAxes(c, state.dropTarget);\n                                    }) + offset;\n                                }\n                                if (insertAtIndex >= 0) {\n                                    newColumns.splice(insertAtIndex, 0, current);\n                                } else {\n                                    newColumns.push(current);\n                                }\n                                break;\n                            }\n                        case 'rowAxes': {\n                                newRows = newRows || state.rowAxes.slice();\n                                var insertAtIndex = -1;\n                                if (state.dropTarget && state.dropDirection) {\n                                    var offset = state.dropDirection ? state.dropDirection === 'before' ? 0 : 1 : 0;\n                                    insertAtIndex = newRows.findIndex(function (c) {\n                                        return compareAxes(c, state.dropTarget);\n                                    }) + offset;\n                                }\n                                if (insertAtIndex >= 0) {\n                                    newRows.splice(insertAtIndex, 0, current);\n                                } else {\n                                    newRows.push(current);\n                                }\n                                break;\n                            }\n                        case 'measureAxes': {\n                                newMeasures = newMeasures || state.measureAxes.slice();\n                                var insertAtIndex = -1;\n                                if (state.dropTarget && state.dropDirection) {\n                                    var offset = state.dropDirection ? state.dropDirection === 'before' ? 0 : 1 : 0;\n                                    insertAtIndex = newMeasures.findIndex(function (c) {\n                                        return compareAxes(c, state.dropTarget);\n                                    }) + offset;\n                                }\n                                if (insertAtIndex >= 0) {\n                                    newMeasures.splice(insertAtIndex, 0, current);\n                                } else {\n                                    newMeasures.push(current);\n                                }\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                    } 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                    } else {\n                        newFilter.push(action.payload);\n                    }\n                    break;\n                case exports.PIVOT_CONFIGURATOR_ACTION.changeFilter:\n                    newFilter = Array.isArray(action.payload) ? (state.filter || []).map(function (f) {\n                        return action.payload.some(function (a) {\n                            return a.field === f.field;\n                        }) ? action.payload.find(function (a) {\n                            return a.field === f.field;\n                        }) : f;\n                    }) : (state.filter || []).map(function (f) {\n                        return f.field === action.payload.field ? action.payload : f;\n                    });\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) {\n                            return !action.payload.some(function (p) {\n                                return p.field === f.field && p.operator === f.operator;\n                            });\n                        });\n                    } else {\n                        newFilter = newFilter.filter(function (f) {\n                            return !(f.field === action.payload.field && f.operator === action.payload.operator);\n                        });\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            exports.addKPI = addKPI;\n            exports.buildKPIMeasures = buildKPIMeasures;\n            exports.compareAxes = compareAxes;\n            exports.configuratorReducer = configuratorReducer;\n            exports.createAxisDescriptors = createAxisDescriptors;\n            exports.createDataState = createDataState;\n            exports.createDiscoverBody = createDiscoverBody;\n            exports.createRequestBody = createRequestBody;\n            exports.discoverCommands = discoverCommands;\n            exports.fetchData = fetchData;\n            exports.fetchDiscover = fetchDiscover;\n            exports.headersReducer = headersReducer;\n            exports.parseResponse = parseResponse;\n            exports.setFilter = setFilter;\n            exports.setSort = setSort;\n            exports.toColumns = toColumns;\n            exports.toData = toData;\n            exports.toRows = toRows;\n            exports.toTree = toTree;\n            Object.defineProperty(exports, '__esModule', { value: true });\n            return exports;\n        }({});\n    }());\n}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {\n    (a3 || a2)();\n}));\n(function (f, define) {\n    define('kendo.pivotgrid', [\n        'pivotgrid/common',\n        'kendo.dom',\n        'kendo.data'\n    ], f);\n}(function () {\n    var __meta__ = {\n        id: 'pivotgrid',\n        name: 'PivotGrid',\n        category: 'web',\n        description: 'The PivotGrid widget is a data summarization tool.',\n        depends: [\n            'dom',\n            'data',\n            'data.xml',\n            'sortable'\n        ],\n        features: [\n            {\n                id: 'pivotgrid-configurator',\n                name: 'Configurator',\n                description: 'The PivotConfigurator widget allows the user to select data slices displayed in PivotGrid',\n                depends: ['pivot.configurator']\n            },\n            {\n                id: 'pivotgrid-filtering',\n                name: 'Filtering',\n                description: 'Support for filtering',\n                depends: ['pivot.fieldmenu']\n            },\n            {\n                id: 'pivotgrid-excel-export',\n                name: 'Excel export',\n                description: 'Export pivot grid data as Excel spreadsheet',\n                depends: ['ooxml']\n            },\n            {\n                id: 'pivotgrid-pdf-export',\n                name: 'PDF export',\n                description: 'Export pivot grid data as PDF',\n                depends: [\n                    'pdf',\n                    'drawing'\n                ]\n            },\n            {\n                id: 'mobile-scroller',\n                name: 'Mobile scroller',\n                description: 'Support for kinetic scrolling in mobile device',\n                depends: ['mobile.scroller']\n            }\n        ]\n    };\n    (function ($, undefined) {\n        var kendo = window.kendo, ui = kendo.ui, Class = kendo.Class, Comparer = kendo.data.Comparer, Widget = ui.Widget, DataSource = kendo.data.DataSource, outerWidth = kendo._outerWidth, outerHeight = kendo._outerHeight, common = window.kendo.pivotgrid.common, fetchDiscover = common.fetchDiscover, normalizeFilter = kendo.data.Query.normalizeFilter, normalizeSort = kendo.data.Query.normalizeSort, toString = {}.toString, identity = function (o) {\n                return o;\n            }, map = $.map, extend = $.extend, isFunction = kendo.isFunction, fetchData = common.fetchData, createDataState = common.createDataState, toColumns = common.toColumns, toRows = common.toRows, toTree = common.toTree, toData = common.toData, headersReducer = common.headersReducer, RESIZE = 'resize', READ = 'read', CHANGE = 'change', ERROR = 'error', REQUESTSTART = 'requestStart', PROGRESS = 'progress', REQUESTEND = 'requestEnd', MEASURES = 'Measures', STATERESET = 'stateReset', AUTO = 'auto', DIV = '<div></div>', NS = '.kendoPivotGrid', ROW_TOTAL_KEY = '__row_total__', DATABINDING = 'dataBinding', DATABOUND = 'dataBound', EXPANDMEMBER = 'expandMember', HEADERTEMPLATE = '<th data-key=\"#:key#\" class=\"#:headerClass#\" #if (colspan) {#colspan=\"#:colspan#\"#}# #if (rowspan) {#rowspan=\"#:rowspan#\"#}#>' + '#if (expandable) {# <span class=\"k-icon k-i-arrow-chevron-#:iconClass# k-color-inherit\" role=\"presentation\"></span>#}#' + '</th>', COLLAPSEMEMBER = 'collapseMember', STATE_EXPANDED = 'k-i-collapse', STATE_COLLAPSED = 'k-i-expand', HEADER_TEMPLATE = '<span>#: data.member.caption || data.member.name #</span>', KPISTATUS_TEMPLATE = '<span class=\"k-icon k-i-kpi-status-#=data.dataItem.value > 0 ? \"open\" : data.dataItem.value < 0 ? \"deny\" : \"hold\"#\" title=\"#:data.dataItem.value#\"></span>', KPITREND_TEMPLATE = '<span class=\"k-icon k-i-kpi-trend-#=data.dataItem.value > 0 ? \"increase\" : data.dataItem.value < 0 ? \"decrease\" : \"equal\"#\" title=\"#:data.dataItem.value#\"></span>', DATACELL_TEMPLATE = '#= data.dataItem ? kendo.htmlEncode(data.dataItem.fmtValue || data.dataItem.value) || \"&nbsp;\" : \"&nbsp;\" #', LAYOUT_TABLE = '<table class=\"k-pivot-layout\">' + '<tr>' + '<td>' + '<div class=\"k-pivot-rowheaders\"></div>' + '</td>' + '<td>' + '<div class=\"k-pivot-table k-state-default\"></div>' + '</td>' + '</tr>' + '</table>';\n        var AXIS_ROWS = 'rows';\n        var AXIS_COLUMNS = 'columns';\n        function normalizeMeasures(measure) {\n            var descriptor = typeof measure === 'string' ? [{ name: measure }] : measure;\n            var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];\n            return map(descriptors, function (d) {\n                if (typeof d === 'string') {\n                    return { name: d };\n                }\n                return {\n                    name: d.name,\n                    type: d.type\n                };\n            });\n        }\n        function normalizeMembers(member) {\n            var descriptor = typeof member === 'string' ? [{\n                    name: [member],\n                    expand: false\n                }] : member;\n            var descriptors = toString.call(descriptor) === '[object Array]' ? descriptor : descriptor !== undefined ? [descriptor] : [];\n            return map(descriptors, function (d) {\n                if (typeof d === 'string') {\n                    return {\n                        name: [d],\n                        expand: false\n                    };\n                }\n                return {\n                    name: toString.call(d.name) === '[object Array]' ? d.name.slice() : [d.name],\n                    expand: d.expand\n                };\n            });\n        }\n        function normalizeName(name) {\n            if (name.indexOf(' ') !== -1) {\n                name = '[\"' + name + '\"]';\n            }\n            return name;\n        }\n        function accumulateMembers(accumulator, rootTuple, tuple, level) {\n            var idx, length;\n            var children;\n            var member;\n            if (!tuple) {\n                tuple = rootTuple;\n            }\n            if (!level) {\n                level = 0;\n            }\n            member = tuple.members[level];\n            if (!member || member.measure) {\n                return;\n            }\n            children = member.children;\n            length = children.length;\n            if (tuple === rootTuple) {\n                accumulator[kendo.stringify([member.name])] = !!length;\n            } else if (length) {\n                accumulator[kendo.stringify(buildPath(tuple, level))] = true;\n            }\n            if (length) {\n                for (idx = 0; idx < length; idx++) {\n                    accumulateMembers(accumulator, rootTuple, children[idx], level);\n                }\n            }\n            accumulateMembers(accumulator, rootTuple, tuple, level + 1);\n        }\n        function descriptorsForAxes(tuples) {\n            var result = {};\n            if (tuples.length) {\n                accumulateMembers(result, tuples[0]);\n            }\n            var descriptors = [];\n            for (var k in result) {\n                descriptors.push({\n                    name: JSON.parse(k),\n                    expand: result[k]\n                });\n            }\n            return descriptors;\n        }\n        function addMissingPathMembers(members, axis) {\n            var tuples = axis.tuples || [];\n            var firstTuple = tuples[0];\n            if (firstTuple && members.length < firstTuple.members.length) {\n                var tupleMembers = firstTuple.members;\n                for (var idx = 0; idx < tupleMembers.length; idx++) {\n                    if (tupleMembers[idx].measure) {\n                        continue;\n                    }\n                    var found = false;\n                    for (var j = 0; j < members.length; j++) {\n                        if (getName(members[j]).indexOf(tupleMembers[idx].hierarchy) === 0) {\n                            found = true;\n                            break;\n                        }\n                    }\n                    if (!found) {\n                        members.push({\n                            name: [tupleMembers[idx].name],\n                            expand: false\n                        });\n                    }\n                }\n            }\n        }\n        function tupleToDescriptors(tuple) {\n            var result = [];\n            var members = tuple.members;\n            for (var idx = 0; idx < members.length; idx++) {\n                if (members[idx].measure) {\n                    continue;\n                }\n                result.push({\n                    name: [members[idx].name],\n                    expand: members[idx].children.length > 0\n                });\n            }\n            return result;\n        }\n        function descriptorsForMembers(axis, members, measures) {\n            axis = axis || {};\n            addMissingPathMembers(members, axis);\n            if (measures.length > 1) {\n                members.push({\n                    name: MEASURES,\n                    measure: true,\n                    children: normalizeMembers(measures)\n                });\n            }\n            var tupletoSearch = { members: members };\n            if (axis.tuples) {\n                var result = findExistingTuple(axis.tuples, tupletoSearch);\n                if (result.tuple) {\n                    members = tupleToDescriptors(result.tuple);\n                }\n            }\n            return members;\n        }\n        function createAggregateGetter(m) {\n            var measureGetter = kendo.getter(m.field, true);\n            return function (aggregatorContext, state) {\n                return m.aggregate(measureGetter(aggregatorContext.dataItem), state, aggregatorContext);\n            };\n        }\n        function isNumber(val) {\n            return typeof val === 'number' && !isNaN(val);\n        }\n        function isDate(val) {\n            return val && val.getTime;\n        }\n        function getScollWidth() {\n            var scrollbar = 0;\n            var div;\n            if (document && document.createElement) {\n                div = document.createElement('div');\n                div.style.cssText = 'overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block';\n                div.innerHTML = '&nbsp;';\n                document.body.appendChild(div);\n                scrollbar = div.offsetWidth - div.scrollWidth;\n                document.body.removeChild(div);\n            }\n            return scrollbar;\n        }\n        var functions = {\n            sum: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator)) {\n                    accumulator = value;\n                } else if (isNumber(value)) {\n                    accumulator += value;\n                }\n                return accumulator;\n            },\n            count: function (value, state) {\n                return (state.accumulator || 0) + 1;\n            },\n            average: {\n                aggregate: function (value, state) {\n                    var accumulator = state.accumulator;\n                    if (state.count === undefined) {\n                        state.count = 0;\n                    }\n                    if (!isNumber(accumulator)) {\n                        accumulator = value;\n                    } else if (isNumber(value)) {\n                        accumulator += value;\n                    }\n                    if (isNumber(value)) {\n                        state.count++;\n                    }\n                    return accumulator;\n                },\n                result: function (state) {\n                    var accumulator = state.accumulator;\n                    if (isNumber(accumulator)) {\n                        accumulator = accumulator / state.count;\n                    }\n                    return accumulator;\n                }\n            },\n            max: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\n                if (accumulator < value && (isNumber(value) || isDate(value))) {\n                    accumulator = value;\n                }\n                return accumulator;\n            },\n            min: function (value, state) {\n                var accumulator = state.accumulator;\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\n                if (accumulator > value && (isNumber(value) || isDate(value))) {\n                    accumulator = value;\n                }\n                return accumulator;\n            }\n        };\n        var PivotCubeBuilder = Class.extend({\n            init: function (options) {\n                this.options = extend({}, this.options, options);\n                this.dimensions = this._normalizeDescriptors('field', this.options.dimensions);\n                this.measures = this._normalizeDescriptors('name', this.options.measures);\n            },\n            _normalizeDescriptors: function (keyField, descriptors) {\n                descriptors = descriptors || {};\n                var fields = {};\n                var field;\n                if (toString.call(descriptors) === '[object Array]') {\n                    for (var idx = 0, length = descriptors.length; idx < length; idx++) {\n                        field = descriptors[idx];\n                        if (typeof field === 'string') {\n                            fields[field] = {};\n                        } else if (field[keyField]) {\n                            fields[field[keyField]] = field;\n                        }\n                    }\n                    descriptors = fields;\n                }\n                return descriptors;\n            },\n            _rootTuples: function (rootNames, measureAggregators) {\n                var aggregatorsLength = measureAggregators.length || 1;\n                var dimensionsSchema = this.dimensions || [];\n                var root, name, parts;\n                var measureIdx = 0;\n                var idx;\n                var rootNamesLength = rootNames.length;\n                var result = [];\n                var keys = [];\n                if (rootNamesLength || measureAggregators.length) {\n                    for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {\n                        root = { members: [] };\n                        for (idx = 0; idx < rootNamesLength; idx++) {\n                            name = rootNames[idx];\n                            parts = name.split('&');\n                            root.members[root.members.length] = {\n                                children: [],\n                                caption: (dimensionsSchema[name] || {}).caption || 'All',\n                                name: name,\n                                levelName: name,\n                                levelNum: '0',\n                                hasChildren: true,\n                                parentName: parts.length > 1 ? parts[0] : undefined,\n                                hierarchy: name\n                            };\n                        }\n                        if (aggregatorsLength > 1) {\n                            root.members[root.members.length] = {\n                                children: [],\n                                caption: measureAggregators[measureIdx].caption,\n                                name: measureAggregators[measureIdx].descriptor.name,\n                                levelName: 'MEASURES',\n                                levelNum: '0',\n                                hasChildren: false,\n                                parentName: undefined,\n                                hierarchy: 'MEASURES'\n                            };\n                        }\n                        result[result.length] = root;\n                    }\n                    keys.push(ROW_TOTAL_KEY);\n                }\n                return {\n                    keys: keys,\n                    tuples: result\n                };\n            },\n            _sortMap: function (map, sortDescriptors) {\n                var sortedMaps = [];\n                var sortTree = [];\n                var flattenTree = [];\n                var mapItem;\n                var key;\n                for (key in map) {\n                    if (!map[key].directParentName) {\n                        sortTree.push($.extend({}, {\n                            name: key,\n                            parentName: map[key].parentName\n                        }));\n                    }\n                }\n                if (!sortTree.length) {\n                    for (key in map) {\n                        sortTree.push($.extend({}, {\n                            name: key,\n                            parentName: map[key].parentName\n                        }));\n                    }\n                }\n                fillSortTree(sortTree, map);\n                for (var i = 0; i < sortDescriptors.length; i++) {\n                    sortItemsTree(sortDescriptors[i].field.split('.').pop(), sortTree, Comparer.create({\n                        field: 'name',\n                        dir: sortDescriptors[i].dir\n                    }));\n                }\n                flattenTree = flatColumns(sortTree);\n                for (var j = 0; j < flattenTree.length; j++) {\n                    mapItem = map[flattenTree[j].name];\n                    mapItem.index = j;\n                    sortedMaps[j] = mapItem;\n                }\n                return sortedMaps;\n            },\n            _expandedTuples: function (map, expanded, measureAggregators, sortDescriptors) {\n                var aggregatorsLength = measureAggregators.length || 1;\n                var dimensionsSchema = this.dimensions || [];\n                var measureIdx;\n                var tuple;\n                var key;\n                var mapItem;\n                var current;\n                var currentKeys;\n                var accumulator = [];\n                var accumulatorKeys = [];\n                var memberInfo;\n                var expandedNames;\n                var parts;\n                var name;\n                var idx;\n                if (sortDescriptors && sortDescriptors.length && !$.isEmptyObject(map)) {\n                    map = this._sortMap(map, sortDescriptors);\n                }\n                for (key in map) {\n                    mapItem = map[key];\n                    memberInfo = this._findExpandedMember(expanded, mapItem.uniquePath);\n                    current = accumulator[memberInfo.index] || [];\n                    currentKeys = accumulatorKeys[memberInfo.index] || [];\n                    expandedNames = memberInfo.member.names;\n                    for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {\n                        tuple = { members: [] };\n                        for (idx = 0; idx < expandedNames.length; idx++) {\n                            if (idx === memberInfo.member.expandedIdx) {\n                                tuple.members[tuple.members.length] = {\n                                    children: [],\n                                    caption: mapItem.value,\n                                    name: mapItem.name,\n                                    hasChildren: false,\n                                    levelNum: 1,\n                                    levelName: mapItem.parentName + mapItem.name,\n                                    parentName: mapItem.parentName,\n                                    hierarchy: mapItem.parentName + mapItem.name\n                                };\n                                if (measureIdx === 0) {\n                                    currentKeys.push(buildPath(tuple, idx).join(''));\n                                }\n                            } else {\n                                name = expandedNames[idx];\n                                parts = name.split('&');\n                                tuple.members[tuple.members.length] = {\n                                    children: [],\n                                    caption: (dimensionsSchema[name] || {}).caption || 'All',\n                                    name: name,\n                                    levelName: name,\n                                    levelNum: '0',\n                                    hasChildren: true,\n                                    parentName: parts.length > 1 ? parts[0] : undefined,\n                                    hierarchy: name\n                                };\n                            }\n                        }\n                        if (aggregatorsLength > 1) {\n                            tuple.members[tuple.members.length] = {\n                                children: [],\n                                caption: measureAggregators[measureIdx].caption,\n                                name: measureAggregators[measureIdx].descriptor.name,\n                                levelName: 'MEASURES',\n                                levelNum: '0',\n                                hasChildren: true,\n                                parentName: undefined,\n                                hierarchy: 'MEASURES'\n                            };\n                        }\n                        current[current.length] = tuple;\n                    }\n                    accumulator[memberInfo.index] = current;\n                    accumulatorKeys[memberInfo.index] = currentKeys;\n                }\n                return {\n                    keys: accumulatorKeys,\n                    tuples: accumulator\n                };\n            },\n            _findExpandedMember: function (members, parentName) {\n                for (var idx = 0; idx < members.length; idx++) {\n                    if (members[idx].uniquePath === parentName) {\n                        return {\n                            member: members[idx],\n                            index: idx\n                        };\n                    }\n                }\n            },\n            _asTuples: function (map, descriptor, measureAggregators, sortDescriptors) {\n                measureAggregators = measureAggregators || [];\n                var rootInfo = this._rootTuples(descriptor.root, measureAggregators);\n                var expandedInfo = this._expandedTuples(map, descriptor.expanded, measureAggregators, sortDescriptors);\n                return {\n                    keys: [].concat.apply(rootInfo.keys, expandedInfo.keys),\n                    tuples: [].concat.apply(rootInfo.tuples, expandedInfo.tuples)\n                };\n            },\n            _measuresInfo: function (measures, rowAxis) {\n                var idx = 0;\n                var length = measures && measures.length;\n                var aggregateNames = [];\n                var resultFuncs = {};\n                var formats = {};\n                var descriptors = this.measures || {};\n                var measure;\n                var name;\n                for (; idx < length; idx++) {\n                    name = measures[idx].descriptor.name;\n                    measure = descriptors[name] || {};\n                    aggregateNames.push(name);\n                    if (measure.result) {\n                        resultFuncs[name] = measure.result;\n                    }\n                    if (measure.format) {\n                        formats[name] = measure.format;\n                    }\n                }\n                return {\n                    names: aggregateNames,\n                    formats: formats,\n                    resultFuncs: resultFuncs,\n                    rowAxis: rowAxis\n                };\n            },\n            _toDataArray: function (map, measuresInfo, rowKeys, columnKeys) {\n                var result = [];\n                var aggregates;\n                var name, i, j, k, n;\n                var row, column, columnKey;\n                var rowMeasureNamesLength = 1;\n                var rowMeasureNames = [];\n                var columnMeasureNames;\n                var rowLength = rowKeys.length || 1;\n                var columnLength = columnKeys.length || 1;\n                if (measuresInfo.rowAxis) {\n                    rowMeasureNames = measuresInfo.names;\n                    rowMeasureNamesLength = rowMeasureNames.length;\n                } else {\n                    columnMeasureNames = measuresInfo.names;\n                }\n                for (i = 0; i < rowLength; i++) {\n                    row = map[rowKeys[i] || ROW_TOTAL_KEY];\n                    for (n = 0; n < rowMeasureNamesLength; n++) {\n                        if (measuresInfo.rowAxis) {\n                            columnMeasureNames = [rowMeasureNames[n]];\n                        }\n                        for (j = 0; j < columnLength; j++) {\n                            columnKey = columnKeys[j] || ROW_TOTAL_KEY;\n                            column = row.items[columnKey];\n                            if (columnKey === ROW_TOTAL_KEY) {\n                                aggregates = row.aggregates;\n                            } else {\n                                aggregates = column ? column.aggregates : {};\n                            }\n                            for (k = 0; k < columnMeasureNames.length; k++) {\n                                name = columnMeasureNames[k];\n                                this._addData(result, aggregates[name], measuresInfo.formats[name], measuresInfo.resultFuncs[name]);\n                            }\n                        }\n                    }\n                }\n                return result;\n            },\n            _addData: function (result, value, format, resultFunc) {\n                var fmtValue = '';\n                var ordinal;\n                if (value) {\n                    value = resultFunc ? resultFunc(value) : value.accumulator;\n                    fmtValue = format ? kendo.format(format, value) : value;\n                }\n                ordinal = result.length;\n                result[ordinal] = {\n                    ordinal: ordinal,\n                    value: value || '',\n                    fmtValue: fmtValue\n                };\n            },\n            _matchDescriptors: function (dataItem, descriptor, getters) {\n                var parts;\n                var parentField;\n                var expectedValue;\n                var names = descriptor.names;\n                var idx = descriptor.expandedIdx;\n                var value;\n                while (idx > 0) {\n                    parts = names[--idx].split('&');\n                    if (parts.length > 1) {\n                        parentField = parts[0];\n                        expectedValue = parts[1];\n                        value = getters[parentField](dataItem);\n                        value = value !== undefined && value !== null ? value.toString() : value;\n                        if (value != expectedValue) {\n                            return false;\n                        }\n                    }\n                }\n                return true;\n            },\n            _calculateAggregate: function (measureAggregators, aggregatorContext, totalItem) {\n                var result = {};\n                var state;\n                var name;\n                for (var measureIdx = 0; measureIdx < measureAggregators.length; measureIdx++) {\n                    name = measureAggregators[measureIdx].descriptor.name;\n                    state = totalItem.aggregates[name] || {};\n                    state.accumulator = measureAggregators[measureIdx].aggregator(aggregatorContext, state);\n                    result[name] = state;\n                }\n                return result;\n            },\n            _processColumns: function (measureAggregators, descriptors, getters, columns, aggregatorContext, rowTotal, state, updateColumn) {\n                var value;\n                var descriptor;\n                var column;\n                var totalItem;\n                var key, name, parentName, path;\n                var dataItem = aggregatorContext.dataItem;\n                var idx = 0;\n                for (; idx < descriptors.length; idx++) {\n                    descriptor = descriptors[idx];\n                    if (!this._matchDescriptors(dataItem, descriptor, getters)) {\n                        continue;\n                    }\n                    path = descriptor.names.slice(0, descriptor.expandedIdx).join('');\n                    name = descriptor.names[descriptor.expandedIdx];\n                    value = getters[name](dataItem);\n                    value = value !== undefined && value !== null ? value.toString() : value;\n                    parentName = name;\n                    name = name + '&' + value;\n                    key = path + name;\n                    column = columns[key] || {\n                        index: state.columnIndex,\n                        parentName: parentName,\n                        name: name,\n                        directParentName: path.indexOf('&') !== -1 ? path : '',\n                        uniquePath: path + parentName,\n                        childrenMap: {},\n                        value: value\n                    };\n                    if (path && columns[path] && !columns[path].childrenMap[path + parentName + '&' + value]) {\n                        columns[path].childrenMap[path + parentName + '&' + value] = true;\n                    }\n                    totalItem = rowTotal.items[key] || { aggregates: {} };\n                    rowTotal.items[key] = {\n                        index: column.index,\n                        aggregates: this._calculateAggregate(measureAggregators, aggregatorContext, totalItem)\n                    };\n                    if (updateColumn) {\n                        if (!columns[key]) {\n                            state.columnIndex++;\n                        }\n                        columns[key] = column;\n                    }\n                }\n            },\n            _measureAggregators: function (options) {\n                var measureDescriptors = options.measures || [];\n                var measures = this.measures || {};\n                var aggregators = [];\n                var descriptor, measure, idx, length;\n                var defaultAggregate, aggregate;\n                if (measureDescriptors.length) {\n                    for (idx = 0, length = measureDescriptors.length; idx < length; idx++) {\n                        descriptor = measureDescriptors[idx];\n                        measure = measures[descriptor.name];\n                        defaultAggregate = null;\n                        if (measure) {\n                            aggregate = measure.aggregate;\n                            if (typeof aggregate === 'string') {\n                                defaultAggregate = functions[aggregate.toLowerCase()];\n                                if (!defaultAggregate) {\n                                    throw new Error('There is no such aggregate function');\n                                }\n                                measure.aggregate = defaultAggregate.aggregate || defaultAggregate;\n                                measure.result = defaultAggregate.result;\n                            }\n                            aggregators.push({\n                                descriptor: descriptor,\n                                caption: measure.caption,\n                                result: measure.result,\n                                aggregator: createAggregateGetter(measure)\n                            });\n                        }\n                    }\n                } else {\n                    aggregators.push({\n                        descriptor: { name: 'default' },\n                        caption: 'default',\n                        aggregator: function () {\n                            return 1;\n                        }\n                    });\n                }\n                return aggregators;\n            },\n            _buildGetters: function (names) {\n                var result = {};\n                var parts;\n                var name;\n                for (var idx = 0; idx < names.length; idx++) {\n                    name = names[idx];\n                    parts = name.split('&');\n                    if (parts.length > 1) {\n                        result[parts[0]] = kendo.getter(parts[0], true);\n                    } else {\n                        result[name] = kendo.getter(normalizeName(name), true);\n                    }\n                }\n                return result;\n            },\n            _parseDescriptors: function (descriptors) {\n                var parsedDescriptors = parseDescriptors(descriptors);\n                var rootNames = getRootNames(parsedDescriptors.root);\n                var expanded = parsedDescriptors.expanded;\n                var result = [];\n                for (var idx = 0; idx < expanded.length; idx++) {\n                    result.push(mapNames(expanded[idx].name, rootNames));\n                }\n                return {\n                    root: rootNames,\n                    expanded: result\n                };\n            },\n            _filter: function (data, filter) {\n                if (!filter) {\n                    return data;\n                }\n                var expr;\n                var idx = 0;\n                var filters = filter.filters;\n                for (; idx < filters.length; idx++) {\n                    expr = filters[idx];\n                    if (expr.operator === 'in') {\n                        filters[idx] = this._normalizeFilter(expr);\n                    }\n                }\n                return new kendo.data.Query(data).filter(filter).data;\n            },\n            _normalizeFilter: function (filter) {\n                var value = filter.value.split(',');\n                var result = [];\n                if (!value.length) {\n                    return value;\n                }\n                for (var idx = 0; idx < value.length; idx++) {\n                    result.push({\n                        field: filter.field,\n                        operator: 'eq',\n                        value: value[idx]\n                    });\n                }\n                return {\n                    logic: 'or',\n                    filters: result\n                };\n            },\n            process: function (data, options) {\n                data = data || [];\n                options = options || {};\n                data = this._filter(data, options.filter);\n                var measures = options.measures || [];\n                var measuresRowAxis = options.measuresAxis === 'rows';\n                var columnDescriptors = options.columns || [];\n                var rowDescriptors = options.rows || [];\n                if (!columnDescriptors.length && rowDescriptors.length && (!measures.length || measures.length && measuresRowAxis)) {\n                    columnDescriptors = rowDescriptors;\n                    rowDescriptors = [];\n                    measuresRowAxis = false;\n                }\n                if (!columnDescriptors.length && !rowDescriptors.length) {\n                    measuresRowAxis = false;\n                }\n                if (!columnDescriptors.length && measures.length) {\n                    columnDescriptors = normalizeMembers(options.measures);\n                }\n                columnDescriptors = this._parseDescriptors(columnDescriptors);\n                rowDescriptors = this._parseDescriptors(rowDescriptors);\n                var aggregatedData = {};\n                var columns = {};\n                var rows = {};\n                var rowValue;\n                var state = { columnIndex: 0 };\n                var measureAggregators = this._measureAggregators(options);\n                var columnGetters = this._buildGetters(columnDescriptors.root);\n                var rowGetters = this._buildGetters(rowDescriptors.root);\n                var processed = false;\n                var expandedColumns = columnDescriptors.expanded;\n                var expandedRows = rowDescriptors.expanded;\n                var dataItem;\n                var aggregatorContext;\n                var hasExpandedRows = expandedRows.length !== 0;\n                var rowIdx, rowDescriptor, rowName, rowTotal;\n                var key, path, parentName, value;\n                var columnsInfo, rowsInfo;\n                var length = data.length;\n                var idx = 0;\n                if (columnDescriptors.root.length || rowDescriptors.root.length) {\n                    processed = true;\n                    for (idx = 0; idx < length; idx++) {\n                        dataItem = data[idx];\n                        aggregatorContext = {\n                            dataItem: dataItem,\n                            index: idx\n                        };\n                        rowTotal = aggregatedData[ROW_TOTAL_KEY] || {\n                            items: {},\n                            aggregates: {}\n                        };\n                        this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, rowTotal, state, !hasExpandedRows);\n                        rowTotal.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, rowTotal);\n                        aggregatedData[ROW_TOTAL_KEY] = rowTotal;\n                        for (rowIdx = 0; rowIdx < expandedRows.length; rowIdx++) {\n                            rowDescriptor = expandedRows[rowIdx];\n                            if (!this._matchDescriptors(dataItem, rowDescriptor, rowGetters)) {\n                                this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, {\n                                    items: {},\n                                    aggregates: {}\n                                }, state, true);\n                                continue;\n                            }\n                            path = rowDescriptor.names.slice(0, rowDescriptor.expandedIdx).join('');\n                            rowName = rowDescriptor.names[rowDescriptor.expandedIdx];\n                            parentName = rowName;\n                            rowValue = rowGetters[rowName](dataItem);\n                            rowValue = rowValue !== undefined ? rowValue.toString() : rowValue;\n                            rowName = rowName + '&' + rowValue;\n                            key = path + rowName;\n                            rows[key] = {\n                                uniquePath: path + parentName,\n                                parentName: parentName,\n                                name: rowName,\n                                value: rowValue\n                            };\n                            value = aggregatedData[key] || {\n                                items: {},\n                                aggregates: {}\n                            };\n                            this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, value, state, true);\n                            value.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, value);\n                            aggregatedData[key] = value;\n                        }\n                    }\n                }\n                if (processed && length) {\n                    if (measureAggregators.length > 1 && (!options.columns || !options.columns.length)) {\n                        columnDescriptors = {\n                            root: [],\n                            expanded: []\n                        };\n                    }\n                    columnsInfo = this._asTuples(columns, columnDescriptors, measuresRowAxis ? [] : measureAggregators, options.sort ? options.sort : []);\n                    rowsInfo = this._asTuples(rows, rowDescriptors, measuresRowAxis ? measureAggregators : [], options.sort ? options.sort : []);\n                    columns = columnsInfo.tuples;\n                    rows = rowsInfo.tuples;\n                    aggregatedData = this._toDataArray(aggregatedData, this._measuresInfo(measureAggregators, measuresRowAxis), rowsInfo.keys, columnsInfo.keys);\n                } else {\n                    aggregatedData = columns = rows = [];\n                }\n                return {\n                    axes: {\n                        columns: { tuples: columns },\n                        rows: { tuples: rows }\n                    },\n                    data: aggregatedData\n                };\n            }\n        });\n        var PivotTransport = Class.extend({\n            init: function (options, transport) {\n                this.transport = transport;\n                this.options = transport.options || {};\n                if (!this.transport.discover) {\n                    if (isFunction(options.discover)) {\n                        this.discover = options.discover;\n                    }\n                }\n            },\n            read: function (options) {\n                return this.transport.read(options);\n            },\n            update: function (options) {\n                return this.transport.update(options);\n            },\n            create: function (options) {\n                return this.transport.create(options);\n            },\n            destroy: function (options) {\n                return this.transport.destroy(options);\n            },\n            discover: function (options) {\n                if (this.transport.discover) {\n                    return this.transport.discover(options);\n                }\n                options.success({});\n            },\n            catalog: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).catalog;\n                }\n                var connection = options.connection || {};\n                connection.catalog = val;\n                this.options.connection = connection;\n                $.extend(this.transport.options, { connection: connection });\n            },\n            cube: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).cube;\n                }\n                var connection = options.connection || {};\n                connection.cube = val;\n                this.options.connection = connection;\n                extend(true, this.transport.options, { connection: connection });\n            }\n        });\n        var PivotDataSourceV2 = DataSource.extend({\n            init: function (options) {\n                DataSource.fn.init.call(this, extend(true, {}, {}, options));\n                var transportOptions = this.options.transport || {};\n                if ((this.options.type || 'xmla').toLowerCase() === 'xmla') {\n                    this._online = true;\n                    this.transport = new XmlaTransportV2(transportOptions);\n                }\n                this._columns = normalizeMembers(this.options.columns);\n                this._rows = normalizeMembers(this.options.rows);\n                var measures = this.options.measures || [];\n                if (toString.call(measures) === '[object Object]') {\n                    this._measuresAxis = measures.axis || 'columns';\n                    measures = measures.values || [];\n                }\n                this._measures = normalizeMeasures(measures);\n            },\n            options: {\n                serverSorting: true,\n                serverPaging: true,\n                serverFiltering: true,\n                serverGrouping: true,\n                serverAggregates: true\n            },\n            axes: function () {\n                return {\n                    columns: normalizeAxis(this.columns()),\n                    rows: normalizeAxis(this.rows())\n                };\n            },\n            catalog: function (val) {\n                if (val === undefined) {\n                    return this.transport.catalog();\n                }\n                this.transport.catalog(val);\n                this._mergeState({});\n                this.read();\n            },\n            cube: function (val) {\n                if (val === undefined) {\n                    return this.transport.cube();\n                }\n                this.transport.cube(val);\n                this._mergeState({});\n                this.read();\n            },\n            measuresAxis: function () {\n                return this._measuresAxis || 'columns';\n            },\n            fetch: function () {\n                if (this.options.type.toLowerCase() === 'xmla' && (this._data === undefined || this._data.length === 0)) {\n                    this._query();\n                }\n            },\n            read: function (data) {\n                var that = this;\n                var isPrevented = that.trigger(REQUESTSTART, { type: READ });\n                var params = that._params(data);\n                if (!isPrevented) {\n                    that.trigger(PROGRESS);\n                    that.transport.read({\n                        data: params,\n                        success: function (newDataState) {\n                            that._saveState(newDataState);\n                            that.trigger(REQUESTEND, {\n                                response: newDataState,\n                                type: READ\n                            });\n                            that.trigger(CHANGE);\n                            if (that._preventRefresh) {\n                                that._preventRefresh = false;\n                            }\n                        },\n                        error: function (err) {\n                            that.trigger(ERROR, { error: err });\n                        }\n                    });\n                }\n            },\n            _params: function (data) {\n                var that = this;\n                var options = DataSource.fn._params.call(that, data);\n                options = extend({\n                    connection: that.options.transport.connection,\n                    columnAxes: JSON.parse(JSON.stringify(that._columns)),\n                    rowAxes: JSON.parse(JSON.stringify(that._rows)),\n                    measuresAxis: that.measuresAxis(),\n                    measureAxes: that._measures\n                }, options);\n                if (options.filter) {\n                    options.filter = normalizeFilter(options.filter);\n                    options.filter = (options.filter || {}).filters;\n                }\n                if (options.sort) {\n                    options.sort = normalizeSort(options.sort);\n                }\n                return options;\n            },\n            discover: function (options) {\n                var that = this, transport = that.transport;\n                if (transport.discover) {\n                    return transport.discover(options);\n                }\n            },\n            schemaMeasures: function () {\n                var that = this;\n                return that.discover({\n                    command: 'schemaMeasures',\n                    restrictions: {\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube()\n                    }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaKPIs: function () {\n                var that = this;\n                return that.discover({\n                    command: 'schemaKPIs',\n                    restrictions: {\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube()\n                    }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaDimensions: function () {\n                var that = this;\n                return that.discover({\n                    command: 'schemaDimensions',\n                    restrictions: {\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube()\n                    }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaHierarchies: function (dimensionName) {\n                var that = this;\n                return that.discover({\n                    command: 'schemaHierarchies',\n                    restrictions: {\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube(),\n                        dimensionUniqueName: dimensionName\n                    }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaLevels: function (hierarchyName) {\n                var that = this;\n                return that.discover({\n                    command: 'schemaLevels',\n                    restrictions: {\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube(),\n                        hierarchyUniqueName: hierarchyName\n                    }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaCubes: function () {\n                var that = this;\n                return that.discover({\n                    command: 'schemaCubes',\n                    restrictions: { catalogName: that.transport.catalog() }\n                }, function (response) {\n                    return response;\n                });\n            },\n            schemaCatalogs: function () {\n                var that = this;\n                return that.discover({ command: 'schemaCatalogs' }, function (response) {\n                    return response;\n                });\n            },\n            schemaMembers: function (restrictions) {\n                var that = this;\n                return that.discover({\n                    command: 'schemaMembers',\n                    restrictions: extend({\n                        catalogName: that.transport.catalog(),\n                        cubeName: that.transport.cube()\n                    }, restrictions)\n                }, function (response) {\n                    return response;\n                });\n            },\n            _saveState: function (state) {\n                var that = this;\n                that._columnTuples = state.columns;\n                that._rowTuples = state.rows;\n                that._view = state.data;\n            },\n            columns: function (val) {\n                if (val === undefined) {\n                    return this._columns;\n                }\n                this._columns = normalizeMembers(val);\n                this.read();\n            },\n            rows: function (val) {\n                if (val === undefined) {\n                    return this._rows;\n                }\n                this._rows = normalizeMembers(val);\n                this.read();\n            },\n            measures: function (val) {\n                if (val === undefined) {\n                    return this._measures;\n                }\n                this._measures = normalizeMeasures(val);\n                this.read();\n            },\n            _mergeState: function (options) {\n                options = DataSource.fn._mergeState.call(this, options);\n                return options;\n            },\n            _query: function (options) {\n                var that = this;\n                var params = extend({}, {\n                    sort: that.sort(),\n                    measuresAxis: that.measuresAxis(),\n                    filter: that.filter()\n                }, options);\n                var state = this._mergeState(params);\n                return this.read(state);\n            }\n        });\n        var PivotDataSource = DataSource.extend({\n            init: function (options) {\n                var cube = ((options || {}).schema || {}).cube;\n                var measuresAxis = 'columns';\n                var measures;\n                var schema = {\n                    axes: identity,\n                    cubes: identity,\n                    catalogs: identity,\n                    measures: identity,\n                    dimensions: identity,\n                    hierarchies: identity,\n                    levels: identity,\n                    members: identity\n                };\n                if (cube) {\n                    schema = $.extend(schema, this._cubeSchema(cube));\n                    this.cubeBuilder = new PivotCubeBuilder(cube);\n                }\n                DataSource.fn.init.call(this, extend(true, {}, { schema: schema }, options));\n                this.transport = new PivotTransport(this.options.transport || {}, this.transport);\n                this._columns = normalizeMembers(this.options.columns);\n                this._rows = normalizeMembers(this.options.rows);\n                measures = this.options.measures || [];\n                if (toString.call(measures) === '[object Object]') {\n                    measuresAxis = measures.axis || 'columns';\n                    measures = measures.values || [];\n                }\n                this._measures = normalizeMeasures(measures);\n                this._measuresAxis = measuresAxis;\n                this._skipNormalize = 0;\n                this._axes = {};\n            },\n            _cubeSchema: function (cube) {\n                return {\n                    dimensions: function () {\n                        var result = [];\n                        var dimensions = cube.dimensions;\n                        for (var key in dimensions) {\n                            result.push({\n                                name: key,\n                                caption: dimensions[key].caption || key,\n                                uniqueName: key,\n                                defaultHierarchy: key,\n                                type: 1\n                            });\n                        }\n                        if (cube.measures) {\n                            result.push({\n                                name: MEASURES,\n                                caption: MEASURES,\n                                uniqueName: MEASURES,\n                                type: 2\n                            });\n                        }\n                        return result;\n                    },\n                    hierarchies: function () {\n                        return [];\n                    },\n                    measures: function () {\n                        var result = [];\n                        var measures = cube.measures;\n                        for (var key in measures) {\n                            result.push({\n                                name: key,\n                                caption: key,\n                                uniqueName: key,\n                                aggregator: key\n                            });\n                        }\n                        return result;\n                    },\n                    members: $.proxy(function (response, restrictions) {\n                        var name = restrictions.levelUniqueName || restrictions.memberUniqueName;\n                        var schemaData = this.options.schema.data;\n                        var dataGetter = isFunction(schemaData) ? schemaData : kendo.getter(schemaData, true);\n                        var data = this.options.data && dataGetter(this.options.data) || this._rawData || [];\n                        var result = [];\n                        var getter;\n                        var value;\n                        var idx = 0;\n                        var distinct = {};\n                        if (name) {\n                            name = name.split('.')[0];\n                        }\n                        if (!restrictions.treeOp) {\n                            result.push({\n                                caption: cube.dimensions[name].caption || name,\n                                childrenCardinality: '1',\n                                dimensionUniqueName: name,\n                                hierarchyUniqueName: name,\n                                levelUniqueName: name,\n                                name: name,\n                                uniqueName: name\n                            });\n                            return result;\n                        }\n                        getter = kendo.getter(normalizeName(name), true);\n                        for (; idx < data.length; idx++) {\n                            value = getter(data[idx]);\n                            if ((value || value === 0) && !distinct[value]) {\n                                distinct[value] = true;\n                                result.push({\n                                    caption: value,\n                                    childrenCardinality: '0',\n                                    dimensionUniqueName: name,\n                                    hierarchyUniqueName: name,\n                                    levelUniqueName: name,\n                                    name: value,\n                                    uniqueName: value\n                                });\n                            }\n                        }\n                        return result;\n                    }, this)\n                };\n            },\n            options: {\n                serverSorting: true,\n                serverPaging: true,\n                serverFiltering: true,\n                serverGrouping: true,\n                serverAggregates: true\n            },\n            catalog: function (val) {\n                if (val === undefined) {\n                    return this.transport.catalog();\n                }\n                this.transport.catalog(val);\n                this._mergeState({});\n                this._axes = {};\n                this.data([]);\n            },\n            cube: function (val) {\n                if (val === undefined) {\n                    return this.transport.cube();\n                }\n                this.transport.cube(val);\n                this._axes = {};\n                this._mergeState({});\n                this.data([]);\n            },\n            axes: function () {\n                return this._axes;\n            },\n            columns: function (val) {\n                if (val === undefined) {\n                    return this._columns;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._columns = normalizeMembers(val);\n                this.query({\n                    columns: val,\n                    rows: this.rowsAxisDescriptors(),\n                    measures: this.measures(),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            rows: function (val) {\n                if (val === undefined) {\n                    return this._rows;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._rows = normalizeMembers(val);\n                this.query({\n                    columns: this.columnsAxisDescriptors(),\n                    rows: val,\n                    measures: this.measures(),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            measures: function (val) {\n                if (val === undefined) {\n                    return this._measures;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this.query({\n                    columns: this.columnsAxisDescriptors(),\n                    rows: this.rowsAxisDescriptors(),\n                    measures: normalizeMeasures(val),\n                    sort: this.sort(),\n                    filter: this.filter()\n                });\n            },\n            measuresAxis: function () {\n                return this._measuresAxis || 'columns';\n            },\n            _expandPath: function (path, axis) {\n                var origin = axis === 'columns' ? 'columns' : 'rows';\n                var other = axis === 'columns' ? 'rows' : 'columns';\n                var members = normalizeMembers(path);\n                var memberToExpand = getName(members[members.length - 1]);\n                this._lastExpanded = origin;\n                members = descriptorsForMembers(this.axes()[origin], members, this.measures());\n                for (var idx = 0; idx < members.length; idx++) {\n                    var memberName = getName(members[idx]);\n                    if (memberName === memberToExpand) {\n                        if (members[idx].expand) {\n                            return;\n                        }\n                        members[idx].expand = true;\n                    } else {\n                        members[idx].expand = false;\n                    }\n                }\n                var descriptors = {};\n                descriptors[origin] = members;\n                descriptors[other] = this._descriptorsForAxis(other);\n                this._query(descriptors);\n            },\n            _descriptorsForAxis: function (axis) {\n                var axes = this.axes();\n                var descriptors = this[axis]() || [];\n                if (axes && axes[axis] && axes[axis].tuples && axes[axis].tuples[0]) {\n                    descriptors = descriptorsForAxes(axes[axis].tuples || []);\n                }\n                return descriptors;\n            },\n            columnsAxisDescriptors: function () {\n                return this._descriptorsForAxis('columns');\n            },\n            rowsAxisDescriptors: function () {\n                return this._descriptorsForAxis('rows');\n            },\n            _process: function (data, e) {\n                this._view = data;\n                e = e || {};\n                e.items = e.items || this._view;\n                this.trigger(CHANGE, e);\n            },\n            _query: function (options) {\n                var that = this;\n                if (!options) {\n                    this._skipNormalize += 1;\n                    this._clearAxesData = true;\n                }\n                return that.query(extend({}, {\n                    page: that.page(),\n                    pageSize: that.pageSize(),\n                    sort: that.sort(),\n                    filter: that.filter(),\n                    group: that.group(),\n                    aggregate: that.aggregate(),\n                    columns: this.columnsAxisDescriptors(),\n                    rows: this.rowsAxisDescriptors(),\n                    measures: this.measures()\n                }, options));\n            },\n            query: function (options) {\n                var state = this._mergeState(options);\n                if (this._data.length && this.cubeBuilder) {\n                    this._params(state);\n                    this._updateLocalData(this._pristineData);\n                    return $.Deferred().resolve().promise();\n                }\n                return this.read(state);\n            },\n            _mergeState: function (options) {\n                options = DataSource.fn._mergeState.call(this, options);\n                if (options !== undefined) {\n                    this._measures = normalizeMeasures(options.measures);\n                    if (options.columns) {\n                        options.columns = normalizeMembers(options.columns);\n                    } else if (!options.columns) {\n                        this._columns = [];\n                    }\n                    if (options.rows) {\n                        options.rows = normalizeMembers(options.rows);\n                    } else if (!options.rows) {\n                        this._rows = [];\n                    }\n                }\n                return options;\n            },\n            filter: function (val) {\n                if (val === undefined) {\n                    return this._filter;\n                }\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._query({\n                    filter: val,\n                    page: 1\n                });\n            },\n            expandColumn: function (path) {\n                this._expandPath(path, 'columns');\n            },\n            expandRow: function (path) {\n                this._expandPath(path, 'rows');\n            },\n            success: function (data) {\n                var originalData;\n                if (this.cubeBuilder) {\n                    originalData = (this.reader.data(data) || []).slice(0);\n                }\n                DataSource.fn.success.call(this, data);\n                if (originalData) {\n                    this._pristineData = originalData;\n                }\n            },\n            _processResult: function (data, axes) {\n                if (this.cubeBuilder) {\n                    var processedData = this.cubeBuilder.process(data, this._requestData);\n                    data = processedData.data;\n                    axes = processedData.axes;\n                }\n                var columnIndexes, rowIndexes;\n                var tuples, resultAxis, measures, axisToSkip;\n                var columnDescriptors = this.columns();\n                var rowDescriptors = this.rows();\n                var hasColumnTuples = axes.columns && axes.columns.tuples;\n                if (!columnDescriptors.length && rowDescriptors.length && hasColumnTuples && (this._rowMeasures().length || !this.measures().length)) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n                if (!columnDescriptors.length && !rowDescriptors.length && this.measuresAxis() === 'rows' && hasColumnTuples) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n                this._axes = {\n                    columns: normalizeAxis(this._axes.columns),\n                    rows: normalizeAxis(this._axes.rows)\n                };\n                axes = {\n                    columns: normalizeAxis(axes.columns),\n                    rows: normalizeAxis(axes.rows)\n                };\n                columnIndexes = this._normalizeTuples(axes.columns.tuples, this._axes.columns.tuples, columnDescriptors, this._columnMeasures());\n                rowIndexes = this._normalizeTuples(axes.rows.tuples, this._axes.rows.tuples, rowDescriptors, this._rowMeasures());\n                if (this._skipNormalize > 0) {\n                    this._skipNormalize -= 1;\n                }\n                if (!this.cubeBuilder) {\n                    data = this._normalizeData({\n                        columnsLength: axes.columns.tuples.length,\n                        rowsLength: axes.rows.tuples.length,\n                        columnIndexes: columnIndexes,\n                        rowIndexes: rowIndexes,\n                        data: data\n                    });\n                }\n                if (this._lastExpanded == 'rows') {\n                    tuples = axes.columns.tuples;\n                    measures = this._columnMeasures();\n                    resultAxis = validateAxis(axes.columns, this._axes.columns, measures);\n                    if (resultAxis) {\n                        axisToSkip = 'columns';\n                        axes.columns = resultAxis;\n                        adjustDataByColumn(tuples, resultAxis.tuples, axes.rows.tuples.length, measures, data);\n                        if (!this.cubeBuilder) {\n                            data = this._normalizeData({\n                                columnsLength: membersCount(axes.columns.tuples, measures),\n                                rowsLength: axes.rows.tuples.length,\n                                data: data\n                            });\n                        }\n                    }\n                } else if (this._lastExpanded == 'columns') {\n                    tuples = axes.rows.tuples;\n                    measures = this._rowMeasures();\n                    resultAxis = validateAxis(axes.rows, this._axes.rows, measures);\n                    if (resultAxis) {\n                        axisToSkip = 'rows';\n                        axes.rows = resultAxis;\n                        adjustDataByRow(tuples, resultAxis.tuples, axes.columns.tuples.length, measures, data);\n                        if (!this.cubeBuilder) {\n                            data = this._normalizeData({\n                                columnsLength: membersCount(axes.rows.tuples, measures),\n                                rowsLength: axes.columns.tuples.length,\n                                data: data\n                            });\n                        }\n                    }\n                }\n                this._lastExpanded = null;\n                var result = this._mergeAxes(axes, data, axisToSkip);\n                this._axes = result.axes;\n                return result.data;\n            },\n            _readData: function (data) {\n                var axes = this.reader.axes(data);\n                var newData = this.reader.data(data);\n                if (this.cubeBuilder) {\n                    this._rawData = newData;\n                }\n                return this._processResult(newData, axes);\n            },\n            _createTuple: function (tuple, measure, buildRoot) {\n                var members = tuple.members;\n                var length = members.length;\n                var root = { members: [] };\n                var levelName, levelNum;\n                var name, parentName;\n                var hasChildren;\n                var hierarchy;\n                var caption;\n                var member;\n                var idx = 0;\n                if (measure) {\n                    length -= 1;\n                }\n                for (; idx < length; idx++) {\n                    member = members[idx];\n                    levelNum = Number(member.levelNum);\n                    name = member.name;\n                    parentName = member.parentName;\n                    caption = member.caption || name;\n                    hasChildren = member.hasChildren;\n                    hierarchy = member.hierarchy;\n                    levelName = member.levelName;\n                    if (buildRoot) {\n                        caption = 'All';\n                        if (levelNum === 0) {\n                            parentName = member.name;\n                        } else {\n                            levelNum -= 1;\n                        }\n                        hasChildren = true;\n                        name = hierarchy = levelName = parentName;\n                    }\n                    root.members.push({\n                        name: name,\n                        children: [],\n                        caption: caption,\n                        levelName: levelName,\n                        levelNum: levelNum.toString(),\n                        hasChildren: hasChildren,\n                        hierarchy: hierarchy,\n                        parentName: !buildRoot ? parentName : ''\n                    });\n                }\n                if (measure) {\n                    root.members.push({\n                        name: measure.name,\n                        children: []\n                    });\n                }\n                return root;\n            },\n            _hasRoot: function (target, source, descriptors) {\n                if (source.length) {\n                    return findExistingTuple(source, target).tuple;\n                }\n                var members = target.members;\n                var member;\n                var descriptor;\n                var isRoot = true;\n                var levelNum;\n                for (var idx = 0, length = members.length; idx < length; idx++) {\n                    member = members[idx];\n                    levelNum = Number(member.levelNum) || 0;\n                    descriptor = descriptors[idx];\n                    if (!(levelNum === 0 || descriptor && member.name === getName(descriptor))) {\n                        isRoot = false;\n                        break;\n                    }\n                }\n                return isRoot;\n            },\n            _mergeAxes: function (sourceAxes, data, axisToSkip) {\n                var columnMeasures = this._columnMeasures();\n                var rowMeasures = this._rowMeasures();\n                var axes = this.axes();\n                var startIndex, tuples;\n                var oldRowsLength = membersCount(axes.rows.tuples, rowMeasures);\n                var newRowsLength = sourceAxes.rows.tuples.length;\n                var oldColumnsLength = membersCount(axes.columns.tuples, columnMeasures);\n                var newColumnsLength = sourceAxes.columns.tuples.length;\n                if (axisToSkip == 'columns') {\n                    newColumnsLength = oldColumnsLength;\n                    tuples = sourceAxes.columns.tuples;\n                } else {\n                    tuples = parseSource(sourceAxes.columns.tuples, columnMeasures);\n                    data = prepareDataOnColumns(tuples, data);\n                }\n                var mergedColumns = mergeTuples(axes.columns.tuples, tuples, columnMeasures);\n                if (axisToSkip == 'rows') {\n                    newRowsLength = membersCount(sourceAxes.rows.tuples, rowMeasures);\n                    tuples = sourceAxes.rows.tuples;\n                } else {\n                    tuples = parseSource(sourceAxes.rows.tuples, rowMeasures);\n                    data = prepareDataOnRows(tuples, data);\n                }\n                var mergedRows = mergeTuples(axes.rows.tuples, tuples, rowMeasures);\n                axes.columns.tuples = mergedColumns.tuples;\n                axes.rows.tuples = mergedRows.tuples;\n                if (oldColumnsLength !== membersCount(axes.columns.tuples, columnMeasures)) {\n                    startIndex = mergedColumns.index + findDataIndex(mergedColumns.parsedRoot, mergedColumns.memberIndex, columnMeasures);\n                    var offset = oldColumnsLength + newColumnsLength;\n                    data = this._mergeColumnData(data, startIndex, newRowsLength, newColumnsLength, offset);\n                } else if (oldRowsLength !== membersCount(axes.rows.tuples, rowMeasures)) {\n                    startIndex = mergedRows.index + findDataIndex(mergedRows.parsedRoot, mergedRows.memberIndex, rowMeasures);\n                    data = this._mergeRowData(data, startIndex, newRowsLength, newColumnsLength);\n                }\n                if (axes.columns.tuples.length === 0 && axes.rows.tuples.length === 0) {\n                    data = [];\n                }\n                return {\n                    axes: axes,\n                    data: data\n                };\n            },\n            _mergeColumnData: function (newData, columnIndex, rowsLength, columnsLength, offset) {\n                var data = this.data().toJSON();\n                var rowIndex, index, drop = 0, toAdd;\n                var columnMeasures = Math.max(this._columnMeasures().length, 1);\n                rowsLength = Math.max(rowsLength, 1);\n                if (data.length > 0) {\n                    drop = columnMeasures;\n                    offset -= columnMeasures;\n                }\n                for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                    index = columnIndex + rowIndex * offset;\n                    toAdd = newData.splice(0, columnsLength);\n                    toAdd.splice(0, drop);\n                    [].splice.apply(data, [\n                        index,\n                        0\n                    ].concat(toAdd));\n                }\n                return data;\n            },\n            _mergeRowData: function (newData, rowIndex, rowsLength, columnsLength) {\n                var data = this.data().toJSON();\n                var idx, dataIndex, toAdd;\n                var rowMeasures = Math.max(this._rowMeasures().length, 1);\n                columnsLength = Math.max(columnsLength, 1);\n                if (data.length > 0) {\n                    rowsLength -= rowMeasures;\n                    newData.splice(0, columnsLength * rowMeasures);\n                }\n                for (idx = 0; idx < rowsLength; idx++) {\n                    toAdd = newData.splice(0, columnsLength);\n                    dataIndex = rowIndex * columnsLength + idx * columnsLength;\n                    [].splice.apply(data, [\n                        dataIndex,\n                        0\n                    ].concat(toAdd));\n                }\n                return data;\n            },\n            _columnMeasures: function () {\n                var measures = this.measures();\n                var columnMeasures = [];\n                if (this.measuresAxis() === 'columns') {\n                    if (this.columns().length === 0) {\n                        columnMeasures = measures;\n                    } else if (measures.length > 1) {\n                        columnMeasures = measures;\n                    }\n                }\n                return columnMeasures;\n            },\n            _rowMeasures: function () {\n                var measures = this.measures();\n                var rowMeasures = [];\n                if (this.measuresAxis() === 'rows') {\n                    if (this.rows().length === 0) {\n                        rowMeasures = measures;\n                    } else if (measures.length > 1) {\n                        rowMeasures = measures;\n                    }\n                }\n                return rowMeasures;\n            },\n            _updateLocalData: function (data, state) {\n                if (this.cubeBuilder) {\n                    if (state) {\n                        this._requestData = state;\n                    }\n                    data = this._processResult(data);\n                }\n                this._data = this._observe(data);\n                this._ranges = [];\n                this._addRange(this._data);\n                this._total = this._data.length;\n                this._pristineTotal = this._total;\n                this._process(this._data);\n            },\n            data: function (value) {\n                var that = this;\n                if (value !== undefined) {\n                    this._pristineData = value.slice(0);\n                    this._updateLocalData(value, {\n                        columns: this.columns(),\n                        rows: this.rows(),\n                        measures: this.measures()\n                    });\n                } else {\n                    return that._data;\n                }\n            },\n            _normalizeTuples: function (tuples, source, descriptors, measures) {\n                var length = measures.length || 1;\n                var idx = 0;\n                var roots = [];\n                var indexes = {};\n                var measureIdx = 0;\n                var tuple, memberIdx, last;\n                if (!tuples.length) {\n                    return;\n                }\n                if (this._skipNormalize <= 0 && !this._hasRoot(tuples[0], source, descriptors)) {\n                    this._skipNormalize = 0;\n                    for (; idx < length; idx++) {\n                        roots.push(this._createTuple(tuples[0], measures[idx], true));\n                        indexes[idx] = idx;\n                    }\n                    tuples.splice.apply(tuples, [\n                        0,\n                        tuples.length\n                    ].concat(roots).concat(tuples));\n                    idx = length;\n                }\n                if (measures.length) {\n                    last = tuple = tuples[idx];\n                    memberIdx = tuple.members.length - 1;\n                    while (tuple) {\n                        if (measureIdx >= length) {\n                            measureIdx = 0;\n                        }\n                        if (tuple.members[memberIdx].name !== measures[measureIdx].name) {\n                            tuples.splice(idx, 0, this._createTuple(tuple, measures[measureIdx]));\n                            indexes[idx] = idx;\n                        }\n                        idx += 1;\n                        measureIdx += 1;\n                        tuple = tuples[idx];\n                        if (length > measureIdx && (!tuple || tupleName(last, memberIdx - 1) !== tupleName(tuple, memberIdx - 1))) {\n                            for (; measureIdx < length; measureIdx++) {\n                                tuples.splice(idx, 0, this._createTuple(last, measures[measureIdx]));\n                                indexes[idx] = idx;\n                                idx += 1;\n                            }\n                            tuple = tuples[idx];\n                        }\n                        last = tuple;\n                    }\n                }\n                return indexes;\n            },\n            _addMissingDataItems: function (result, metadata) {\n                while (metadata.rowIndexes[parseInt(result.length / metadata.columnsLength, 10)] !== undefined) {\n                    for (var idx = 0; idx < metadata.columnsLength; idx++) {\n                        result = addEmptyDataItem(result);\n                    }\n                }\n                while (metadata.columnIndexes[result.length % metadata.columnsLength] !== undefined) {\n                    result = addEmptyDataItem(result);\n                }\n                return result;\n            },\n            _normalizeOrdinals: function (result, dataItem, metadata) {\n                var lastOrdinal = metadata.lastOrdinal;\n                if (!dataItem) {\n                    return addEmptyDataItem(result);\n                }\n                if (dataItem.ordinal - lastOrdinal > 1) {\n                    lastOrdinal += 1;\n                    while (lastOrdinal < dataItem.ordinal && result.length < metadata.length) {\n                        result = this._addMissingDataItems(addEmptyDataItem(result), metadata);\n                        lastOrdinal += 1;\n                    }\n                }\n                dataItem.ordinal = result.length;\n                result[result.length] = dataItem;\n                return result;\n            },\n            _normalizeData: function (options) {\n                var data = options.data;\n                var dataIdx = 0;\n                var dataItem;\n                var result = [];\n                var lastOrdinal;\n                var length;\n                options.lastOrdinal = 0;\n                options.columnIndexes = options.columnIndexes || {};\n                options.rowIndexes = options.rowIndexes || {};\n                options.columnsLength = options.columnsLength || 1;\n                options.rowsLength = options.rowsLength || 1;\n                options.length = options.columnsLength * options.rowsLength;\n                length = options.length;\n                if (data.length === length) {\n                    return data;\n                }\n                while (result.length < length) {\n                    dataItem = data[dataIdx++];\n                    if (dataItem) {\n                        lastOrdinal = dataItem.ordinal;\n                    }\n                    result = this._normalizeOrdinals(this._addMissingDataItems(result, options), dataItem, options);\n                    options.lastOrdinal = lastOrdinal;\n                }\n                return result;\n            },\n            discover: function (options, converter) {\n                var that = this, transport = that.transport;\n                return $.Deferred(function (deferred) {\n                    transport.discover(extend({\n                        success: function (response) {\n                            response = that.reader.parse(response);\n                            if (that._handleCustomErrors(response)) {\n                                return;\n                            }\n                            if (converter) {\n                                response = converter(response);\n                            }\n                            deferred.resolve(response);\n                        },\n                        error: function (response, status, error) {\n                            deferred.reject(response);\n                            that.error(response, status, error);\n                        }\n                    }, options));\n                }).promise().done(function () {\n                    that.trigger('schemaChange');\n                });\n            },\n            schemaMeasures: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaMeasures',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.measures(response);\n                });\n            },\n            schemaKPIs: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaKPIs',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.kpis(response);\n                });\n            },\n            schemaDimensions: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaDimensions',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.dimensions(response);\n                });\n            },\n            schemaHierarchies: function (dimensionName) {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaHierarchies',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube(),\n                            dimensionUniqueName: dimensionName\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.hierarchies(response);\n                });\n            },\n            schemaLevels: function (hierarchyName) {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaLevels',\n                        restrictions: {\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube(),\n                            hierarchyUniqueName: hierarchyName\n                        }\n                    }\n                }, function (response) {\n                    return that.reader.levels(response);\n                });\n            },\n            schemaCubes: function () {\n                var that = this;\n                return that.discover({\n                    data: {\n                        command: 'schemaCubes',\n                        restrictions: { catalogName: that.transport.catalog() }\n                    }\n                }, function (response) {\n                    return that.reader.cubes(response);\n                });\n            },\n            schemaCatalogs: function () {\n                var that = this;\n                return that.discover({ data: { command: 'schemaCatalogs' } }, function (response) {\n                    return that.reader.catalogs(response);\n                });\n            },\n            schemaMembers: function (restrictions) {\n                var that = this;\n                var success = function (restrictions) {\n                    return function (response) {\n                        return that.reader.members(response, restrictions);\n                    };\n                }(restrictions);\n                return that.discover({\n                    data: {\n                        command: 'schemaMembers',\n                        restrictions: extend({\n                            catalogName: that.transport.catalog(),\n                            cubeName: that.transport.cube()\n                        }, restrictions)\n                    }\n                }, success);\n            },\n            _params: function (data) {\n                if (this._clearAxesData) {\n                    this._axes = {};\n                    this._data = this._observe([]);\n                    this._clearAxesData = false;\n                    this.trigger(STATERESET);\n                }\n                var options = DataSource.fn._params.call(this, data);\n                options = extend({\n                    measures: this.measures(),\n                    measuresAxis: this.measuresAxis(),\n                    columns: this.columns(),\n                    rows: this.rows()\n                }, options);\n                if (this.cubeBuilder) {\n                    this._requestData = options;\n                }\n                return options;\n            }\n        });\n        function flatColumns(columns) {\n            var result = [];\n            for (var idx = 0; idx < columns.length; idx++) {\n                result.push(columns[idx]);\n                if (columns[idx].children) {\n                    result = result.concat(flatColumns(columns[idx].children));\n                }\n            }\n            return result;\n        }\n        function sortItemsTree(field, items, sortFunction) {\n            for (var i = 0; i < items.length; i++) {\n                if (items[i].children && items[i].children.length) {\n                    sortItemsTree(field, items[i].children, sortFunction);\n                }\n            }\n            if (items[0].parentName != field) {\n                return;\n            }\n            items = items.sort(sortFunction);\n        }\n        function fillSortTree(items, map) {\n            for (var i = 0; i < items.length; i++) {\n                var currentItem = map[items[i].name];\n                if (!$.isEmptyObject(currentItem.childrenMap)) {\n                    items[i].children = [];\n                    for (var name in currentItem.childrenMap) {\n                        items[i].children.push($.extend({}, {\n                            name: name,\n                            parentName: map[name].parentName\n                        }));\n                    }\n                    fillSortTree(items[i].children, map);\n                }\n            }\n        }\n        function addEmptyDataItem(result) {\n            result[result.length] = {\n                value: '',\n                fmtValue: '',\n                ordinal: result.length\n            };\n            return result;\n        }\n        function validateAxis(newAxis, axis, measures) {\n            if (newAxis.tuples.length < membersCount(axis.tuples, measures)) {\n                return axis;\n            }\n            return;\n        }\n        function adjustDataByColumn(sourceTuples, targetTuples, rowsLength, measures, data) {\n            var columnIdx, rowIdx, dataIdx;\n            var columnsLength = sourceTuples.length;\n            var targetColumnsLength = membersCount(targetTuples, measures);\n            var measuresLength = measures.length || 1;\n            for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {\n                for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {\n                    dataIdx = tupleIndex(sourceTuples[columnIdx], targetTuples) * measuresLength;\n                    dataIdx += columnIdx % measuresLength;\n                    data[rowIdx * columnsLength + columnIdx].ordinal = rowIdx * targetColumnsLength + dataIdx;\n                }\n            }\n        }\n        function adjustDataByRow(sourceTuples, targetTuples, columnsLength, measures, data) {\n            var columnIdx, rowIdx, dataIdx;\n            var rowsLength = sourceTuples.length;\n            var measuresLength = measures.length || 1;\n            for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {\n                dataIdx = tupleIndex(sourceTuples[rowIdx], targetTuples);\n                dataIdx *= measuresLength;\n                dataIdx += rowIdx % measuresLength;\n                for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {\n                    data[rowIdx * columnsLength + columnIdx].ordinal = dataIdx * columnsLength + columnIdx;\n                }\n            }\n        }\n        function tupleIndex(tuple, collection) {\n            return findExistingTuple(collection, tuple).index;\n        }\n        function membersCount(tuples, measures) {\n            if (!tuples.length) {\n                return 0;\n            }\n            var queue = tuples.slice();\n            var current = queue.shift();\n            var result = 1;\n            while (current) {\n                if (current.members) {\n                    [].push.apply(queue, current.members);\n                } else if (current.children) {\n                    if (!current.measure) {\n                        result += current.children.length;\n                    }\n                    [].push.apply(queue, current.children);\n                }\n                current = queue.shift();\n            }\n            if (measures.length) {\n                result = result * measures.length;\n            }\n            return result;\n        }\n        function normalizeAxis(axis) {\n            if (!axis) {\n                axis = { tuples: [] };\n            }\n            if (!axis.tuples) {\n                axis.tuples = [];\n            }\n            return axis;\n        }\n        function findDataIndex(tuple, memberIndex, measures) {\n            if (!tuple) {\n                return 0;\n            }\n            var measuresLength = Math.max(measures.length, 1);\n            var tuples = tuple.members.slice(0, memberIndex);\n            var current = tuples.shift();\n            var counter = measuresLength;\n            while (current) {\n                if (current.name === MEASURES) {\n                    counter += measuresLength - 1;\n                } else if (current.children) {\n                    [].push.apply(tuples, current.children);\n                } else {\n                    counter++;\n                    [].push.apply(tuples, current.members);\n                }\n                current = tuples.shift();\n            }\n            return counter;\n        }\n        function mergeTuples(target, source, measures) {\n            if (!source[0]) {\n                return {\n                    parsedRoot: null,\n                    tuples: target,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            var result = findExistingTuple(target, source[0]);\n            if (!result.tuple) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            var targetMembers = result.tuple.members;\n            var sourceMembers = source[0].members;\n            var memberIndex = -1;\n            if (targetMembers.length !== sourceMembers.length) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n            for (var idx = 0, length = targetMembers.length; idx < length; idx++) {\n                if (!targetMembers[idx].measure && sourceMembers[idx].children[0]) {\n                    if (memberIndex == -1 && sourceMembers[idx].children.length) {\n                        memberIndex = idx;\n                    }\n                    targetMembers[idx].children = sourceMembers[idx].children;\n                }\n            }\n            measures = Math.max(measures.length, 1);\n            return {\n                parsedRoot: result.tuple,\n                index: result.index * measures,\n                memberIndex: memberIndex,\n                tuples: target\n            };\n        }\n        function equalTuples(first, second) {\n            var equal = true;\n            var idx, length;\n            first = first.members;\n            second = second.members;\n            for (idx = 0, length = first.length; idx < length; idx++) {\n                if (first[idx].measure || second[idx].measure) {\n                    continue;\n                }\n                equal = equal && getName(first[idx]) === getName(second[idx]);\n            }\n            return equal;\n        }\n        function findExistingTuple(tuples, toFind) {\n            var idx, length, tuple, found, counter = 0;\n            var memberIndex, membersLength, member;\n            for (idx = 0, length = tuples.length; idx < length; idx++) {\n                tuple = tuples[idx];\n                if (equalTuples(tuple, toFind)) {\n                    return {\n                        tuple: tuple,\n                        index: counter\n                    };\n                }\n                counter++;\n                for (memberIndex = 0, membersLength = tuple.members.length; memberIndex < membersLength; memberIndex++) {\n                    member = tuple.members[memberIndex];\n                    if (member.measure) {\n                        continue;\n                    }\n                    found = findExistingTuple(member.children, toFind);\n                    counter += found.index;\n                    if (found.tuple) {\n                        return {\n                            tuple: found.tuple,\n                            index: counter\n                        };\n                    }\n                }\n            }\n            return { index: counter };\n        }\n        function addMembers(members, map) {\n            var member, i, len, path = '';\n            for (i = 0, len = members.length; i < len; i++) {\n                member = members[i];\n                path += member.name;\n                if (!map[path]) {\n                    map[path] = member;\n                }\n            }\n        }\n        function findParentMember(tuple, map) {\n            var members = tuple.members;\n            var i, len, member, path = '';\n            var parentPath = '';\n            var parentMember;\n            for (i = 0, len = members.length; i < len; i++) {\n                member = members[i];\n                if (parentMember) {\n                    if (map[path + member.name]) {\n                        path += member.name;\n                        parentMember = map[path];\n                        continue;\n                    } else if (map[path + member.parentName]) {\n                        return map[path + member.parentName];\n                    } else if (map[parentPath + member.parentName]) {\n                        return map[parentPath + member.parentName];\n                    } else {\n                        return map[parentPath];\n                    }\n                }\n                path += member.name;\n                parentMember = map[member.parentName];\n                if (!parentMember) {\n                    parentMember = map[path];\n                    if (!parentMember) {\n                        return null;\n                    }\n                }\n                if (parentMember) {\n                    parentPath += parentMember.name;\n                }\n            }\n            return parentMember;\n        }\n        function measurePosition(tuple, measures) {\n            if (measures.length === 0) {\n                return -1;\n            }\n            var measure = measures[0];\n            var members = tuple.members;\n            for (var idx = 0, len = members.length; idx < len; idx++) {\n                if (members[idx].name == measure.name) {\n                    return idx;\n                }\n            }\n        }\n        function normalizeTupleMeasures(tuple, index) {\n            if (index < 0) {\n                return;\n            }\n            var member = {\n                name: MEASURES,\n                measure: true,\n                children: [$.extend({\n                        members: [],\n                        dataIndex: tuple.dataIndex\n                    }, tuple.members[index])]\n            };\n            tuple.members.splice(index, 1, member);\n            tuple.dataIndex = undefined;\n        }\n        function parseSource(tuples, measures) {\n            if (tuples.length < 1) {\n                return [];\n            }\n            var result = [];\n            var map = {};\n            var measureIndex = measurePosition(tuples[0], measures);\n            for (var i = 0; i < tuples.length; i++) {\n                var tuple = tuples[i];\n                tuple.dataIndex = i;\n                normalizeTupleMeasures(tuple, measureIndex);\n                var parentMember = findParentMember(tuple, map);\n                if (parentMember) {\n                    if (measureIndex < 0 || !parentMember.measure) {\n                        parentMember.children.push(tuple);\n                    } else {\n                        parentMember.children.push(tuple.members[measureIndex].children[0]);\n                    }\n                } else {\n                    result.push(tuple);\n                }\n                addMembers(tuple.members, map);\n            }\n            return result;\n        }\n        function prepareDataOnRows(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\n            var result = [];\n            var indices = buildDataIndices(tuples);\n            var rowsLength = indices.length;\n            var columnsLength = Math.max(data.length / rowsLength, 1);\n            var rowIndex, columnIndex, targetIndex, sourceIndex;\n            var calcIndex;\n            for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                targetIndex = columnsLength * rowIndex;\n                sourceIndex = columnsLength * indices[rowIndex];\n                for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {\n                    calcIndex = parseInt(sourceIndex + columnIndex, 10);\n                    result[parseInt(targetIndex + columnIndex, 10)] = data[calcIndex] || {\n                        value: '',\n                        fmtValue: '',\n                        ordinal: calcIndex\n                    };\n                }\n            }\n            return result;\n        }\n        function prepareDataOnColumns(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\n            var result = [];\n            var indices = buildDataIndices(tuples);\n            var columnsLength = indices.length;\n            var rowsLength = Math.max(data.length / columnsLength, 1);\n            var columnIndex, rowIndex, dataIndex, calcIndex;\n            for (rowIndex = 0; rowIndex < rowsLength; rowIndex++) {\n                dataIndex = columnsLength * rowIndex;\n                for (columnIndex = 0; columnIndex < columnsLength; columnIndex++) {\n                    calcIndex = indices[columnIndex] + dataIndex;\n                    result[dataIndex + columnIndex] = data[calcIndex] || {\n                        value: '',\n                        fmtValue: '',\n                        ordinal: calcIndex\n                    };\n                }\n            }\n            return result;\n        }\n        function buildDataIndices(tuples) {\n            tuples = tuples.slice();\n            var result = [];\n            var tuple = tuples.shift();\n            var idx, length, spliceIndex, children, member;\n            while (tuple) {\n                if (tuple.dataIndex !== undefined) {\n                    result.push(tuple.dataIndex);\n                }\n                spliceIndex = 0;\n                for (idx = 0, length = tuple.members.length; idx < length; idx++) {\n                    member = tuple.members[idx];\n                    children = member.children;\n                    if (member.measure) {\n                        [].splice.apply(tuples, [\n                            0,\n                            0\n                        ].concat(children));\n                    } else {\n                        [].splice.apply(tuples, [\n                            spliceIndex,\n                            0\n                        ].concat(children));\n                    }\n                    spliceIndex += children.length;\n                }\n                tuple = tuples.shift();\n            }\n            return result;\n        }\n        PivotDataSourceV2.create = function (options) {\n            options = options && options.push ? { data: options } : options;\n            var dataSource = options || {}, data = dataSource.data;\n            dataSource.data = data;\n            if (!(dataSource instanceof PivotDataSourceV2) && dataSource instanceof kendo.data.DataSource) {\n                throw new Error('Incorrect DataSource type. Only PivotDataSource instances are supported');\n            }\n            return dataSource instanceof PivotDataSourceV2 ? dataSource : new PivotDataSourceV2(dataSource);\n        };\n        PivotDataSource.create = function (options) {\n            options = options && options.push ? { data: options } : options;\n            var dataSource = options || {}, data = dataSource.data;\n            dataSource.data = data;\n            if (!(dataSource instanceof PivotDataSource) && dataSource instanceof kendo.data.DataSource) {\n                throw new Error('Incorrect DataSource type. Only PivotDataSource instances are supported');\n            }\n            return dataSource instanceof PivotDataSource ? dataSource : new PivotDataSource(dataSource);\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 expandMemberDescriptor(names, sort) {\n            var idx = names.length - 1;\n            var name = names[idx];\n            var sortDescriptor;\n            sortDescriptor = sortDescriptorForMember(sort, name);\n            if (sortDescriptor && sortDescriptor.dir) {\n                name = 'ORDER(' + name + '.Children,' + sortDescriptor.field + '.CurrentMember.MEMBER_CAPTION,' + sortDescriptor.dir + ')';\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 = sort.length; idx < length; idx++) {\n                if (member.indexOf(sort[idx].field) === 0) {\n                    return sort[idx];\n                }\n            }\n            return null;\n        }\n        function crossJoin(names) {\n            var result = 'CROSSJOIN({';\n            var r;\n            if (names.length > 2) {\n                r = names.pop();\n                result += crossJoin(names);\n            } else {\n                result += names.shift();\n                r = names.pop();\n            }\n            result += '},{';\n            result += r;\n            result += '})';\n            return result;\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 measureNames(measures) {\n            var idx = 0;\n            var length = measures.length;\n            var result = [];\n            var measure;\n            for (; idx < length; idx++) {\n                measure = measures[idx];\n                result.push(measure.name !== undefined ? measure.name : measure);\n            }\n            return result;\n        }\n        function indexOf(name, items) {\n            var idx, length, index = -1;\n            for (idx = 0, length = items.length; idx < length; idx++) {\n                if (getName(items[idx]) === name) {\n                    index = idx;\n                    break;\n                }\n            }\n            return index;\n        }\n        function getName(name) {\n            name = name.name || name;\n            if (toString.call(name) === '[object Array]') {\n                name = name[name.length - 1];\n            }\n            return name;\n        }\n        function getRootNames(members) {\n            var length = members.length;\n            var names = [];\n            var idx = 0;\n            for (; idx < length; idx++) {\n                names.push(members[idx].name[0]);\n            }\n            return names;\n        }\n        function mapNames(names, rootNames) {\n            var name;\n            var rootName;\n            var j;\n            var idx = 0;\n            var length = names.length;\n            var rootLength = rootNames.length;\n            rootNames = rootNames.slice(0);\n            for (; idx < length; idx++) {\n                name = names[idx];\n                for (j = 0; j < rootLength; j++) {\n                    rootName = baseHierarchyPath(rootNames[j]);\n                    if (name.indexOf(rootName) !== -1) {\n                        rootNames[j] = name;\n                        break;\n                    }\n                }\n            }\n            return {\n                names: rootNames,\n                expandedIdx: j,\n                uniquePath: rootNames.slice(0, j + 1).join('')\n            };\n        }\n        function parseDescriptors(members) {\n            var expanded = [];\n            var child = [];\n            var root = [];\n            var member;\n            var j, l;\n            var idx = 0;\n            var length = members.length;\n            var name;\n            var hierarchyName;\n            var found;\n            for (; idx < length; idx++) {\n                member = members[idx];\n                name = member.name;\n                found = false;\n                if (toString.call(name) !== '[object Array]') {\n                    member.name = name = [name];\n                }\n                if (name.length > 1) {\n                    child.push(member);\n                } else {\n                    hierarchyName = baseHierarchyPath(name[0]);\n                    for (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                root: root,\n                expanded: expanded\n            };\n        }\n        function serializeMembers(members, measures, sort) {\n            var command = '';\n            members = members || [];\n            var expanded = parseDescriptors(members);\n            var root = expanded.root;\n            var rootNames = getRootNames(root);\n            var crossJoinCommands = [];\n            expanded = expanded.expanded;\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).names;\n                    crossJoinCommands.push(crossJoinCommand(names, measures));\n                }\n                command += crossJoinCommands.join(',');\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        var filterFunctionFormats = {\n            contains: ', InStr({0}.CurrentMember.MEMBER_CAPTION,\"{1}\") > 0',\n            doesnotcontain: ', InStr({0}.CurrentMember.MEMBER_CAPTION,\"{1}\")',\n            startswith: ', Left({0}.CurrentMember.MEMBER_CAPTION,Len(\"{1}\"))=\"{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        };\n        function serializeExpression(expression) {\n            var command = '';\n            var value = expression.value;\n            var field = expression.field;\n            var operator = expression.operator;\n            if (operator == 'in') {\n                command += '{';\n                command += value;\n                command += '}';\n            } else {\n                command += operator == 'neq' || operator == 'doesnotcontain' ? '-' : '';\n                command += 'Filter(';\n                command += field + '.MEMBERS';\n                command += kendo.format(filterFunctionFormats[operator], field, value);\n                command += ')';\n            }\n            return command;\n        }\n        function serializeFilters(filter, cube) {\n            var command = '', current;\n            var filters = filter.filters;\n            var length = filters.length;\n            var idx;\n            for (idx = length - 1; idx >= 0; idx--) {\n                current = 'SELECT (';\n                current += serializeExpression(filters[idx]);\n                current += ') ON 0';\n                if (idx == length - 1) {\n                    current += ' FROM [' + cube + ']';\n                    command = current;\n                } else {\n                    command = current + ' FROM ( ' + command + ' )';\n                }\n            }\n            return command;\n        }\n        function serializeOptions(parentTagName, options, capitalize) {\n            var result = '';\n            if (options) {\n                result += '<' + parentTagName + '>';\n                var value;\n                for (var key in options) {\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                result += '</' + parentTagName + '>';\n            } else {\n                result += '<' + parentTagName + '/>';\n            }\n            return result;\n        }\n        var xmlaDiscoverCommands = {\n            schemaCubes: 'MDSCHEMA_CUBES',\n            schemaCatalogs: 'DBSCHEMA_CATALOGS',\n            schemaMeasures: 'MDSCHEMA_MEASURES',\n            schemaDimensions: 'MDSCHEMA_DIMENSIONS',\n            schemaHierarchies: 'MDSCHEMA_HIERARCHIES',\n            schemaLevels: 'MDSCHEMA_LEVELS',\n            schemaMembers: 'MDSCHEMA_MEMBERS',\n            schemaKPIs: 'MDSCHEMA_KPIS'\n        };\n        var convertersMap = {\n            read: function (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                command += 'SELECT NON EMPTY {';\n                var columns = options.columns || [];\n                var rows = options.rows || [];\n                var measures = options.measures || [];\n                var measuresRowAxis = options.measuresAxis === 'rows';\n                var sort = options.sort || [];\n                if (!columns.length && rows.length && (!measures.length || measures.length && measuresRowAxis)) {\n                    columns = rows;\n                    rows = [];\n                    measuresRowAxis = false;\n                }\n                if (!columns.length && !rows.length) {\n                    measuresRowAxis = false;\n                }\n                if (columns.length) {\n                    command += serializeMembers(columns, !measuresRowAxis ? measures : [], sort);\n                } else if (measures.length && !measuresRowAxis) {\n                    command += measureNames(measures).join(',');\n                }\n                command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON COLUMNS';\n                if (rows.length || measuresRowAxis && measures.length > 1) {\n                    command += ', NON EMPTY {';\n                    if (rows.length) {\n                        command += serializeMembers(rows, measuresRowAxis ? measures : [], sort);\n                    } else {\n                        command += measureNames(measures).join(',');\n                    }\n                    command += '} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON ROWS';\n                }\n                if (options.filter) {\n                    command += ' FROM ';\n                    command += '(';\n                    command += serializeFilters(options.filter, options.connection.cube);\n                    command += ')';\n                } else {\n                    command += ' FROM [' + options.connection.cube + ']';\n                }\n                if (measures.length == 1 && columns.length) {\n                    command += ' WHERE (' + measureNames(measures).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            discover: function (options) {\n                options = options || {};\n                var command = '<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"><Header/><Body><Discover xmlns=\"urn:schemas-microsoft-com:xml-analysis\">';\n                command += '<RequestType>' + (xmlaDiscoverCommands[options.command] || options.command) + '</RequestType>';\n                command += '<Restrictions>' + serializeOptions('RestrictionList', options.restrictions, true) + '</Restrictions>';\n                if (options.connection && options.connection.catalog) {\n                    options.properties = $.extend({}, { Catalog: options.connection.catalog }, options.properties);\n                }\n                command += '<Properties>' + serializeOptions('PropertyList', options.properties) + '</Properties>';\n                command += '</Discover></Body></Envelope>';\n                return command;\n            }\n        };\n        var XmlaTransport = kendo.data.RemoteTransport.extend({\n            init: function (options) {\n                var originalOptions = options;\n                options = this.options = extend(true, {}, this.options, options);\n                kendo.data.RemoteTransport.call(this, options);\n                if (isFunction(originalOptions.discover)) {\n                    this.discover = originalOptions.discover;\n                } else if (typeof originalOptions.discover === 'string') {\n                    this.options.discover = { url: originalOptions.discover };\n                } else if (!originalOptions.discover) {\n                    this.options.discover = this.options.read;\n                }\n            },\n            setup: function (options, type) {\n                options.data = options.data || {};\n                $.extend(true, options.data, { connection: this.options.connection });\n                return kendo.data.RemoteTransport.fn.setup.call(this, options, type);\n            },\n            options: {\n                read: {\n                    dataType: 'text',\n                    contentType: 'text/xml',\n                    type: 'POST'\n                },\n                discover: {\n                    dataType: 'text',\n                    contentType: 'text/xml',\n                    type: 'POST'\n                },\n                parameterMap: function (options, type) {\n                    return convertersMap[type](options, type);\n                }\n            },\n            discover: function (options) {\n                return $.ajax(this.setup(options, 'discover'));\n            }\n        });\n        var XmlaTransportV2 = Class.extend({\n            init: function (options) {\n                options = this.options = extend(true, {}, this.options, options);\n            },\n            setup: function (options) {\n                return $.extend(true, options || {}, { connection: this.options.connection });\n            },\n            read: function (options) {\n                var that = this, success, error;\n                var fetchOptions = that.setup(options.data, READ);\n                success = options.success || $.noop;\n                error = options.error || $.noop;\n                if (options.parameterMap) {\n                    fetchOptions = that.parameterMap(fetchOptions, READ);\n                }\n                fetchData({ url: that.options.read }, fetchOptions).then(createDataState).then(function (newDataState) {\n                    success(newDataState);\n                }).catch(function (err) {\n                    error(err);\n                });\n            },\n            catalog: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).catalog;\n                }\n                var connection = options.connection || {};\n                connection.catalog = val;\n                this.options.connection = connection;\n                $.extend(this.transport.options, { connection: connection });\n            },\n            cube: function (val) {\n                var options = this.options || {};\n                if (val === undefined) {\n                    return (options.connection || {}).cube;\n                }\n                var connection = options.connection || {};\n                connection.cube = val;\n                this.options.connection = connection;\n                extend(true, this.transport.options, { connection: connection });\n            },\n            discover: function (options) {\n                return fetchDiscover({ url: this.options.read }, options);\n            }\n        });\n        function asArray(object) {\n            if (object == null) {\n                return [];\n            }\n            var type = toString.call(object);\n            if (type !== '[object Array]') {\n                return [object];\n            }\n            return object;\n        }\n        function translateAxis(axis) {\n            var result = { tuples: [] };\n            var tuples = asArray(kendo.getter('Tuples.Tuple', true)(axis));\n            var captionGetter = kendo.getter('Caption[\\'#text\\']');\n            var unameGetter = kendo.getter('UName[\\'#text\\']');\n            var levelNameGetter = kendo.getter('LName[\\'#text\\']');\n            var levelNumGetter = kendo.getter('LNum[\\'#text\\']');\n            var childrenGetter = kendo.getter('CHILDREN_CARDINALITY[\\'#text\\']', true);\n            var hierarchyGetter = kendo.getter('[\\'@Hierarchy\\']');\n            var parentNameGetter = kendo.getter('PARENT_UNIQUE_NAME[\\'#text\\']', true);\n            for (var idx = 0; idx < tuples.length; idx++) {\n                var members = [];\n                var member = asArray(tuples[idx].Member);\n                for (var memberIdx = 0; memberIdx < member.length; memberIdx++) {\n                    members.push({\n                        children: [],\n                        caption: captionGetter(member[memberIdx]),\n                        name: unameGetter(member[memberIdx]),\n                        levelName: levelNameGetter(member[memberIdx]),\n                        levelNum: levelNumGetter(member[memberIdx]),\n                        hasChildren: parseInt(childrenGetter(member[memberIdx]), 10) > 0,\n                        parentName: parentNameGetter(member[memberIdx]),\n                        hierarchy: hierarchyGetter(member[memberIdx])\n                    });\n                }\n                result.tuples.push({ members: members });\n            }\n            return result;\n        }\n        var schemaDataReaderMap = {\n            cubes: {\n                name: kendo.getter('CUBE_NAME[\\'#text\\']', true),\n                caption: kendo.getter('CUBE_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                type: kendo.getter('CUBE_TYPE[\\'#text\\']', true)\n            },\n            catalogs: {\n                name: kendo.getter('CATALOG_NAME[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true)\n            },\n            measures: {\n                name: kendo.getter('MEASURE_NAME[\\'#text\\']', true),\n                caption: kendo.getter('MEASURE_CAPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('MEASURE_UNIQUE_NAME[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                aggregator: kendo.getter('MEASURE_AGGREGATOR[\\'#text\\']', true),\n                groupName: kendo.getter('MEASUREGROUP_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('MEASURE_DISPLAY_FOLDER[\\'#text\\']', true),\n                defaultFormat: kendo.getter('DEFAULT_FORMAT_STRING[\\'#text\\']', true)\n            },\n            kpis: {\n                name: kendo.getter('KPI_NAME[\\'#text\\']', true),\n                caption: kendo.getter('KPI_CAPTION[\\'#text\\']', true),\n                value: kendo.getter('KPI_VALUE[\\'#text\\']', true),\n                goal: kendo.getter('KPI_GOAL[\\'#text\\']', true),\n                status: kendo.getter('KPI_STATUS[\\'#text\\']', true),\n                trend: kendo.getter('KPI_TREND[\\'#text\\']', true),\n                statusGraphic: kendo.getter('KPI_STATUS_GRAPHIC[\\'#text\\']', true),\n                trendGraphic: kendo.getter('KPI_TREND_GRAPHIC[\\'#text\\']', true),\n                description: kendo.getter('KPI_DESCRIPTION[\\'#text\\']', true),\n                groupName: kendo.getter('MEASUREGROUP_NAME[\\'#text\\']', true)\n            },\n            dimensions: {\n                name: kendo.getter('DIMENSION_NAME[\\'#text\\']', true),\n                caption: kendo.getter('DIMENSION_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                defaultHierarchy: kendo.getter('DEFAULT_HIERARCHY[\\'#text\\']', true),\n                type: kendo.getter('DIMENSION_TYPE[\\'#text\\']', true)\n            },\n            hierarchies: {\n                name: kendo.getter('HIERARCHY_NAME[\\'#text\\']', true),\n                caption: kendo.getter('HIERARCHY_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('HIERARCHY_DISPLAY_FOLDER[\\'#text\\']', true),\n                origin: kendo.getter('HIERARCHY_ORIGIN[\\'#text\\']', true),\n                defaultMember: kendo.getter('DEFAULT_MEMBER[\\'#text\\']', true)\n            },\n            levels: {\n                name: kendo.getter('LEVEL_NAME[\\'#text\\']', true),\n                caption: kendo.getter('LEVEL_CAPTION[\\'#text\\']', true),\n                description: kendo.getter('DESCRIPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                displayFolder: kendo.getter('LEVEL_DISPLAY_FOLDER[\\'#text\\']', true),\n                orderingProperty: kendo.getter('LEVEL_ORDERING_PROPERTY[\\'#text\\']', true),\n                origin: kendo.getter('LEVEL_ORIGIN[\\'#text\\']', true),\n                hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true)\n            },\n            members: {\n                name: kendo.getter('MEMBER_NAME[\\'#text\\']', true),\n                caption: kendo.getter('MEMBER_CAPTION[\\'#text\\']', true),\n                uniqueName: kendo.getter('MEMBER_UNIQUE_NAME[\\'#text\\']', true),\n                dimensionUniqueName: kendo.getter('DIMENSION_UNIQUE_NAME[\\'#text\\']', true),\n                hierarchyUniqueName: kendo.getter('HIERARCHY_UNIQUE_NAME[\\'#text\\']', true),\n                levelUniqueName: kendo.getter('LEVEL_UNIQUE_NAME[\\'#text\\']', true),\n                childrenCardinality: kendo.getter('CHILDREN_CARDINALITY[\\'#text\\']', true)\n            }\n        };\n        var xmlaReaderMethods = [\n            'axes',\n            'catalogs',\n            'cubes',\n            'dimensions',\n            'hierarchies',\n            'levels',\n            'measures'\n        ];\n        var XmlaDataReader = kendo.data.XmlDataReader.extend({\n            init: function (options) {\n                kendo.data.XmlDataReader.call(this, options);\n                this._extend(options);\n            },\n            _extend: function (options) {\n                var idx = 0;\n                var length = xmlaReaderMethods.length;\n                var methodName;\n                var option;\n                for (; idx < length; idx++) {\n                    methodName = xmlaReaderMethods[idx];\n                    option = options[methodName];\n                    if (option && option !== identity) {\n                        this[methodName] = option;\n                    }\n                }\n            },\n            parse: function (xml) {\n                var result = kendo.data.XmlDataReader.fn.parse(xml.replace(/<(\\/?)(\\w|-)+:/g, '<$1'));\n                return kendo.getter('[\\'Envelope\\'][\\'Body\\']', true)(result);\n            },\n            errors: function (root) {\n                var fault = kendo.getter('[\\'Fault\\']', true)(root);\n                if (fault) {\n                    return [{\n                            faultstring: kendo.getter('faultstring[\\'#text\\']', true)(fault),\n                            faultcode: kendo.getter('faultcode[\\'#text\\']', true)(fault)\n                        }];\n                }\n                return null;\n            },\n            axes: function (root) {\n                root = kendo.getter('ExecuteResponse[\"return\"].root', true)(root);\n                var axes = asArray(kendo.getter('Axes.Axis', true)(root));\n                var axis;\n                var result = {\n                    columns: {},\n                    rows: {}\n                };\n                for (var idx = 0; idx < axes.length; idx++) {\n                    axis = axes[idx];\n                    if (axis['@name'].toLowerCase() !== 'sliceraxis') {\n                        if (!result.columns.tuples) {\n                            result.columns = translateAxis(axis);\n                        } else {\n                            result.rows = translateAxis(axis);\n                        }\n                    }\n                }\n                return result;\n            },\n            data: function (root) {\n                root = kendo.getter('ExecuteResponse[\"return\"].root', true)(root);\n                var cells = asArray(kendo.getter('CellData.Cell', true)(root));\n                var result = [];\n                var ordinalGetter = kendo.getter('[\\'@CellOrdinal\\']');\n                var valueGetter = kendo.getter('Value[\\'#text\\']');\n                var fmtValueGetter = kendo.getter('FmtValue[\\'#text\\']');\n                for (var idx = 0; idx < cells.length; idx++) {\n                    result.push({\n                        value: valueGetter(cells[idx]),\n                        fmtValue: fmtValueGetter(cells[idx]),\n                        ordinal: parseInt(ordinalGetter(cells[idx]), 10)\n                    });\n                }\n                return result;\n            },\n            _mapSchema: function (root, getters) {\n                root = kendo.getter('DiscoverResponse[\"return\"].root', true)(root);\n                var rows = asArray(kendo.getter('row', true)(root));\n                var result = [];\n                for (var idx = 0; idx < rows.length; idx++) {\n                    var obj = {};\n                    for (var key in getters) {\n                        obj[key] = getters[key](rows[idx]);\n                    }\n                    result.push(obj);\n                }\n                return result;\n            },\n            measures: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.measures);\n            },\n            kpis: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.kpis);\n            },\n            hierarchies: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.hierarchies);\n            },\n            levels: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.levels);\n            },\n            dimensions: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.dimensions);\n            },\n            cubes: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.cubes);\n            },\n            catalogs: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.catalogs);\n            },\n            members: function (root) {\n                return this._mapSchema(root, schemaDataReaderMap.members);\n            }\n        });\n        extend(true, kendo.data, {\n            PivotDataSource: PivotDataSource,\n            PivotDataSourceV2: PivotDataSourceV2,\n            XmlaTransport: XmlaTransport,\n            XmlaDataReader: XmlaDataReader,\n            PivotCubeBuilder: PivotCubeBuilder,\n            transports: { xmla: XmlaTransport },\n            readers: { xmla: XmlaDataReader }\n        });\n        var sortExpr = function (expressions, name) {\n            if (!expressions) {\n                return null;\n            }\n            for (var idx = 0, length = expressions.length; idx < length; idx++) {\n                if (expressions[idx].field === name) {\n                    return expressions[idx];\n                }\n            }\n            return null;\n        };\n        var removeExpr = function (expressions, name) {\n            var result = [];\n            for (var idx = 0, length = expressions.length; idx < length; idx++) {\n                if (expressions[idx].field !== name) {\n                    result.push(expressions[idx]);\n                }\n            }\n            return result;\n        };\n        kendo.ui.PivotSettingTarget = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that.element.addClass('k-pivot-setting');\n                that.dataSource = kendo.data.PivotDataSource.create(options.dataSource);\n                that._refreshHandler = $.proxy(that.refresh, that);\n                that.dataSource.first(CHANGE, that._refreshHandler);\n                if (!options.template) {\n                    that.options.template = '<div data-' + kendo.ns + 'name=\"${data.name || data}\">${data.name || data}' + (that.options.enabled ? '<a class=\"k-button k-button-icon k-flat\"><span class=\"k-icon k-i-close k-setting-delete\"></span></a>' : '') + '</div>';\n                }\n                that.template = kendo.template(that.options.template);\n                that.emptyTemplate = kendo.template(that.options.emptyTemplate);\n                that._sortable();\n                that.element.on('click' + NS, '.k-button,.k-item', function (e) {\n                    var target = $(e.target);\n                    var name = target.closest('[' + kendo.attr('name') + ']').attr(kendo.attr('name'));\n                    if (!name) {\n                        return;\n                    }\n                    if (target.hasClass('k-i-close')) {\n                        that.remove(name);\n                    } else if (that.options.sortable && target[0] === e.currentTarget) {\n                        that.sort({\n                            field: name,\n                            dir: target.find('.k-i-sort-asc-sm')[0] ? 'desc' : 'asc'\n                        });\n                    }\n                });\n                if (options.filterable || options.sortable) {\n                    that.fieldMenu = new ui.PivotFieldMenu(that.element, {\n                        messages: that.options.messages.fieldMenu,\n                        filter: '.k-setting-fieldmenu',\n                        filterable: options.filterable,\n                        sortable: options.sortable,\n                        dataSource: that.dataSource\n                    });\n                }\n                that.refresh();\n            },\n            options: {\n                name: 'PivotSettingTarget',\n                template: null,\n                filterable: false,\n                sortable: false,\n                emptyTemplate: '<div class=\\'k-empty\\'>${data}</div>',\n                setting: 'columns',\n                enabled: true,\n                messages: { empty: 'Drop Fields Here' }\n            },\n            setDataSource: function (dataSource) {\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.dataSource = this.options.dataSource = dataSource;\n                if (this.fieldMenu) {\n                    this.fieldMenu.setDataSource(dataSource);\n                }\n                dataSource.first(CHANGE, this._refreshHandler);\n                this.refresh();\n            },\n            _sortable: function () {\n                var that = this;\n                if (that.options.enabled) {\n                    this.sortable = this.element.kendoSortable({\n                        connectWith: this.options.connectWith,\n                        hint: that.options.hint,\n                        filter: '>*:not(.k-empty)',\n                        cursor: 'move',\n                        start: function (e) {\n                            e.item.trigger('focus').trigger('blur');\n                        },\n                        change: function (e) {\n                            var name = e.item.attr(kendo.attr('name'));\n                            if (e.action == 'receive') {\n                                that.add(name);\n                            } else if (e.action == 'remove') {\n                                that.remove(name);\n                            } else if (e.action == 'sort') {\n                                that.move(name, e.newIndex);\n                            }\n                        }\n                    }).data('kendoSortable');\n                }\n            },\n            _isKPI: function (data) {\n                return data.type === 'kpi' || data.measure;\n            },\n            validate: function (data) {\n                var isMeasure = data.type == 2 || 'aggregator' in data || this._isKPI(data);\n                if (isMeasure) {\n                    return this.options.setting === 'measures';\n                }\n                if (this.options.setting === 'measures') {\n                    return isMeasure;\n                }\n                var items = this.dataSource[this.options.setting]();\n                var name = data.defaultHierarchy || data.uniqueName;\n                if (indexOf(name, items) > -1) {\n                    return false;\n                }\n                items = this.dataSource[this.options.setting === 'columns' ? 'rows' : 'columns']();\n                if (indexOf(name, items) > -1) {\n                    return false;\n                }\n                return true;\n            },\n            add: function (name) {\n                var items = this.dataSource[this.options.setting]();\n                var i, l;\n                name = Array.isArray(name) ? name.slice(0) : [name];\n                for (i = 0, l = name.length; i < l; i++) {\n                    if (indexOf(name[i], items) !== -1) {\n                        name.splice(i, 1);\n                        i -= 1;\n                        l -= 1;\n                    }\n                }\n                if (name.length) {\n                    items = items.concat(name);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            move: function (name, index) {\n                var items = this.dataSource[this.options.setting]();\n                var idx = indexOf(name, items);\n                if (idx > -1) {\n                    name = items.splice(idx, 1)[0];\n                    items.splice(index, 0, name);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            remove: function (name) {\n                var items = this.dataSource[this.options.setting]();\n                var idx = indexOf(name, items);\n                var sortExpressions = this.dataSource.sort();\n                var filter = this.dataSource.filter();\n                if (idx > -1) {\n                    if (filter) {\n                        filter.filters = removeExpr(filter.filters, name);\n                        this.dataSource._filter.filters = filter.filters;\n                        if (!filter.filters.length) {\n                            this.dataSource._filter = null;\n                        }\n                    }\n                    if (sortExpressions) {\n                        sortExpressions = removeExpr(sortExpressions, name);\n                        this.dataSource._sort = sortExpressions;\n                    }\n                    items.splice(idx, 1);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n            sort: function (expr) {\n                var sortable = this.options.sortable;\n                var allowUnsort = sortable === true || sortable.allowUnsort;\n                var skipExpr = allowUnsort && expr.dir === 'asc';\n                var expressions = this.dataSource.sort() || [];\n                var result = removeExpr(expressions, expr.field);\n                if (skipExpr && expressions.length !== result.length) {\n                    expr = null;\n                }\n                if (expr) {\n                    result.push(expr);\n                }\n                this.dataSource.sort(result);\n            },\n            refresh: function () {\n                var html = '';\n                var items = this.dataSource[this.options.setting]();\n                var length = items.length;\n                var idx = 0;\n                var item;\n                if (length) {\n                    for (; idx < length; idx++) {\n                        item = items[idx];\n                        item = item.name === undefined ? { name: item } : item;\n                        html += this.template(extend({ sortIcon: this._sortIcon(item.name) }, item));\n                    }\n                } else {\n                    html = this.emptyTemplate(this.options.messages.empty);\n                }\n                this.element.html(html);\n            },\n            destroy: function () {\n                Widget.fn.destroy.call(this);\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.element.off(NS);\n                if (this.sortable) {\n                    this.sortable.destroy();\n                }\n                if (this.fieldMenu) {\n                    this.fieldMenu.destroy();\n                }\n                this.element = null;\n                this._refreshHandler = null;\n            },\n            _sortIcon: function (name) {\n                var expressions = this.dataSource.sort();\n                var expr = sortExpr(expressions, getName(name));\n                var icon = '';\n                if (expr) {\n                    icon = 'k-i-sort-' + expr.dir;\n                }\n                return icon;\n            }\n        });\n        kendo.ui.PivotSettingTargetV2 = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that.dataSource = kendo.data.PivotDataSourceV2.create(options.dataSource);\n                that._refreshHandler = $.proxy(that.refresh, that);\n                that.dataSource.first(CHANGE, that._refreshHandler);\n                that.template = kendo.template(that.options.template);\n                that._sortable();\n                that.element.on('click' + NS, '.k-i-close-circle', function (e) {\n                    var target = $(e.target);\n                    var parent = target.closest('.k-chip');\n                    var name = parent.find('.k-chip-label').text();\n                    if (!name) {\n                        return;\n                    }\n                    that.remove(name);\n                    parent.remove();\n                    that.trigger('remove', { name: name });\n                });\n                if (options.filterable || options.sortable) {\n                    that.fieldMenu = new ui.PivotFieldMenuV2(that.element, {\n                        messages: that.options.messages.fieldMenu,\n                        filterable: options.filterable,\n                        filter: '.k-i-more-vertical',\n                        sortable: options.sortable,\n                        dataSource: that.dataSource\n                    });\n                }\n                that.refresh();\n            },\n            events: ['remove'],\n            options: {\n                name: 'PivotSettingTargetV2',\n                template: null,\n                filterable: false,\n                sortable: false,\n                setting: 'columns',\n                enabled: true,\n                messages: { empty: 'Drop Fields Here' }\n            },\n            setDataSource: function (dataSource) {\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.dataSource = this.options.dataSource = dataSource;\n                if (this.fieldMenu) {\n                    this.fieldMenu.setDataSource(dataSource);\n                }\n                dataSource.first(CHANGE, this._refreshHandler);\n                this.refresh();\n            },\n            _applyState: function () {\n                if (this._sortState !== undefined) {\n                    this.dataSource._sort = this._sortState;\n                    this._sortState = undefined;\n                }\n                if (this._stateFilter !== undefined) {\n                    this.dataSource._filter = this._stateFilter;\n                    this._stateFilter = undefined;\n                }\n                this.dataSource['_' + this.options.setting] = this.options.setting === 'measures' ? normalizeMeasures(this._savedState) : normalizeMembers(this._savedState);\n            },\n            _cancelChanges: function () {\n                this._sortState = undefined;\n                this._stateFilter = undefined;\n                this._savedState = kendo.deepExtend([], this._initialState);\n                this._redraw();\n            },\n            _state: function (newState, modifyInit) {\n                var that = this;\n                if (!newState) {\n                    return that._savedState || [];\n                } else {\n                    if (!that._savedState || modifyInit) {\n                        that._initialState = kendo.deepExtend([], newState);\n                    }\n                    that._savedState = kendo.deepExtend([], newState);\n                }\n            },\n            _sortable: function () {\n                var that = this;\n                this.sortable = this.element.kendoSortable({\n                    connectWith: this.options.connectWith,\n                    hint: that.options.hint,\n                    filter: '>*:not(.k-empty)',\n                    cursor: 'move',\n                    start: function (e) {\n                        e.item.focus().blur();\n                    },\n                    change: function (e) {\n                        var name = e.item.find('.k-chip-label').text();\n                        if (e.action == 'receive') {\n                            that.add(name);\n                        } else if (e.action == 'remove') {\n                            that.remove(name);\n                        } else if (e.action == 'sort') {\n                            that.move(name, e.newIndex);\n                        }\n                    }\n                }).data('kendoSortable');\n            },\n            add: function (name) {\n                var items = this._state();\n                var i, l;\n                name = $.isArray(name) ? name.slice(0) : [name];\n                for (i = 0, l = name.length; i < l; i++) {\n                    if (indexOf(name[i], items) !== -1) {\n                        name.splice(i, 1);\n                        i -= 1;\n                        l -= 1;\n                    }\n                }\n                if (name.length) {\n                    items = items.concat(name);\n                    this._state(items);\n                    this._redraw();\n                }\n            },\n            move: function (name, index) {\n                var items = this._state();\n                var idx = indexOf(name, items);\n                if (idx > -1) {\n                    name = items.splice(idx, 1)[0];\n                    items.splice(index, 0, name);\n                    this._state(items);\n                    this._redraw();\n                }\n            },\n            remove: function (name) {\n                var items = this._state();\n                var idx = indexOf(name, items);\n                var sortExpressions = this.dataSource.sort();\n                var filter = this.dataSource.filter();\n                if (idx > -1) {\n                    if (filter) {\n                        filter.filters = removeExpr(filter.filters, name);\n                        this._savedFilter = this.dataSource._filter;\n                        this._savedFilter.filters = filter.filters;\n                        if (!filter.filters.length) {\n                            this._savedFilter = null;\n                        }\n                    }\n                    if (sortExpressions) {\n                        sortExpressions = removeExpr(sortExpressions, name);\n                        this._sortState = sortExpressions;\n                    }\n                    items.splice(idx, 1);\n                    this._state(items);\n                    this._redraw();\n                }\n            },\n            _emptyState: function (enable) {\n                var that = this;\n                if (enable) {\n                    that.element.html(this.options.messages.empty).addClass('k-settings-description').removeClass('k-chip-list');\n                } else {\n                    that.element.removeClass('k-settings-description').addClass('k-chip-list');\n                }\n            },\n            _redraw: function () {\n                var items = this._state() || [];\n                this._emptyState(!items.length);\n                if (items.length) {\n                    this.element.html(this._targetsHTML(items));\n                }\n            },\n            _targetsHTML: function (items) {\n                var item;\n                var html = '';\n                var idx = 0;\n                var options = this.options;\n                var enabled = false;\n                if (this.options.setting != 'measures') {\n                    enabled = options.filterable || options.sortable;\n                }\n                if (items.length) {\n                    for (; idx < items.length; idx++) {\n                        item = items[idx];\n                        item = item.name === undefined ? { name: item } : item;\n                        html += this.template({\n                            name: item.name,\n                            menuenabled: enabled\n                        });\n                    }\n                }\n                return html;\n            },\n            refresh: function () {\n                if (this.dataSource._preventRefresh) {\n                    return;\n                }\n                var items = this.dataSource[this.options.setting]();\n                this._emptyState(!this._state().length);\n                this._state(items, true);\n                if (items.length) {\n                    this.element.html(this._targetsHTML(items));\n                }\n            },\n            destroy: function () {\n                Widget.fn.destroy.call(this);\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.element.off(NS);\n                if (this.sortable) {\n                    this.sortable.destroy();\n                }\n                if (this.fieldMenu) {\n                    this.fieldMenu.destroy();\n                }\n                this.element = null;\n                this._refreshHandler = null;\n            }\n        });\n        var PivotConfiguratorButton = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that.element = $(element);\n                that._element();\n                that._attachEvents();\n            },\n            options: {\n                name: 'PivotConfiguratorButton',\n                text: 'Change settings',\n                configurator: ''\n            },\n            destroy: function () {\n                this.element.off(NS);\n            },\n            setOptions: function (options) {\n                var that = this;\n                kendo.deepExtend(that.options, options);\n                this.init(this.element, this.options);\n            },\n            toggle: function () {\n                var attr = kendo.attr('role');\n                var pivotEl = this.element.closest('[' + attr + '=pivotcontainer]').find('[' + attr + '=pivotgridv2]');\n                var pivot;\n                $('#' + this.options.configurator).toggleClass('k-hidden');\n                if (pivotEl.length) {\n                    pivot = pivotEl.getKendoPivotGridV2();\n                    pivot._setContentWidth();\n                    pivot._updateDimensions();\n                }\n            },\n            _attachEvents: function () {\n                this.element.on('click' + NS, $.proxy(this.toggle, this));\n            },\n            _element: function () {\n                var options = this.options;\n                this.element.addClass('k-pivotgrid-configurator-button');\n                this.element.html(kendo.format('<span>{0}<span class=\\'k-icon k-i-gear k-color-inherit\\'></span></span>', options.text));\n            }\n        });\n        var PivotContainer = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that.element = $(element);\n                that.options = options;\n                that._addClasses();\n            },\n            options: {\n                name: 'PivotContainer',\n                configuratorPosition: 'left'\n            },\n            setOptions: function (options) {\n                var that = this;\n                kendo.deepExtend(that.options, options);\n                this.init(this.element, this.options);\n            },\n            _addClasses: function () {\n                var options = this.options;\n                var className;\n                this.element.removeClass('k-flex-row k-flex-row-reverse k-flex-column k-flex-column-reverse');\n                switch (options.configuratorPosition) {\n                case 'right':\n                    className = 'k-flex-row';\n                    break;\n                case 'left':\n                    className = 'k-flex-row-reverse';\n                    break;\n                case 'bottom':\n                    className = 'k-flex-column';\n                    break;\n                case 'top':\n                    className = 'k-flex-column-reverse';\n                    break;\n                default:\n                    className = 'k-flex-row';\n                }\n                this.element.addClass('k-d-flex k-pos-relative').addClass(className);\n            }\n        });\n        var PivotGridV2 = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                Widget.fn.init.call(that, element, options);\n                that._dataSource();\n                that._bindConfigurator();\n                that._wrapper();\n                that._columnHeadersWrapper = $('<div class=\"k-pivotgrid-column-headers\"></div>');\n                that._rowHeadersWrapper = $('<div class=\"k-pivotgrid-row-headers\"></div>');\n                that._contentWrapper = $('<div class=\"k-pivotgrid-values\"></div>');\n                that.wrapper.append(that._columnHeadersWrapper);\n                that.wrapper.append(that._rowHeadersWrapper);\n                that.wrapper.append(that._contentWrapper);\n                that._columnBuilder = new ColumnRowBuilder({\n                    template: this.options.columnHeaderTemplate,\n                    axes: 'columns'\n                });\n                that._rowBuilder = new ColumnRowBuilder({\n                    template: this.options.rowHeaderTemplate,\n                    axes: 'rows'\n                });\n                that._contentBuilder = new ContentBuilderV2({ template: this.options.dataCellTemplate || DATACELL_TEMPLATE });\n                that._scrollable();\n                that._rowHeadersWrapper.add(that._columnHeadersWrapper).on('click', 'span.k-icon', function () {\n                    var button = $(this);\n                    var path = button.parent().attr(kendo.attr('key'));\n                    var expanded = button.hasClass('k-i-arrow-chevron-up');\n                    var isRow = button.closest('.k-pivotgrid-row-headers').length !== 0;\n                    var paths = path.split(',');\n                    var eventName = expanded ? COLLAPSEMEMBER : EXPANDMEMBER;\n                    if (that.trigger(eventName, {\n                            path: paths,\n                            axis: isRow ? 'rows' : 'columns'\n                        })) {\n                        return;\n                    }\n                    var reducerPayLoad = {\n                        type: 'HEADERS_ACTION_TOGGLE',\n                        payload: paths,\n                        tree: isRow ? that._rowBuilder.getTree() : that._columnBuilder.getTree()\n                    };\n                    var currentAxes = isRow ? that.dataSource._rows : that.dataSource._columns;\n                    var newHeaders = headersReducer(currentAxes, reducerPayLoad);\n                    that.dataSource._preventRefresh = true;\n                    if (isRow) {\n                        that.dataSource.rows(newHeaders);\n                    } else {\n                        that.dataSource.columns(newHeaders);\n                    }\n                });\n                if (that.options.autoBind) {\n                    that.dataSource.fetch();\n                }\n                kendo.notify(that);\n            },\n            events: [\n                DATABINDING,\n                DATABOUND,\n                EXPANDMEMBER,\n                COLLAPSEMEMBER\n            ],\n            options: {\n                name: 'PivotGridV2',\n                autoBind: true,\n                height: null,\n                columnWidth: null,\n                configurator: '',\n                columnHeaderTemplate: null,\n                rowHeaderTemplate: null,\n                dataCellTemplate: null\n            },\n            destroy: function () {\n                var that = this;\n                Widget.fn.destroy.call(that);\n                if (that._windowResizeHandler) {\n                    $(window).off(RESIZE + NS, that._windowResizeHandler);\n                    that._windowResizeHandler = null;\n                }\n            },\n            _dataSource: function () {\n                var that = this;\n                var dataSource = that.options.dataSource;\n                dataSource = $.isArray(dataSource) ? { data: dataSource } : dataSource;\n                if (that.dataSource && this._refreshHandler) {\n                    that.dataSource.unbind(CHANGE, that._refreshHandler).unbind(PROGRESS, that._progressHandler).unbind(ERROR, that._errorHandler);\n                } else {\n                    that._refreshHandler = $.proxy(that.refresh, that);\n                    that._progressHandler = $.proxy(that._requestStart, that);\n                    that._errorHandler = $.proxy(that._error, that);\n                }\n                that.dataSource = kendo.data.PivotDataSourceV2.create(dataSource).bind(CHANGE, that._refreshHandler).bind(PROGRESS, that._progressHandler).bind(ERROR, that._errorHandler);\n            },\n            _resize: function () {\n                var that = this;\n                that.wrapper[0].style.setProperty('--kendo-scrollbar-width', kendo.format('{0}px', getScollWidth()));\n            },\n            _scrollable: function () {\n                var that = this;\n                var columnsHeader = that._columnHeadersWrapper;\n                var rowsHeader = that._rowHeadersWrapper;\n                that._resize();\n                that._windowResizeHandler = $.proxy(that._resize, that);\n                that._contentWrapper.scroll(function () {\n                    kendo.scrollLeft(columnsHeader, this.scrollLeft);\n                    rowsHeader.scrollTop(this.scrollTop);\n                });\n                rowsHeader.bind('DOMMouseScroll' + NS + ' mousewheel' + NS, $.proxy(that._wheelScroll, that));\n                $(window).on(RESIZE + NS, that._windowResizeHandler);\n            },\n            _wheelScroll: function (e) {\n                if (e.ctrlKey) {\n                    return;\n                }\n                var delta = kendo.wheelDeltaY(e);\n                var scrollTop = this._contentWrapper.scrollTop();\n                if (delta) {\n                    e.preventDefault();\n                    $(e.currentTarget).one('wheel' + NS, false);\n                    this._rowHeadersWrapper.scrollTop(scrollTop + -delta);\n                    this._contentWrapper.scrollTop(scrollTop + -delta);\n                }\n            },\n            _wrapper: function () {\n                var height = this.options.height;\n                this.wrapper = this.element.addClass('k-widget k-pivotgrid');\n                this.wrapper.append('<span class=\"k-pivotgrid-empty-cell\" />');\n                if (height) {\n                    this.wrapper.css('height', height);\n                }\n            },\n            _progress: function (toggle) {\n                kendo.ui.progress(this.wrapper, toggle);\n            },\n            _error: function () {\n                this._progress(false);\n            },\n            _requestStart: function () {\n                this._progress(true);\n            },\n            _updateDimensions: function () {\n                var that = this;\n                that.wrapper.css({\n                    'grid-template-columns': kendo.format('{0}px 1fr', that._rowHeadersWrapper.find('.k-pivotgrid-table')[0].offsetWidth),\n                    'grid-template-rows': kendo.format('{0}px 1fr', that._columnHeadersWrapper.find('.k-pivotgrid-table')[0].offsetHeight)\n                });\n            },\n            _setContentWidth: function () {\n                if (!this.options.columnWidth) {\n                    return;\n                }\n                var contentTable = this._contentWrapper.find('table');\n                var columnTable = this._columnHeadersWrapper.children('table');\n                var rowLength = contentTable.children('colgroup').children().length;\n                var calculatedWidth = rowLength * this.options.columnWidth;\n                var minWidth = Math.ceil(calculatedWidth / this._contentWrapper.width() * 100);\n                if (minWidth < 100) {\n                    minWidth = 100;\n                }\n                contentTable.add(columnTable).css('width', minWidth + '%');\n            },\n            _bindConfigurator: function () {\n                var configurator = this.options.configurator;\n                if (configurator) {\n                    $(configurator).kendoPivotConfiguratorV2('setDataSource', this.dataSource);\n                }\n            },\n            cellInfoByElement: function (element) {\n                element = $(element);\n                return this.cellInfo(element.index(), element.parent('tr').index());\n            },\n            cellInfo: function (columnIndex, rowIndex) {\n                var contentBuilder = this._contentBuilder;\n                var dataIndex;\n                var dataItem;\n                if (columnIndex >= contentBuilder.columnsCount || columnIndex < 0 || rowIndex >= contentBuilder.rowsCount || rowIndex < 0) {\n                    return null;\n                }\n                dataIndex = rowIndex * contentBuilder.columnsCount + columnIndex;\n                dataItem = contentBuilder.hash[dataIndex < 0 ? 0 : dataIndex];\n                return {\n                    columnTuple: dataItem.columnTuple,\n                    rowTuple: dataItem.rowTuple,\n                    dataItem: dataItem.data\n                };\n            },\n            refresh: function () {\n                var that = this;\n                var dataSource = that.dataSource;\n                if (that.trigger(DATABINDING, { action: 'rebind' })) {\n                    return;\n                }\n                that._columnBuilder.setTuples(dataSource._columnTuples);\n                that._columnHeadersWrapper.html(that._columnBuilder.build());\n                that._rowBuilder.setTuples(dataSource._rowTuples);\n                that._rowHeadersWrapper.html(that._rowBuilder.build());\n                that._contentBuilder.setRowColumnInfo({\n                    columnHeaderLeafs: that._columnBuilder.getHeaderLeafs(),\n                    rowHeaderLeafs: that._rowBuilder.getHeaderLeafs(),\n                    columnHeaderBreadth: that._columnBuilder.getBreadth(),\n                    rowHeaderDepth: that._rowBuilder.getBreadth(),\n                    data: dataSource._view\n                });\n                that._contentWrapper.html(that._contentBuilder.build());\n                that._setContentWidth();\n                that._updateDimensions();\n                that._progress(false);\n                that.trigger(DATABOUND);\n            }\n        });\n        ui.plugin(PivotConfiguratorButton);\n        ui.plugin(PivotContainer);\n        ui.plugin(PivotGridV2);\n        var PivotGrid = Widget.extend({\n            init: function (element, options) {\n                var that = this;\n                var columnBuilder;\n                var rowBuilder;\n                Widget.fn.init.call(that, element, options);\n                that._dataSource();\n                that._bindConfigurator();\n                that._wrapper();\n                that._createLayout();\n                that._columnBuilder = columnBuilder = new ColumnBuilder();\n                that._rowBuilder = rowBuilder = new RowBuilder();\n                that._contentBuilder = new ContentBuilder();\n                that._templates();\n                that.columnsHeader.add(that.rowsHeader).on('click', 'span.k-icon', function () {\n                    var button = $(this);\n                    var builder = columnBuilder;\n                    var action = 'expandColumn';\n                    var eventName;\n                    var path = button.attr(kendo.attr('path'));\n                    var eventArgs = {\n                        axis: 'columns',\n                        path: $.parseJSON(path)\n                    };\n                    if (button.parent().is('td')) {\n                        builder = rowBuilder;\n                        action = 'expandRow';\n                        eventArgs.axis = 'rows';\n                    }\n                    var expanded = button.hasClass(STATE_EXPANDED);\n                    var metadata = builder.metadata[path];\n                    var request = metadata.expanded === undefined;\n                    eventName = expanded ? COLLAPSEMEMBER : EXPANDMEMBER;\n                    eventArgs.childrenLoaded = metadata.maxChildren > metadata.children;\n                    if (that.trigger(eventName, eventArgs)) {\n                        return;\n                    }\n                    builder.metadata[path].expanded = !expanded;\n                    button.toggleClass(STATE_EXPANDED, !expanded).toggleClass(STATE_COLLAPSED, expanded);\n                    if (!expanded && request) {\n                        that.dataSource[action](eventArgs.path);\n                    } else {\n                        that.refresh();\n                    }\n                });\n                that._scrollable();\n                if (that.options.autoBind) {\n                    that.dataSource.fetch();\n                }\n                kendo.notify(that);\n            },\n            events: [\n                DATABINDING,\n                DATABOUND,\n                EXPANDMEMBER,\n                COLLAPSEMEMBER\n            ],\n            options: {\n                name: 'PivotGrid',\n                autoBind: true,\n                reorderable: true,\n                filterable: false,\n                sortable: false,\n                height: null,\n                columnWidth: 100,\n                configurator: '',\n                columnHeaderTemplate: null,\n                rowHeaderTemplate: null,\n                dataCellTemplate: null,\n                kpiStatusTemplate: null,\n                kpiTrendTemplate: null,\n                messages: {\n                    measureFields: 'Drop Data Fields Here',\n                    columnFields: 'Drop Column Fields Here',\n                    rowFields: 'Drop Rows Fields Here'\n                }\n            },\n            _templates: function () {\n                var columnTemplate = this.options.columnHeaderTemplate;\n                var rowTemplate = this.options.rowHeaderTemplate;\n                var dataTemplate = this.options.dataCellTemplate;\n                var kpiStatusTemplate = this.options.kpiStatusTemplate;\n                var kpiTrendTemplate = this.options.kpiTrendTemplate;\n                this._columnBuilder.template = kendo.template(columnTemplate || HEADER_TEMPLATE, { useWithBlock: !!columnTemplate });\n                this._contentBuilder.dataTemplate = kendo.template(dataTemplate || DATACELL_TEMPLATE, { useWithBlock: !!dataTemplate });\n                this._contentBuilder.kpiStatusTemplate = kendo.template(kpiStatusTemplate || KPISTATUS_TEMPLATE, { useWithBlock: !!kpiStatusTemplate });\n                this._contentBuilder.kpiTrendTemplate = kendo.template(kpiTrendTemplate || KPITREND_TEMPLATE, { useWithBlock: !!kpiTrendTemplate });\n                this._rowBuilder.template = kendo.template(rowTemplate || HEADER_TEMPLATE, { useWithBlock: !!rowTemplate });\n            },\n            _bindConfigurator: function () {\n                var configurator = this.options.configurator;\n                if (configurator) {\n                    $(configurator).kendoPivotConfigurator('setDataSource', this.dataSource);\n                }\n            },\n            cellInfoByElement: function (element) {\n                element = $(element);\n                return this.cellInfo(element.index(), element.parent('tr').index());\n            },\n            cellInfo: function (columnIndex, rowIndex) {\n                var contentBuilder = this._contentBuilder;\n                var columnInfo = contentBuilder.columnIndexes[columnIndex || 0];\n                var rowInfo = contentBuilder.rowIndexes[rowIndex || 0];\n                var dataIndex;\n                if (!columnInfo || !rowInfo) {\n                    return null;\n                }\n                dataIndex = rowInfo.index * contentBuilder.rowLength + columnInfo.index;\n                return {\n                    columnTuple: columnInfo.tuple,\n                    rowTuple: rowInfo.tuple,\n                    measure: columnInfo.measure || rowInfo.measure,\n                    dataItem: this.dataSource.view()[dataIndex]\n                };\n            },\n            setDataSource: function (dataSource) {\n                this.options.dataSource = dataSource;\n                this._dataSource();\n                if (this.measuresTarget) {\n                    this.measuresTarget.setDataSource(dataSource);\n                }\n                if (this.rowsTarget) {\n                    this.rowsTarget.setDataSource(dataSource);\n                }\n                if (this.columnsTarget) {\n                    this.columnsTarget.setDataSource(dataSource);\n                }\n                this._bindConfigurator();\n                if (this.options.autoBind) {\n                    dataSource.fetch();\n                }\n            },\n            setOptions: function (options) {\n                Widget.fn.setOptions.call(this, options);\n                this._templates();\n            },\n            destroy: function () {\n                Widget.fn.destroy.call(this);\n                clearTimeout(this._headerReflowTimeout);\n            },\n            _dataSource: function () {\n                var that = this;\n                var dataSource = that.options.dataSource;\n                dataSource = Array.isArray(dataSource) ? { data: dataSource } : dataSource;\n                if (that.dataSource && this._refreshHandler) {\n                    that.dataSource.unbind(CHANGE, that._refreshHandler).unbind(STATERESET, that._stateResetHandler).unbind(PROGRESS, that._progressHandler).unbind(ERROR, that._errorHandler);\n                } else {\n                    that._refreshHandler = $.proxy(that.refresh, that);\n                    that._progressHandler = $.proxy(that._requestStart, that);\n                    that._stateResetHandler = $.proxy(that._stateReset, that);\n                    that._errorHandler = $.proxy(that._error, that);\n                }\n                that.dataSource = kendo.data.PivotDataSource.create(dataSource).bind(CHANGE, that._refreshHandler).bind(PROGRESS, that._progressHandler).bind(STATERESET, that._stateResetHandler).bind(ERROR, that._errorHandler);\n            },\n            _error: function () {\n                this._progress(false);\n            },\n            _requestStart: function () {\n                this._progress(true);\n            },\n            _stateReset: function () {\n                this._columnBuilder.reset();\n                this._rowBuilder.reset();\n            },\n            _wrapper: function () {\n                var height = this.options.height;\n                this.wrapper = this.element.addClass('k-widget k-pivot');\n                if (height) {\n                    this.wrapper.css('height', height);\n                }\n            },\n            _measureFields: function () {\n                this.measureFields = $(DIV).addClass('k-pivot-toolbar k-toolbar k-header k-settings-measures');\n                this.measuresTarget = this._createSettingTarget(this.measureFields, {\n                    setting: 'measures',\n                    messages: { empty: this.options.messages.measureFields }\n                });\n            },\n            _createSettingTarget: function (element, options) {\n                var template = '<span tabindex=\"0\" class=\"k-button\" data-' + kendo.ns + 'name=\"${data.name}\">${data.name}';\n                var sortable = options.sortable;\n                var icons = '';\n                if (sortable) {\n                    icons += '#if (data.sortIcon) {#';\n                    icons += '<span class=\"k-icon ${data.sortIcon}-sm\"></span>';\n                    icons += '#}#';\n                }\n                if (options.filterable || sortable) {\n                    icons += '<span class=\"k-icon k-i-more-vertical k-setting-fieldmenu\"></span>';\n                }\n                if (this.options.reorderable) {\n                    icons += '<span class=\"k-icon k-i-close k-setting-delete\"></span>';\n                }\n                if (icons) {\n                    template += '<span class=\"k-field-actions\">' + icons + '</span>';\n                }\n                template += '</span>';\n                return new kendo.ui.PivotSettingTarget(element, $.extend({\n                    template: template,\n                    emptyTemplate: '<span class=\"k-empty\">${data}</span>',\n                    enabled: this.options.reorderable,\n                    dataSource: this.dataSource\n                }, options));\n            },\n            _initSettingTargets: function () {\n                this.columnsTarget = this._createSettingTarget(this.columnFields, {\n                    connectWith: this.rowFields,\n                    setting: 'columns',\n                    filterable: this.options.filterable,\n                    sortable: this.options.sortable,\n                    messages: {\n                        empty: this.options.messages.columnFields,\n                        fieldMenu: this.options.messages.fieldMenu\n                    }\n                });\n                this.rowsTarget = this._createSettingTarget(this.rowFields, {\n                    connectWith: this.columnFields,\n                    setting: 'rows',\n                    filterable: this.options.filterable,\n                    sortable: this.options.sortable,\n                    messages: {\n                        empty: this.options.messages.rowFields,\n                        fieldMenu: this.options.messages.fieldMenu\n                    }\n                });\n            },\n            _createLayout: function () {\n                var that = this;\n                var layoutTable = $(LAYOUT_TABLE);\n                var leftContainer = layoutTable.find('.k-pivot-rowheaders');\n                var rightContainer = layoutTable.find('.k-pivot-table');\n                var gridWrapper = $(DIV).addClass('k-grid k-widget');\n                that._measureFields();\n                that.columnFields = $(DIV).addClass('k-pivot-toolbar k-toolbar k-header k-settings-columns');\n                that.rowFields = $(DIV).addClass('k-pivot-toolbar k-toolbar k-header k-settings-rows');\n                that.columnsHeader = $('<div class=\"k-grid-header-wrap\" />').wrap('<div class=\"k-grid-header\" />');\n                that.columnsHeader.parent().css('padding-right', kendo.support.scrollbar());\n                that.rowsHeader = $('<div class=\"k-grid k-widget k-alt\"/>');\n                that.content = $('<div class=\"k-grid-content\" />');\n                leftContainer.append(that.measureFields);\n                leftContainer.append(that.rowFields);\n                leftContainer.append(that.rowsHeader);\n                gridWrapper.append(that.columnsHeader.parent());\n                gridWrapper.append(that.content);\n                rightContainer.append(that.columnFields);\n                rightContainer.append(gridWrapper);\n                that.wrapper.append(layoutTable);\n                that.columnsHeaderTree = new kendo.dom.Tree(that.columnsHeader[0]);\n                that.rowsHeaderTree = new kendo.dom.Tree(that.rowsHeader[0]);\n                that.contentTree = new kendo.dom.Tree(that.content[0]);\n                that._initSettingTargets();\n            },\n            _progress: function (toggle) {\n                kendo.ui.progress(this.wrapper, toggle);\n            },\n            _resize: function () {\n                if (this.content[0].firstChild) {\n                    this._setSectionsWidth();\n                    this._setSectionsHeight();\n                    this._setContentWidth();\n                    this._setContentHeight();\n                    this._columnHeaderReflow();\n                }\n            },\n            _columnHeaderReflow: function () {\n                var columnTable = this.columnsHeader.children('table');\n                if (!kendo.support.browser.mozilla) {\n                    return;\n                }\n                clearTimeout(this._headerReflowTimeout);\n                columnTable.css('table-layout', 'auto');\n                this._headerReflowTimeout = setTimeout(function () {\n                    columnTable.css('table-layout', '');\n                });\n            },\n            _setSectionsWidth: function () {\n                var rowsHeader = this.rowsHeader;\n                var leftColumn = rowsHeader.parent('.k-pivot-rowheaders').width(AUTO);\n                var width;\n                width = Math.max(outerWidth(this.measureFields), outerWidth(this.rowFields));\n                width = Math.max(rowsHeader.children('table').width(), width);\n                leftColumn.width(width);\n            },\n            _setSectionsHeight: function () {\n                var measureFieldsHeight = this.measureFields.height(AUTO).height();\n                var columnFieldsHeight = this.columnFields.height(AUTO).height();\n                var rowFieldsHeight = this.rowFields.height(AUTO).innerHeight();\n                var columnsHeight = this.columnsHeader.height(AUTO).innerHeight();\n                var padding = rowFieldsHeight - this.rowFields.height();\n                var firstRowHeight = columnFieldsHeight > measureFieldsHeight ? columnFieldsHeight : measureFieldsHeight;\n                var secondRowHeight = columnsHeight > rowFieldsHeight ? columnsHeight : rowFieldsHeight;\n                this.measureFields.height(firstRowHeight);\n                this.columnFields.height(firstRowHeight);\n                this.rowFields.height(secondRowHeight - padding);\n                this.columnsHeader.height(secondRowHeight);\n            },\n            _setContentWidth: function () {\n                var contentTable = this.content.find('table');\n                var columnTable = this.columnsHeader.children('table');\n                var rowLength = contentTable.children('colgroup').children().length;\n                var calculatedWidth = rowLength * this.options.columnWidth;\n                var minWidth = Math.ceil(calculatedWidth / this.content.width() * 100);\n                if (minWidth < 100) {\n                    minWidth = 100;\n                }\n                contentTable.add(columnTable).css('width', minWidth + '%');\n                this._resetColspan(columnTable);\n            },\n            _setContentHeight: function () {\n                var that = this;\n                var content = that.content;\n                var rowsHeader = that.rowsHeader;\n                var innerHeight = that.wrapper.innerHeight();\n                var scrollbar = kendo.support.scrollbar();\n                var skipScrollbar = content[0].offsetHeight === content[0].clientHeight;\n                var height = that.options.height;\n                if (that.wrapper.is(':visible')) {\n                    if (!innerHeight || !height) {\n                        if (skipScrollbar) {\n                            scrollbar = 0;\n                        }\n                        content.height('auto');\n                        rowsHeader.height(content.height() - scrollbar);\n                        return;\n                    }\n                    innerHeight -= outerHeight(that.columnFields);\n                    innerHeight -= outerHeight(that.columnsHeader.parent());\n                    if (innerHeight <= scrollbar * 2) {\n                        innerHeight = scrollbar * 2 + 1;\n                        if (!skipScrollbar) {\n                            innerHeight += scrollbar;\n                        }\n                    }\n                    content.height(innerHeight);\n                    if (skipScrollbar) {\n                        scrollbar = 0;\n                    }\n                    rowsHeader.height(innerHeight - scrollbar);\n                }\n            },\n            _resetColspan: function (columnTable) {\n                var that = this;\n                var cell = columnTable.children('tbody').children().first().children().first();\n                if (that._colspan === undefined) {\n                    that._colspan = cell.attr('colspan');\n                }\n                cell.attr('colspan', 1);\n                clearTimeout(that._layoutTimeout);\n                that._layoutTimeout = setTimeout(function () {\n                    cell.attr('colspan', that._colspan);\n                    that._colspan = undefined;\n                });\n            },\n            _axisMeasures: function (axis) {\n                var result = [];\n                var dataSource = this.dataSource;\n                var measures = dataSource.measures();\n                var hasMeasure = measures.length > 1 || measures[0] && measures[0].type;\n                if (dataSource.measuresAxis() === axis) {\n                    if (dataSource[axis]().length === 0 || hasMeasure) {\n                        result = measures;\n                    }\n                }\n                return result;\n            },\n            items: function () {\n                return [];\n            },\n            refresh: function () {\n                var that = this;\n                var dataSource = that.dataSource;\n                var axes = dataSource.axes();\n                var columns = (axes.columns || {}).tuples || [];\n                var rows = (axes.rows || {}).tuples || [];\n                var columnBuilder = that._columnBuilder;\n                var rowBuilder = that._rowBuilder;\n                var columnAxis = {};\n                var rowAxis = {};\n                if (that.trigger(DATABINDING, { action: 'rebind' })) {\n                    return;\n                }\n                columnBuilder.measures = that._axisMeasures(AXIS_COLUMNS);\n                rowBuilder.measures = that._axisMeasures(AXIS_ROWS);\n                that.columnsHeaderTree.render(columnBuilder.build(columns));\n                that.rowsHeaderTree.render(rowBuilder.build(rows));\n                columnAxis = {\n                    indexes: columnBuilder._indexes,\n                    measures: columnBuilder.measures,\n                    metadata: columnBuilder.metadata\n                };\n                rowAxis = {\n                    indexes: rowBuilder._indexes,\n                    measures: rowBuilder.measures,\n                    metadata: rowBuilder.metadata\n                };\n                that.contentTree.render(that._contentBuilder.build(dataSource.view(), columnAxis, rowAxis));\n                that._resize();\n                if (that.touchScroller) {\n                    that.touchScroller.contentResized();\n                } else {\n                    var touchScroller = kendo.touchScroller(that.content);\n                    if (touchScroller && touchScroller.movable) {\n                        that.touchScroller = touchScroller;\n                        touchScroller.movable.bind('change', function (e) {\n                            kendo.scrollLeft(that.columnsHeader, -e.sender.x);\n                            that.rowsHeader.scrollTop(-e.sender.y);\n                        });\n                    }\n                }\n                that._progress(false);\n                that.trigger(DATABOUND);\n            },\n            _scrollable: function () {\n                var that = this;\n                var columnsHeader = that.columnsHeader;\n                var rowsHeader = that.rowsHeader;\n                that.content.on('scroll', function () {\n                    kendo.scrollLeft(columnsHeader, this.scrollLeft);\n                    rowsHeader.scrollTop(this.scrollTop);\n                });\n                rowsHeader.on('DOMMouseScroll' + NS + ' mousewheel' + NS, $.proxy(that._wheelScroll, that));\n            },\n            _wheelScroll: function (e) {\n                if (e.ctrlKey) {\n                    return;\n                }\n                var delta = kendo.wheelDeltaY(e);\n                var scrollTop = this.content.scrollTop();\n                if (delta) {\n                    e.preventDefault();\n                    $(e.currentTarget).one('wheel' + NS, false);\n                    this.rowsHeader.scrollTop(scrollTop + -delta);\n                    this.content.scrollTop(scrollTop + -delta);\n                }\n            }\n        });\n        var element = kendo.dom.element;\n        var htmlNode = kendo.dom.html;\n        var createMetadata = function (levelNum, memberIdx) {\n            return {\n                maxChildren: 0,\n                children: 0,\n                maxMembers: 0,\n                members: 0,\n                measures: 1,\n                levelNum: levelNum,\n                parentMember: memberIdx !== 0\n            };\n        };\n        var buildPath = function (tuple, index) {\n            var path = [];\n            var idx = 0;\n            for (; idx <= index; idx++) {\n                path.push(tuple.members[idx].name);\n            }\n            return path;\n        };\n        var tupleName = function (tuple, index) {\n            var name = '';\n            var idx = 0;\n            for (; idx <= index; idx++) {\n                name += tuple.members[idx].name;\n            }\n            return name;\n        };\n        var ContentBuilderV2 = Class.extend({\n            init: function (options) {\n                this.template = kendo.template(options.template);\n                this.hash = [];\n            },\n            setRowColumnInfo: function (options) {\n                this.data = options.data;\n                this.columnHeaderLeafs = options.columnHeaderLeafs;\n                this.rowHeaderLeafs = options.rowHeaderLeafs;\n                this.columnHeaderBreadth = options.columnHeaderBreadth;\n                this.rowHeaderDepth = options.rowHeaderDepth;\n                this.hash.length = 0;\n            },\n            addColElements: function (count) {\n                var html = '';\n                for (var index = 0; index < count; index++) {\n                    html += '<col>';\n                }\n                this.table.find('colgroup').append(html);\n            },\n            addRowElements: function (data) {\n                var that = this;\n                var body = that.table.find('tbody');\n                var row;\n                for (var index = 0; index < data.length; index++) {\n                    row = $('<tr class=\"k-pivotgrid-row\"></tr>');\n                    body.append(row);\n                    that.addColumCell(row, data[index], index);\n                }\n                this.rowsCount = data.length;\n            },\n            addColumCell: function (rowEl, rowItem, rowIndex) {\n                var that = this;\n                for (var index = 0; index < rowItem.cells.length; index++) {\n                    var cell = rowItem.cells[index];\n                    if (cell) {\n                        var cellEl = $('<td class=\"k-pivotgrid-cell\"></td>');\n                        if (this.rowHeaderLeafs[rowIndex].total || this.columnHeaderLeafs[index].total) {\n                            cellEl.addClass('k-pivotgrid-header-total');\n                        }\n                        cellEl.append(that.template({\n                            dataItem: cell.data,\n                            rowTuple: cell.rowTuple,\n                            columnTuple: cell.columnTuple\n                        }));\n                        this.hash.push(cell);\n                        rowEl.append(cellEl);\n                    }\n                }\n            },\n            build: function () {\n                var data = toData((this.data || []).slice(), this.columnHeaderLeafs, this.rowHeaderLeafs, this.columnHeaderBreadth, this.rowHeaderDepth);\n                var that = this;\n                var table = $('<table class=\\'k-pivotgrid-table\\'><colgroup></colgroup><tbody class=\\'k-pivotgrid-tbody\\'></tbody></table>');\n                that.table = table;\n                that.addColElements(this.columnHeaderLeafs.length);\n                that.addRowElements(data);\n                this.rowsCount = data.length;\n                this.columnsCount = this.columnHeaderLeafs.length;\n                return that.table;\n            }\n        });\n        var ColumnRowBuilder = Class.extend({\n            init: function (options) {\n                this.tuples = options.tuples;\n                this.axes = options.axes;\n                this.headerTemplate = kendo.template(HEADERTEMPLATE);\n                if (options.template) {\n                    this.template = kendo.template(options.template);\n                }\n            },\n            setTuples: function (tuples) {\n                this.tuples = tuples;\n            },\n            addColElements: function (count) {\n                var html = '';\n                for (var index = 0; index < count; index++) {\n                    html += '<col>';\n                }\n                this.table.find('colgroup').append(html);\n            },\n            addRowElements: function (columnHeaderRows) {\n                var that = this;\n                var body = that.table.find('tbody');\n                var row;\n                for (var index = 0; index < columnHeaderRows.length; index++) {\n                    row = $('<tr class=\"k-pivotgrid-row\"></tr>');\n                    body.append(row);\n                    that.addColumCell(row, columnHeaderRows[index]);\n                }\n            },\n            addColumCell: function (rowEl, rowItem) {\n                var that = this;\n                var cellEl;\n                var cell;\n                for (var index = 0; index < rowItem.cells.length; index++) {\n                    cell = rowItem.cells[index];\n                    if (cell) {\n                        cellEl = $(that.headerTemplate({\n                            rowspan: cell.rowSpan,\n                            colspan: cell.colSpan,\n                            key: cell.path.join(',') + (cell.total ? '|[TOTAL]' : ''),\n                            iconClass: cell.children && cell.children.length ? 'up' : 'down',\n                            expandable: cell.hasChildren && !cell.total,\n                            headerClass: kendo.format('k-pivotgrid-cell{0}{1}', cell.total ? ' k-pivotgrid-header-total' : '', cell.levelNum === 0 ? ' k-pivotgrid-header-root' : '')\n                        }));\n                        cellEl.append(that.template ? that.template({ member: cell }) : cell.caption);\n                        rowEl.append(cellEl);\n                    }\n                }\n            },\n            build: function () {\n                var tree = toTree((this.tuples || []).slice());\n                var treeData = this.axes == 'columns' ? toColumns(tree) : toRows(tree);\n                var headerRows = treeData[0];\n                var headerLeafs = treeData[1];\n                var breadth = treeData[2];\n                var rowHeaderBreadth = treeData[3];\n                var that = this;\n                that._tree = tree;\n                that._breadth = breadth;\n                that._headerLeafs = headerLeafs;\n                var table = $('<table class=\\'k-pivotgrid-table\\'><colgroup></colgroup><tbody class=\\'k-pivotgrid-tbody\\'></tbody></table>');\n                that.table = table;\n                that.addColElements(this.axes == 'columns' ? headerLeafs.length : rowHeaderBreadth);\n                that.addRowElements(headerRows);\n                return that.table;\n            },\n            getTree: function () {\n                return this._tree;\n            },\n            getBreadth: function () {\n                return this._breadth;\n            },\n            getHeaderLeafs: function () {\n                return this._headerLeafs;\n            }\n        });\n        var ColumnBuilder = Class.extend({\n            init: function () {\n                this.measures = 1;\n                this.metadata = {};\n            },\n            build: function (tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            reset: function () {\n                this.metadata = {};\n            },\n            _colGroup: function () {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function (tuples) {\n                var root = tuples[0];\n                this.map = {};\n                this.rows = [];\n                this.rootTuple = root;\n                this._indexes = [];\n                if (root) {\n                    this._buildRows(root, 0);\n                    this._normalize();\n                } else {\n                    this.rows.push(element('tr', null, [element('th', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _normalize: function () {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n                var row;\n                var cellsLength;\n                var cellIdx;\n                var cells;\n                var cell;\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n                    if (row.rowSpan === 1) {\n                        continue;\n                    }\n                    cells = row.children;\n                    cellIdx = 0;\n                    cellsLength = cells.length;\n                    for (; cellIdx < cellsLength; cellIdx++) {\n                        cell = cells[cellIdx];\n                        if (cell.tupleAll) {\n                            cell.attr.rowSpan = row.rowSpan;\n                        }\n                    }\n                }\n            },\n            _rowIndex: function (row) {\n                var rows = this.rows;\n                var length = rows.length;\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    if (rows[idx] === row) {\n                        break;\n                    }\n                }\n                return idx;\n            },\n            _rowLength: function () {\n                var cells = this.rows[0] ? this.rows[0].children : [];\n                var length = cells.length;\n                var rowLength = 0;\n                var idx = 0;\n                if (length) {\n                    for (; idx < length; idx++) {\n                        rowLength += cells[idx].attr.colSpan || 1;\n                    }\n                }\n                if (!rowLength) {\n                    rowLength = this.measures;\n                }\n                return rowLength;\n            },\n            _row: function (tuple, memberIdx, parentMember) {\n                var rootName = this.rootTuple.members[memberIdx].name;\n                var levelNum = tuple.members[memberIdx].levelNum;\n                var rowKey = rootName + levelNum;\n                var map = this.map;\n                var parentRow;\n                var children;\n                var row = map[rowKey];\n                if (!row) {\n                    row = element('tr', null, []);\n                    row.parentMember = parentMember;\n                    row.collapsed = 0;\n                    row.colSpan = 0;\n                    row.rowSpan = 1;\n                    map[rowKey] = row;\n                    parentRow = map[rootName + (Number(levelNum) - 1)];\n                    if (parentRow) {\n                        children = parentRow.children;\n                        if (children[1] && children[1].attr.className.indexOf('k-alt') === -1) {\n                            row.notFirst = true;\n                        } else {\n                            row.notFirst = parentRow.notFirst;\n                        }\n                    }\n                    this.rows.splice(this._rowIndex(parentRow) + 1, 0, row);\n                } else {\n                    row.notFirst = false;\n                    if (!row.parentMember || row.parentMember !== parentMember) {\n                        row.parentMember = parentMember;\n                        row.collapsed = 0;\n                        row.colSpan = 0;\n                    }\n                }\n                return row;\n            },\n            _measures: function (measures, tuple, className) {\n                var map = this.map;\n                var row = map.measureRow;\n                var measure;\n                if (!row) {\n                    row = element('tr', null, []);\n                    map.measureRow = row;\n                    this.rows.push(row);\n                }\n                for (var idx = 0, length = measures.length; idx < length; idx++) {\n                    measure = measures[idx];\n                    row.children.push(this._cell(className || '', [this._content(measure, tuple)], measure));\n                }\n                return length;\n            },\n            _content: function (member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\n            },\n            _cell: function (className, children, member) {\n                var cell = element('th', { className: 'k-header' + className }, children);\n                cell.value = member.caption || member.name;\n                return cell;\n            },\n            _buildRows: function (tuple, memberIdx, parentMember) {\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n                var row, childRow, children, childrenLength;\n                var cell, allCell, cellAttr;\n                var cellChildren = [];\n                var path;\n                var idx = 0;\n                var metadata;\n                var colSpan;\n                var collapsed = 0;\n                var memberCollapsed = 0;\n                if (member.measure) {\n                    this._measures(member.children, tuple);\n                    return;\n                }\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n                row = this._row(tuple, memberIdx, parentMember);\n                children = member.children;\n                childrenLength = children.length;\n                metadata = this.metadata[path];\n                if (!metadata) {\n                    this.metadata[path] = metadata = createMetadata(Number(member.levelNum), memberIdx);\n                    metadata.rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);\n                }\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        collapsed = metadata.maxChildren;\n                        row.collapsed += collapsed;\n                        metadata.children = 0;\n                        childrenLength = 0;\n                    }\n                    cellAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    cellAttr[kendo.attr('path')] = path;\n                    cellChildren.push(element('span', cellAttr));\n                }\n                cellChildren.push(this._content(member, tuple));\n                cell = this._cell(row.notFirst ? ' k-first' : '', cellChildren, member);\n                row.children.push(cell);\n                row.colSpan += 1;\n                if (childrenLength) {\n                    allCell = this._cell(' k-alt', [this._content(member, tuple)], member);\n                    row.children.push(allCell);\n                    for (; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx, member);\n                    }\n                    colSpan = childRow.colSpan;\n                    collapsed = childRow.collapsed;\n                    cell.attr.colSpan = colSpan;\n                    metadata.children = colSpan;\n                    metadata.members = 1;\n                    row.colSpan += colSpan;\n                    row.collapsed += collapsed;\n                    row.rowSpan = childRow.rowSpan + 1;\n                    if (nextMember) {\n                        if (nextMember.measure) {\n                            colSpan = this._measures(nextMember.children, tuple, ' k-alt');\n                        } else {\n                            childRow = this._buildRows(tuple, memberIdx + 1);\n                            colSpan = childRow.colSpan;\n                            row.collapsed += childRow.collapsed;\n                            memberCollapsed = childRow.collapsed;\n                        }\n                        allCell.attr.colSpan = colSpan;\n                        colSpan -= 1;\n                        metadata.members += colSpan;\n                        row.colSpan += colSpan;\n                    }\n                } else if (nextMember) {\n                    if (nextMember.measure) {\n                        colSpan = this._measures(nextMember.children, tuple);\n                    } else {\n                        childRow = this._buildRows(tuple, memberIdx + 1);\n                        colSpan = childRow.colSpan;\n                        row.collapsed += childRow.collapsed;\n                        memberCollapsed = childRow.collapsed;\n                    }\n                    metadata.members = colSpan;\n                    if (colSpan > 1) {\n                        cell.attr.colSpan = colSpan;\n                        row.colSpan += colSpan - 1;\n                    }\n                }\n                if (metadata.maxMembers < metadata.members + memberCollapsed) {\n                    metadata.maxMembers = metadata.members + memberCollapsed;\n                }\n                children = metadata.children + collapsed;\n                if (metadata.maxChildren < children) {\n                    metadata.maxChildren = children;\n                }\n                (allCell || cell).tupleAll = true;\n                return row;\n            }\n        });\n        var RowBuilder = Class.extend({\n            init: function () {\n                this.metadata = {};\n            },\n            build: function (tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            reset: function () {\n                this.metadata = {};\n            },\n            _rowLength: function () {\n                var children = this.rows[0].children;\n                var length = 0;\n                var idx = 0;\n                var cell = children[idx];\n                while (cell) {\n                    length += cell.attr.colSpan || 1;\n                    cell = children[++idx];\n                }\n                return length;\n            },\n            _colGroup: function () {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function (tuples) {\n                var root = tuples[0];\n                this.rootTuple = root;\n                this.rows = [];\n                this.map = {};\n                this._indexes = [];\n                if (root) {\n                    this._buildRows(root, 0);\n                    this._normalize();\n                } else {\n                    this.rows.push(element('tr', null, [element('td', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _normalize: function () {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n                var members = this.rootTuple.members;\n                var firstMemberName = members[0].name;\n                var membersLength = members.length;\n                var memberIdx = 0;\n                var row;\n                var cell;\n                var maxcolSpan;\n                var map = this.map;\n                var allRow;\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n                    for (memberIdx = 0; memberIdx < membersLength; memberIdx++) {\n                        maxcolSpan = this[members[memberIdx].name];\n                        cell = row.colSpan['dim' + memberIdx];\n                        if (cell && cell.colSpan < maxcolSpan) {\n                            cell.attr.colSpan = maxcolSpan - cell.colSpan + 1;\n                        }\n                    }\n                }\n                row = map[firstMemberName];\n                allRow = map[firstMemberName + 'all'];\n                if (row) {\n                    row.children[0].attr.className = 'k-first';\n                }\n                if (allRow) {\n                    allRow.children[0].attr.className += ' k-first';\n                }\n            },\n            _row: function (children) {\n                var row = element('tr', null, children);\n                row.rowSpan = 1;\n                row.colSpan = {};\n                this.rows.push(row);\n                return row;\n            },\n            _content: function (member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\n            },\n            _cell: function (className, children, member) {\n                var cell = element('td', { className: className }, children);\n                cell.value = member.caption || member.name;\n                return cell;\n            },\n            _buildRows: function (tuple, memberIdx) {\n                var map = this.map;\n                var path;\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n                var children = member.children;\n                var childrenLength = children.length;\n                var levelNum = Number(member.levelNum);\n                var rootName = this.rootTuple.members[memberIdx].name;\n                var tuplePath = buildPath(tuple, memberIdx - 1).join('');\n                var rootLevelNum = Number(this.rootTuple.members[memberIdx].levelNum);\n                var parentName = tuplePath + (rootLevelNum === levelNum ? '' : member.parentName || '');\n                var row = map[parentName + 'all'] || map[parentName];\n                var colSpan = levelNum + 1;\n                var cell, allCell;\n                var childRow, allRow;\n                var metadata;\n                var className;\n                var cellChildren = [];\n                var expandIconAttr;\n                var idx;\n                if (!row || row.hasChild) {\n                    row = this._row();\n                } else {\n                    row.hasChild = true;\n                }\n                if (member.measure) {\n                    className = row.allCell ? 'k-grid-footer' : '';\n                    row.children.push(this._cell(className, [this._content(children[0], tuple)], children[0]));\n                    row.rowSpan = childrenLength;\n                    for (idx = 1; idx < childrenLength; idx++) {\n                        this._row([this._cell(className, [this._content(children[idx], tuple)], children[idx])]);\n                    }\n                    return row;\n                }\n                map[tuplePath + member.name] = row;\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n                metadata = this.metadata[path];\n                if (!metadata) {\n                    this.metadata[path] = metadata = createMetadata(levelNum, memberIdx);\n                    metadata.rootLevelNum = rootLevelNum;\n                }\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        childrenLength = 0;\n                        metadata.children = 0;\n                    }\n                    expandIconAttr = { className: 'k-icon ' + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    expandIconAttr[kendo.attr('path')] = path;\n                    cellChildren.push(element('span', expandIconAttr));\n                }\n                cellChildren.push(this._content(member, tuple));\n                className = row.allCell && !childrenLength ? 'k-grid-footer' : '';\n                cell = this._cell(className, cellChildren, member);\n                cell.colSpan = colSpan;\n                row.children.push(cell);\n                row.colSpan['dim' + memberIdx] = cell;\n                if (!this[rootName] || this[rootName] < colSpan) {\n                    this[rootName] = colSpan;\n                }\n                if (childrenLength) {\n                    row.allCell = false;\n                    row.hasChild = false;\n                    for (idx = 0; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx);\n                        if (row !== childRow) {\n                            row.rowSpan += childRow.rowSpan;\n                        }\n                    }\n                    if (row.rowSpan > 1) {\n                        cell.attr.rowSpan = row.rowSpan;\n                    }\n                    metadata.children = row.rowSpan;\n                    allCell = this._cell('k-grid-footer', [this._content(member, tuple)], member);\n                    allCell.colSpan = colSpan;\n                    allRow = this._row([allCell]);\n                    allRow.colSpan['dim' + memberIdx] = allCell;\n                    allRow.allCell = true;\n                    map[tuplePath + member.name + 'all'] = allRow;\n                    if (nextMember) {\n                        childRow = this._buildRows(tuple, memberIdx + 1);\n                        allCell.attr.rowSpan = childRow.rowSpan;\n                    }\n                    row.rowSpan += allRow.rowSpan;\n                    metadata.members = allRow.rowSpan;\n                } else if (nextMember) {\n                    row.hasChild = false;\n                    this._buildRows(tuple, memberIdx + 1);\n                    (allCell || cell).attr.rowSpan = row.rowSpan;\n                    metadata.members = row.rowSpan;\n                }\n                if (metadata.maxChildren < metadata.children) {\n                    metadata.maxChildren = metadata.children;\n                }\n                if (metadata.maxMembers < metadata.members) {\n                    metadata.maxMembers = metadata.members;\n                }\n                return row;\n            }\n        });\n        var ContentBuilder = Class.extend({\n            init: function () {\n                this.columnAxis = {};\n                this.rowAxis = {};\n            },\n            build: function (data, columnAxis, rowAxis) {\n                var index = columnAxis.indexes[0];\n                var metadata = columnAxis.metadata[index ? index.path : undefined];\n                this.columnAxis = columnAxis;\n                this.rowAxis = rowAxis;\n                this.data = data;\n                this.rowLength = metadata ? metadata.maxChildren + metadata.maxMembers : columnAxis.measures.length || 1;\n                if (!this.rowLength) {\n                    this.rowLength = 1;\n                }\n                var tbody = this._tbody();\n                var colgroup = this._colGroup();\n                return [element('table', null, [\n                        colgroup,\n                        tbody\n                    ])];\n            },\n            _colGroup: function () {\n                var length = this.columnAxis.measures.length || 1;\n                var children = [];\n                var idx = 0;\n                if (this.rows[0]) {\n                    length = this.rows[0].children.length;\n                }\n                for (; idx < length; idx++) {\n                    children.push(element('col', null));\n                }\n                return element('colgroup', null, children);\n            },\n            _tbody: function () {\n                this.rows = [];\n                if (this.data[0]) {\n                    this.columnIndexes = this._indexes(this.columnAxis, this.rowLength);\n                    this.rowIndexes = this._indexes(this.rowAxis, Math.ceil(this.data.length / this.rowLength));\n                    this._buildRows();\n                } else {\n                    this.rows.push(element('tr', null, [element('td', null, [htmlNode('&nbsp;')])]));\n                }\n                return element('tbody', null, this.rows);\n            },\n            _indexes: function (axisInfo, total) {\n                var result = [];\n                var axisInfoMember;\n                var indexes = axisInfo.indexes;\n                var metadata = axisInfo.metadata;\n                var measures = axisInfo.measures;\n                var measuresLength = measures.length || 1;\n                var current;\n                var dataIdx = 0;\n                var firstEmpty = 0;\n                var idx = 0;\n                var length = indexes.length;\n                var measureIdx;\n                var index;\n                var children;\n                var skipChildren;\n                if (!length) {\n                    for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {\n                        result[measureIdx] = {\n                            index: measureIdx,\n                            measure: measures[measureIdx],\n                            tuple: null\n                        };\n                    }\n                    return result;\n                }\n                for (; idx < length; idx++) {\n                    axisInfoMember = indexes[idx];\n                    current = metadata[axisInfoMember.path];\n                    children = current.children + current.members;\n                    skipChildren = 0;\n                    if (children) {\n                        children -= measuresLength;\n                    }\n                    if (current.expanded === false && current.children !== current.maxChildren) {\n                        skipChildren = current.maxChildren;\n                    }\n                    if (current.parentMember && current.levelNum === current.rootLevelNum) {\n                        children = -1;\n                    }\n                    if (children > -1) {\n                        for (measureIdx = 0; measureIdx < measuresLength; measureIdx++) {\n                            index = children + measureIdx;\n                            if (!current.children) {\n                                index += firstEmpty;\n                            }\n                            result[children + firstEmpty + measureIdx] = {\n                                children: children,\n                                index: dataIdx,\n                                measure: measures[measureIdx],\n                                tuple: axisInfoMember.tuple\n                            };\n                            dataIdx += 1;\n                        }\n                        while (result[firstEmpty] !== undefined) {\n                            firstEmpty += 1;\n                        }\n                    }\n                    if (firstEmpty === total) {\n                        break;\n                    }\n                    dataIdx += skipChildren;\n                }\n                return result;\n            },\n            _buildRows: function () {\n                var rowIndexes = this.rowIndexes;\n                var length = rowIndexes.length;\n                var idx = 0;\n                for (; idx < length; idx++) {\n                    var rowIndex = rowIndexes[idx];\n                    if (rowIndex) {\n                        this.rows.push(this._buildRow(rowIndex));\n                    }\n                }\n            },\n            _buildRow: function (rowInfo) {\n                var startIdx = rowInfo.index * this.rowLength;\n                var columnIndexes = this.columnIndexes;\n                var length = columnIndexes.length;\n                var columnInfo;\n                var cells = [];\n                var idx = 0;\n                var templateInfo;\n                var cell, cellContent;\n                var attr, dataItem, measure;\n                for (; idx < length; idx++) {\n                    columnInfo = columnIndexes[idx];\n                    if (columnInfo === undefined) {\n                        continue;\n                    }\n                    attr = {};\n                    if (columnInfo.children) {\n                        attr.className = 'k-alt';\n                    }\n                    cellContent = '';\n                    dataItem = this.data[startIdx + columnInfo.index];\n                    measure = columnInfo.measure || rowInfo.measure;\n                    templateInfo = {\n                        columnTuple: columnInfo.tuple,\n                        rowTuple: rowInfo.tuple,\n                        measure: measure,\n                        dataItem: dataItem\n                    };\n                    if (dataItem.value !== '' && measure && measure.type) {\n                        if (measure.type === 'status') {\n                            cellContent = this.kpiStatusTemplate(templateInfo);\n                        } else if (measure.type === 'trend') {\n                            cellContent = this.kpiTrendTemplate(templateInfo);\n                        }\n                    }\n                    if (!cellContent) {\n                        cellContent = this.dataTemplate(templateInfo);\n                    }\n                    cell = element('td', attr, [htmlNode(cellContent)]);\n                    cell.value = dataItem.value;\n                    cells.push(cell);\n                }\n                attr = {};\n                if (rowInfo.children) {\n                    attr.className = 'k-grid-footer';\n                }\n                return element('tr', attr, cells);\n            }\n        });\n        ui.plugin(PivotGrid);\n        kendo.PivotExcelExporter = kendo.Class.extend({\n            init: function (options) {\n                this.options = options;\n                this.widget = options.widget;\n                this.dataSource = this.widget.dataSource;\n            },\n            _columns: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var width = this.widget.options.columnWidth;\n                var result = [];\n                var idx;\n                if (rowHeaderLength && this.dataSource.data()[0]) {\n                    for (idx = 0; idx < rowHeaderLength; idx++) {\n                        result.push({ autoWidth: true });\n                    }\n                }\n                for (idx = 0; idx < columnHeaderLength; idx++) {\n                    result.push({\n                        autoWidth: false,\n                        width: width\n                    });\n                }\n                return result;\n            },\n            _cells: function (rows, type, callback) {\n                var result = [];\n                var i = 0;\n                var length = rows.length;\n                var cellsLength;\n                var row, cells;\n                var j, cell;\n                for (; i < length; i++) {\n                    row = [];\n                    cells = rows[i].children;\n                    cellsLength = cells.length;\n                    for (j = 0; j < cellsLength; j++) {\n                        cell = cells[j];\n                        row.push({\n                            background: '#7a7a7a',\n                            color: '#fff',\n                            value: cell.value,\n                            colSpan: cell.attr.colSpan || 1,\n                            rowSpan: cell.attr.rowSpan || 1\n                        });\n                    }\n                    if (callback) {\n                        callback(row, i);\n                    }\n                    result.push({\n                        cells: row,\n                        type: type\n                    });\n                }\n                return result;\n            },\n            _rows: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var columnHeaderRows = columnHeaderTable.children[1].children;\n                var rowHeaderRows = rowHeaderTable.children[1].children;\n                var contentRows = this.widget.contentTree.children[0].children[1].children;\n                var columnRows = this._cells(columnHeaderRows, 'header');\n                if (rowHeaderLength) {\n                    columnRows[0].cells.splice(0, 0, {\n                        background: '#7a7a7a',\n                        color: '#fff',\n                        value: '',\n                        colSpan: rowHeaderLength,\n                        rowSpan: columnHeaderRows.length\n                    });\n                }\n                var dataCallback = function (row, index) {\n                    var j = 0;\n                    var cell, value;\n                    var cells = contentRows[index].children;\n                    for (; j < columnHeaderLength; j++) {\n                        cell = cells[j];\n                        value = Number(cell.value);\n                        if (isNaN(value)) {\n                            value = cell.value;\n                        }\n                        row.push({\n                            background: '#dfdfdf',\n                            color: '#333',\n                            value: value,\n                            colSpan: 1,\n                            rowSpan: 1\n                        });\n                    }\n                };\n                var rowRows = this._cells(rowHeaderRows, 'data', dataCallback);\n                return columnRows.concat(rowRows);\n            },\n            _freezePane: function () {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var columnHeaderRows = columnHeaderTable.children[1].children;\n                return {\n                    colSplit: rowHeaderLength,\n                    rowSplit: columnHeaderRows.length\n                };\n            },\n            workbook: function () {\n                var promise;\n                if (this.dataSource.view()[0]) {\n                    promise = $.Deferred();\n                    promise.resolve();\n                } else {\n                    promise = this.dataSource.fetch();\n                }\n                return promise.then($.proxy(function () {\n                    return {\n                        sheets: [{\n                                columns: this._columns(),\n                                rows: this._rows(),\n                                freezePane: this._freezePane(),\n                                filter: null\n                            }]\n                    };\n                }, this));\n            }\n        });\n        var PivotExcelMixin = {\n            extend: function (proto) {\n                proto.events.push('excelExport');\n                proto.options.excel = $.extend(proto.options.excel, this.options);\n                proto.saveAsExcel = this.saveAsExcel;\n            },\n            options: {\n                proxyURL: '',\n                filterable: false,\n                fileName: 'Export.xlsx'\n            },\n            saveAsExcel: function () {\n                var excel = this.options.excel || {};\n                var exporter = new kendo.PivotExcelExporter({ widget: this });\n                exporter.workbook().then($.proxy(function (book) {\n                    if (!this.trigger('excelExport', { workbook: book })) {\n                        var workbook = new kendo.ooxml.Workbook(book);\n                        workbook.toDataURLAsync().then(function (dataURI) {\n                            kendo.saveAs({\n                                dataURI: dataURI,\n                                fileName: book.fileName || excel.fileName,\n                                proxyURL: excel.proxyURL,\n                                forceProxy: excel.forceProxy\n                            });\n                        });\n                    }\n                }, this));\n            }\n        };\n        kendo.PivotExcelMixin = PivotExcelMixin;\n        if (kendo.ooxml && kendo.ooxml.Workbook) {\n            PivotExcelMixin.extend(PivotGrid.prototype);\n        }\n        if (kendo.PDFMixin) {\n            kendo.PDFMixin.extend(PivotGrid.prototype);\n            PivotGrid.fn._drawPDF = function () {\n                return this._drawPDFShadow({ width: this.wrapper.width() }, { avoidLinks: this.options.pdf.avoidLinks });\n            };\n        }\n        if (kendo.PDFMixin) {\n            kendo.PDFMixin.extend(PivotGridV2.prototype);\n            PivotGridV2.fn._drawPDF = function () {\n                return this._drawPDFShadow({ width: this.wrapper.width() }, { avoidLinks: this.options.pdf.avoidLinks });\n            };\n        }\n    }(window.kendo.jQuery));\n    return window.kendo;\n}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {\n    (a3 || a2)();\n}));"]}