{"version":3,"file":"kendo.pivotgrid.min.js","names":["factory","define","amd","$","undefined$1","kendo","window","ui","Class","Comparer","data","Widget","DataSource","outerWidth","_outerWidth","outerHeight","_outerHeight","common","pivotgrid","fetchDiscover","normalizeFilter","Query","normalizeSort","toString","identity","o","map","extend","isFunction","fetchData","createLocalDataState","createDataTree","sumAggregate","averageAggregate","minAggregate","maxAggregate","createDataState","toColumns","toRows","toTree","toData","headersReducer","RESIZE","READ","CHANGE","ERROR","PROGRESS","MEASURES","STATERESET","AUTO","DIV","NS","ROW_TOTAL_KEY","DATABINDING","DATABOUND","EXPANDMEMBER","COLLAPSEMEMBER","STATE_EXPANDED","STATE_COLLAPSED","HEADER_TEMPLATE","DATACELL_TEMPLATE","normalizeMeasures","measure","descriptor","name","descriptors","call","d","type","normalizeMembers","member","expand","slice","normalizeName","indexOf","accumulateMembers","accumulator","rootTuple","tuple","level","idx","length","children","members","stringify","buildPath","descriptorsForAxes","tuples","result","k","push","JSON","parse","descriptorsForMembers","axis","measures","firstTuple","tupleMembers","found","j","getName","hierarchy","addMissingPathMembers","tupletoSearch","findExistingTuple","tupleToDescriptors","createAggregateGetter","m","measureGetter","getter","field","aggregatorContext","state","aggregate","dataItem","isNumber","val","isNaN","isDate","getTime","flattenSortDescriptors","i","dir","split","pop","createLocalMeasure","key","format","measureMap","Sum","Average","Min","Max","value","item","this","bind","caption","uniqueName","functions","sum","count","average","max","min","PivotCubeBuilder","init","options","dimensions","_normalizeDescriptors","keyField","fields","_rootTuples","rootNames","measureAggregators","root","parts","aggregatorsLength","dimensionsSchema","measureIdx","rootNamesLength","keys","levelName","levelNum","hasChildren","parentName","_sortMap","sortDescriptors","flattenTree","mapItem","sortedMaps","sortTree","directParentName","fillSortTree","sortItemsTree","create","flatColumns","index","_expandedTuples","expanded","current","currentKeys","memberInfo","expandedNames","accumulatorKeys","isEmptyObject","_findExpandedMember","uniquePath","names","expandedIdx","join","_asTuples","rootInfo","expandedInfo","concat","apply","_measuresInfo","rowAxis","aggregateNames","resultFuncs","formats","_toDataArray","measuresInfo","rowKeys","columnKeys","aggregates","n","row","column","columnKey","columnMeasureNames","rowMeasureNamesLength","rowMeasureNames","rowLength","columnLength","items","_addData","resultFunc","ordinal","fmtValue","_matchDescriptors","getters","parentField","expectedValue","_calculateAggregate","totalItem","aggregator","_processColumns","columns","rowTotal","updateColumn","path","columnIndex","childrenMap","_measureAggregators","defaultAggregate","measureDescriptors","aggregators","toLowerCase","Error","_buildGetters","_parseDescriptors","parsedDescriptors","parseDescriptors","getRootNames","mapNames","_filter","filter","expr","filters","operator","_normalizeFilter","logic","process","measuresRowAxis","measuresAxis","columnDescriptors","rowDescriptors","rows","rowValue","rowIdx","rowDescriptor","rowName","columnsInfo","rowsInfo","aggregatedData","columnGetters","rowGetters","processed","expandedColumns","expandedRows","hasExpandedRows","sort","axes","PivotTransport","transport","discover","read","update","destroy","success","catalog","connection","cube","PivotDataSourceV2","schema","cubes","catalogs","hierarchies","levels","cubeSchema","_cubeSchema","fn","transportOptions","_online","XmlaTransportV2","_columns","_rows","_measuresAxis","values","_measures","serverSorting","serverPaging","serverFiltering","serverGrouping","serverAggregates","normalizeAxis","_mergeState","fetch","callback","that","_data","_query","done","_createSettings","settings","dimensionsSettings","displayValueFunc","sortValueFunc","displayValue","sortValue","defaultHierarchy","restoreMeasure","memberType","_pristineData","distinct","levelUniqueName","childrenCardinality","isPrevented","trigger","params","_params","deferred","Deferred","originalData","reader","columnSettings","columnAxes","rowSettings","rowAxes","stateArgs","dataTree","dataField","columnsData","reverse","_saveState","resolve","newDataState","response","_preventRefresh","error","err","promise","measureAxes","schemaMeasures","command","restrictions","catalogName","cubeName","schemaKPIs","schemaDimensions","schemaHierarchies","dimensionName","dimensionUniqueName","schemaLevels","hierarchyName","hierarchyUniqueName","schemaCubes","schemaCatalogs","schemaMembers","_columnTuples","_rowTuples","_view","PivotDataSource","cubeBuilder","_skipNormalize","_axes","memberUniqueName","schemaData","dataGetter","_rawData","treeOp","_clearAxesData","query","rowsAxisDescriptors","columnsAxisDescriptors","_expandPath","origin","other","memberToExpand","_lastExpanded","_descriptorsForAxis","_process","e","page","pageSize","group","_updateLocalData","expandColumn","expandRow","_processResult","processedData","_requestData","columnIndexes","rowIndexes","resultAxis","axisToSkip","hasColumnTuples","_rowMeasures","_normalizeTuples","_columnMeasures","_normalizeData","columnsLength","rowsLength","validateAxis","sourceTuples","targetTuples","columnIdx","dataIdx","targetColumnsLength","membersCount","measuresLength","tupleIndex","adjustDataByColumn","adjustDataByRow","_mergeAxes","_readData","newData","_createTuple","buildRoot","Number","_hasRoot","target","source","isRoot","sourceAxes","startIndex","columnMeasures","rowMeasures","oldRowsLength","newRowsLength","oldColumnsLength","newColumnsLength","rowIndex","dataIndex","calcIndex","indices","buildDataIndices","Math","prepareDataOnColumns","parseSource","mergedColumns","mergeTuples","targetIndex","sourceIndex","parseInt","prepareDataOnRows","mergedRows","findDataIndex","parsedRoot","memberIndex","offset","_mergeColumnData","_mergeRowData","toAdd","toJSON","drop","splice","_observe","_ranges","_addRange","_total","_pristineTotal","memberIdx","last","roots","indexes","tupleName","_addMissingDataItems","metadata","addEmptyDataItem","_normalizeOrdinals","lastOrdinal","converter","_handleCustomErrors","status","reject","kpis","sortFunction","currentItem","newAxis","collection","queue","shift","counter","targetMembers","sourceMembers","equalTuples","first","second","equal","toFind","membersLength","addMembers","len","findParentMember","parentMember","parentPath","normalizeTupleMeasures","measureIndex","measurePosition","spliceIndex","baseHierarchyPath","memberName","expandMemberDescriptor","sortDescriptor","sortDescriptorForMember","crossJoin","r","crossJoinCommand","tmp","measureNames","rootName","rootLength","l","child","serializeMembers","crossJoinCommands","dataSource","filterFunctionFormats","contains","doesnotcontain","startswith","endswith","eq","neq","serializeExpression","expression","serializeOptions","parentTagName","capitalize","replace","toUpperCase","xmlaDiscoverCommands","convertersMap","serializeFilters","properties","Catalog","XmlaTransport","RemoteTransport","originalOptions","url","setup","dataType","contentType","parameterMap","ajax","fetchOptions","noop","then","catch","asArray","object","translateAxis","captionGetter","unameGetter","levelNameGetter","levelNumGetter","childrenGetter","hierarchyGetter","parentNameGetter","Member","schemaDataReaderMap","description","groupName","displayFolder","defaultFormat","goal","trend","statusGraphic","trendGraphic","defaultMember","orderingProperty","xmlaReaderMethods","XmlaDataReader","XmlDataReader","_extend","methodName","option","xml","errors","fault","faultstring","faultcode","cells","ordinalGetter","valueGetter","fmtValueGetter","_mapSchema","obj","transports","xmla","readers","removeExpr","expressions","PivotSettingTarget","element","addClass","_refreshHandler","refresh","template","actions","enabled","ns","emptyTemplate","_sortable","on","action","closest","attr","hasClass","remove","sortable","sortDirection","currentTarget","find","filterable","fieldMenu","PivotFieldMenu","messages","setting","empty","setDataSource","unbind","kendoSortable","connectWith","hint","cursor","start","change","add","move","newIndex","_isKPI","validate","isMeasure","Array","isArray","sortExpressions","_sort","skipExpr","allowUnsort","html","sortIcon","_sortIcon","off","sortExpr","icon","PivotSettingTargetV2","parent","text","PivotFieldMenuV2","events","_applyState","_sortState","_stateFilter","_savedState","_cancelChanges","deepExtend","_initialState","_redraw","_state","newState","modifyInit","focus","blur","_savedFilter","_emptyState","enable","removeClass","_targetsHTML","menuenabled","PivotConfiguratorButton","_element","_attachEvents","configurator","setOptions","toggle","pivot","pivotEl","toggleClass","getKendoPivotGridV2","_setContentWidth","_updateDimensions","PivotContainer","_addClasses","configuratorPosition","className","PivotGridV2","_dataSource","_bindConfigurator","_wrapper","_columnHeadersWrapper","_rowHeadersWrapper","_contentWrapper","wrapper","append","_columnBuilder","ColumnRowBuilder","columnHeaderTemplate","_rowBuilder","rowHeaderTemplate","_contentBuilder","ContentBuilderV2","dataCellTemplate","_scrollable","button","isRow","paths","eventName","reducerPayLoad","payload","tree","getTree","currentAxes","newHeaders","autoBind","notify","height","columnWidth","_windowResizeHandler","_progressHandler","_errorHandler","_requestStart","_error","_resize","div","scrollbar","style","setProperty","document","createElement","cssText","innerHTML","body","appendChild","offsetWidth","scrollWidth","removeChild","columnsHeader","rowsHeader","scroll","scrollLeft","scrollTop","_wheelScroll","ctrlKey","delta","wheelDeltaY","preventDefault","one","css","_progress","progress","offsetHeight","contentTable","columnTable","rowTable","width","kendoPivotConfiguratorV2","cellInfoByElement","cellInfo","contentBuilder","columnsCount","rowsCount","columnTuple","hash","rowTuple","setTuples","build","setRowColumnInfo","columnHeaderLeafs","getHeaderLeafs","rowHeaderLeafs","columnHeaderBreadth","getBreadth","rowHeaderDepth","plugin","PivotGrid","columnBuilder","rowBuilder","_createLayout","ColumnBuilder","RowBuilder","ContentBuilder","_templates","builder","eventArgs","parseJSON","is","request","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","calculatedWidth","minWidth","ceil","_resetColspan","skipScrollbar","clientHeight","cell","_colspan","_layoutTimeout","_axisMeasures","hasMeasure","columnAxis","render","_indexes","touchScroller","contentResized","movable","sender","x","y","htmlNode","createMetadata","maxMembers","addColElements","table","addRowElements","addColumCell","rowEl","rowItem","cellEl","total","headerTemplate","columnHeaderRows","rowspan","rowSpan","colspan","colSpan","iconClass","expandable","headerClass","treeData","headerRows","headerLeafs","breadth","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","background","color","rowHeaderRows","contentRows","columnRows","rowRows","_freezePane","colSplit","rowSplit","workbook","sheets","freezePane","PivotExcelMixin","proto","excel","saveAsExcel","proxyURL","fileName","book","ooxml","Workbook","toDataURLAsync","dataURI","saveAs","forceProxy","prototype","PDFMixin","_drawPDF","_drawPDFShadow","avoidLinks","pdf","jQuery"],"sources":["kendo.pivotgrid.js"],"mappings":"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","sourcesContent":["(function (factory) {\n    typeof define === 'function' && define.amd ? define(['kendo.pivot.common', 'kendo.dom', 'kendo.data'], factory) :\n    factory();\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: [ \"dom\", \"data\", \"data.xml\", \"sortable\", \"pivot.common\" ],\n        features: [{\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            id: \"pivotgrid-filtering\",\n            name: \"Filtering\",\n            description: \"Support for filtering\",\n            depends: [ \"pivot.fieldmenu\" ]\n        }, {\n            id: \"pivotgrid-excel-export\",\n            name: \"Excel export\",\n            description: \"Export pivot grid data as Excel spreadsheet\",\n            depends: [ \"ooxml\" ]\n        }, {\n            id: \"pivotgrid-pdf-export\",\n            name: \"PDF export\",\n            description: \"Export pivot grid data as PDF\",\n            depends: [ \"pdf\", \"drawing\" ]\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\n    (function($, undefined$1) {\n        var kendo = window.kendo,\n            ui = kendo.ui,\n            Class = kendo.Class,\n            Comparer = kendo.data.Comparer,\n            Widget = ui.Widget,\n            DataSource = kendo.data.DataSource,\n            outerWidth = kendo._outerWidth,\n            outerHeight = kendo._outerHeight,\n            common = window.kendo.pivotgrid.common,\n            fetchDiscover = common.fetchDiscover,\n            normalizeFilter = kendo.data.Query.normalizeFilter,\n            normalizeSort = kendo.data.Query.normalizeSort,\n            toString = {}.toString,\n            identity = function(o) { return o; },\n            map = $.map,\n            extend = $.extend,\n            isFunction = kendo.isFunction,\n            fetchData = common.fetchData,\n            createLocalDataState = common.createLocalDataState,\n            createDataTree = common.createDataTree,\n            sumAggregate = common.sumAggregate,\n            averageAggregate = common.averageAggregate,\n            minAggregate = common.minAggregate,\n            maxAggregate = common.maxAggregate,\n            createDataState = common.createDataState,\n            toColumns = common.toColumns,\n            toRows = common.toRows,\n            toTree = common.toTree,\n            toData = common.toData,\n            headersReducer = common.headersReducer,\n            RESIZE = \"resize\",\n            READ = \"read\",\n            CHANGE = \"change\",\n            ERROR = \"error\",\n            REQUESTSTART = \"requestStart\",\n            PROGRESS = \"progress\",\n            REQUESTEND = \"requestEnd\",\n            MEASURES = \"Measures\",\n            STATERESET = \"stateReset\",\n            AUTO = \"auto\",\n            DIV = \"<div></div>\",\n            NS = \".kendoPivotGrid\",\n            ROW_TOTAL_KEY = \"__row_total__\",\n            DATABINDING = \"dataBinding\",\n            DATABOUND = \"dataBound\",\n            EXPANDMEMBER = \"expandMember\",\n            HEADERTEMPLATE = '<th data-key=\"#:key#\" class=\"#:headerClass#\" #if (colspan) {#colspan=\"#:colspan#\"#}# #if (rowspan) {#rowspan=\"#:rowspan#\"#}#>' +\n                                        '#if (expandable) {# <span class=\"k-icon k-i-arrow-chevron-#:iconClass# k-color-inherit\" role=\"presentation\"></span>#}#' +\n                                    '</th>',\n            COLLAPSEMEMBER = \"collapseMember\",\n            STATE_EXPANDED = \"k-i-collapse\",\n            STATE_COLLAPSED = \"k-i-expand\",\n            HEADER_TEMPLATE = \"<span>#: data.member.caption || data.member.name #</span>\",\n            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>',\n            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>',\n            DATACELL_TEMPLATE = '#= data.dataItem ? kendo.htmlEncode(data.dataItem.fmtValue || data.dataItem.value) || \"&nbsp;\" : \"&nbsp;\" #',\n            LAYOUT_TABLE = '<table class=\"k-pivot-layout\">' +\n                                '<tr>' +\n                                    '<td>' +\n                                        '<div class=\"k-pivot-rowheaders\"></div>' +\n                                    '</td>' +\n                                    '<td>' +\n                                        '<div class=\"k-pivot-table\"></div>' +\n                                    '</td>' +\n                                '</tr>' +\n                            '</table>';\n            var AXIS_ROWS = \"rows\";\n            var AXIS_COLUMNS = \"columns\";\n\n        function normalizeMeasures(measure) {\n            var descriptor = typeof measure === \"string\" ? [{ name: measure }] : measure;\n            var descriptors = toString.call(descriptor) === \"[object Array]\" ? descriptor : (descriptor !== undefined$1 ? [descriptor] : []);\n\n            return map(descriptors, function(d) {\n                if (typeof d === \"string\") {\n                    return { name: d };\n                }\n                return $.extend(true, d, { name: d.name, type: d.type });\n            });\n        }\n\n        function normalizeMembers(member) {\n            var descriptor = typeof member === \"string\" ? [{ name: [member], expand: false }] : member;\n            var descriptors = toString.call(descriptor) === \"[object Array]\" ? descriptor : (descriptor !== undefined$1 ? [descriptor] : []);\n\n            return map(descriptors, function(d) {\n                if (typeof d === \"string\") {\n                    return { name: [d], expand: false };\n                }\n                return { name: (toString.call(d.name) === \"[object Array]\" ? d.name.slice() : [d.name]), expand: d.expand };\n            });\n        }\n\n        function normalizeName(name) {\n            if (name.indexOf(\" \") !== -1) {\n                name = '[\"' + name + '\"]';\n            }\n\n            return name;\n        }\n\n        function accumulateMembers(accumulator, rootTuple, tuple, level) {\n            var idx, length;\n            var children;\n            var member;\n\n            if (!tuple) {\n                tuple = rootTuple;\n            }\n\n            if (!level) {\n                level = 0;\n            }\n\n            member = tuple.members[level];\n\n            if (!member || member.measure) { //return if no member or measure\n                return;\n            }\n\n            children = member.children;\n            length = children.length;\n\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\n            if (length) {\n                for (idx = 0; idx < length; idx++) {\n                    accumulateMembers(accumulator, rootTuple, children[idx], level);\n                }\n            }\n\n            accumulateMembers(accumulator, rootTuple, tuple, level + 1);\n        }\n\n        function descriptorsForAxes(tuples) {\n            var result = {};\n\n            if (tuples.length) {\n                accumulateMembers(result, tuples[0]);\n            }\n\n            var descriptors = [];\n            for (var k in result) {\n                descriptors.push({ name: JSON.parse(k), expand: result[k] });\n            }\n\n            return descriptors;\n        }\n\n        function addMissingPathMembers(members, axis) {\n            var tuples = axis.tuples || [];\n            var firstTuple = tuples[0];\n\n            if (firstTuple && members.length < firstTuple.members.length) {\n                var tupleMembers = firstTuple.members;\n\n                for (var idx = 0; idx < tupleMembers.length; idx++) {\n                    if (tupleMembers[idx].measure) {\n                        continue;\n                    }\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\n                    if (!found) {\n                        members.push({ name: [tupleMembers[idx].name], expand: false }); //calling normalize here to make name from string to array\n                    }\n                }\n            }\n        }\n\n        function tupleToDescriptors(tuple) {\n            var result = [];\n            var members = tuple.members;\n\n            for (var idx = 0; idx < members.length; idx++) {\n                if (members[idx].measure) {\n                    continue;\n                }\n\n                //make tuple name an array\n                result.push({ name: [members[idx].name], expand: members[idx].children.length > 0 });\n            }\n\n            return result;\n        }\n\n        function descriptorsForMembers(axis, members, measures) {\n            axis = axis || {};\n\n            addMissingPathMembers(members, axis);\n\n            if (measures.length > 1) {\n                members.push({\n                    name: MEASURES,\n                    measure: true,\n                    children: normalizeMembers(measures)\n                });\n            }\n\n            var tupletoSearch = {\n                members: members\n            };\n\n            if (axis.tuples) {\n                var result = findExistingTuple(axis.tuples, tupletoSearch);\n                if (result.tuple) {\n                    members = tupleToDescriptors(result.tuple);\n                }\n            }\n\n            return members;\n        }\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\n        function isNumber(val) {\n            return typeof val === \"number\" && !isNaN(val);\n        }\n\n        function isDate(val) {\n            return val && val.getTime;\n        }\n\n        function getScollWidth() {\n            var scrollbar = 0;\n            var div;\n            if (document && document.createElement) {\n                div = document.createElement('div');\n\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\n                scrollbar = div.offsetWidth - div.scrollWidth;\n\n                document.body.removeChild(div);\n            }\n\n            return scrollbar;\n        }\n\n        function flattenSortDescriptors(descriptors) {\n            var result = [];\n            for (var i = 0; i < descriptors.length; i++) {\n                result.push({\n                    dir: descriptors[i].dir,\n                    field: descriptors[i].field.split(\".\").pop()\n                });\n            }\n            return result;\n        }\n\n        function createLocalMeasure(field, key, format) {\n            var formatFunc = function(value) { return kendo.format(this.format, value); };\n            var measureMap = {\n                \"Sum\": sumAggregate,\n                \"Average\": averageAggregate,\n                \"Min\": minAggregate,\n                \"Max\": maxAggregate,\n            };\n            var valueFunc = function(item) { return item[this.field]; };\n            var measure = {\n                    value: valueFunc.bind({ field: field }),\n                    aggregate: measureMap[key],\n                    caption: key,\n                    uniqueName: key,\n                    type: 2,\n                    name: [key]\n                };\n            if (format) {\n                measure.aggregate.format = formatFunc.bind({ format: format });\n            }\n\n            return measure;\n        }\n\n\n        var functions = {\n            sum: function(value, state) {\n                var accumulator = state.accumulator;\n\n                if (!isNumber(accumulator)) {\n                    accumulator = value;\n                } else if (isNumber(value)) {\n                    accumulator += value;\n                }\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\n                    if (state.count === undefined$1) {\n                        state.count = 0;\n                    }\n\n                    if (!isNumber(accumulator)) {\n                        accumulator = value;\n                    } else if (isNumber(value)) {\n                        accumulator += value;\n                    }\n\n                    if (isNumber(value)) {\n                        state.count++;\n                    }\n\n                    return accumulator;\n                },\n                result: function(state) {\n                    var accumulator = state.accumulator;\n\n                    if (isNumber(accumulator)) {\n                        accumulator = accumulator / state.count;\n                    }\n\n                    return accumulator;\n                }\n            },\n            max: function(value, state) {\n                var accumulator = state.accumulator;\n\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\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\n                if (!isNumber(accumulator) && !isDate(accumulator)) {\n                    accumulator = value;\n                }\n\n                if (accumulator > value && (isNumber(value) || isDate(value))) {\n                    accumulator = value;\n                }\n                return accumulator;\n            }\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\n            _normalizeDescriptors: function(keyField, descriptors) {\n                descriptors = descriptors || {};\n                var fields = {};\n                var field;\n\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\n                return descriptors;\n            },\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\n                var rootNamesLength = rootNames.length;\n                var result = [];\n                var keys = [];\n\n                if (rootNamesLength || measureAggregators.length) {\n                    for (measureIdx = 0; measureIdx < aggregatorsLength; measureIdx++) {\n\n                        root = { members: [] };\n\n                        for (idx = 0; idx < rootNamesLength; idx++) {\n                            name = rootNames[idx];\n                            parts = name.split(\"&\");\n\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$1,\n                                hierarchy: name\n                            };\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$1,\n                                hierarchy: \"MEASURES\"\n                            };\n                        }\n\n                        result[result.length] = root;\n                    }\n\n                    keys.push(ROW_TOTAL_KEY);\n                }\n\n                return {\n                    keys: keys,\n                    tuples: result\n                };\n            },\n\n            _sortMap: function(map, sortDescriptors) {\n                var sortedMaps = [];\n                var sortTree = [];\n                var flattenTree = [];\n                var mapItem;\n                var key;\n\n                for (key in map) {\n                    if (!map[key].directParentName) {\n                        sortTree.push($.extend({}, { name: key, parentName: map[key].parentName }));\n                    }\n                }\n\n                //if there are no root this means that something is expanding\n                //and we should only sort that part of the tree\n                if (!sortTree.length) {\n                    for (key in map) {\n                        sortTree.push($.extend({}, { name: key, parentName: map[key].parentName }));\n                    }\n                }\n\n                fillSortTree(sortTree, map);\n\n                // fill tree recursive\n                for (var i = 0; i < sortDescriptors.length; i++) {\n                    sortItemsTree(sortDescriptors[i].field.split(\".\").pop(), sortTree, Comparer.create({ field: \"name\", dir: sortDescriptors[i].dir }));\n                }\n\n                flattenTree = flatColumns(sortTree);\n\n                //we need to flatten the structure so the tuples can build correctly\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\n                return sortedMaps;\n            },\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\n                var key;\n                var mapItem;\n                var current;\n                var currentKeys;\n                var accumulator = [];\n                var accumulatorKeys = [];\n                var memberInfo;\n\n                var expandedNames;\n                var parts;\n                var name;\n                var idx;\n\n                if (sortDescriptors && sortDescriptors.length && !$.isEmptyObject(map)) {\n                    map = this._sortMap(map, sortDescriptors);\n                }\n\n                for (key in map) {\n                    mapItem = map[key];\n                    memberInfo = this._findExpandedMember(expanded, mapItem.uniquePath);\n\n                    current = accumulator[memberInfo.index] || [];\n                    currentKeys = accumulatorKeys[memberInfo.index] || [];\n\n                    expandedNames = memberInfo.member.names;\n\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\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$1,\n                                    hierarchy: name\n                                };\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$1,\n                                hierarchy: \"MEASURES\"\n                            };\n                        }\n\n                        current[current.length] = tuple;\n                    }\n\n                    accumulator[memberInfo.index] = current;\n                    accumulatorKeys[memberInfo.index] = currentKeys;\n                }\n\n                return {\n                    keys: accumulatorKeys,\n                    tuples: accumulator\n                };\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\n            _asTuples: function(map, descriptor, measureAggregators, sortDescriptors) {\n                measureAggregators = measureAggregators || [];\n\n                var rootInfo = this._rootTuples(descriptor.root, measureAggregators);\n                var expandedInfo = this._expandedTuples(map, descriptor.expanded, measureAggregators, sortDescriptors);\n\n                return {\n                    keys: [].concat.apply(rootInfo.keys, expandedInfo.keys),\n                    tuples: [].concat.apply(rootInfo.tuples, expandedInfo.tuples)\n                };\n            },\n\n            _measuresInfo: function(measures, rowAxis) {\n                var idx = 0;\n                var length = measures && measures.length;\n\n                var aggregateNames = [];\n                var resultFuncs = {};\n                var formats = {};\n\n                var descriptors = (this.measures || {});\n                var measure;\n                var name;\n\n                for (; idx < length; idx++) {\n                    name = measures[idx].descriptor.name;\n                    measure = descriptors[name] || {};\n\n                    aggregateNames.push(name);\n\n                    if (measure.result) {\n                        resultFuncs[name] = measure.result;\n                    }\n\n                    if (measure.format) {\n                        formats[name] = measure.format;\n                    }\n                }\n\n                return {\n                    names: aggregateNames,\n                    formats: formats,\n                    resultFuncs: resultFuncs,\n                    rowAxis: rowAxis\n                };\n            },\n\n            _toDataArray: function(map, measuresInfo, rowKeys, columnKeys) {\n                var result = [];\n\n                var aggregates;\n                var name, i, j, k, n;\n                var row, column, columnKey;\n\n                var rowMeasureNamesLength = 1;\n                var rowMeasureNames = [];\n                var columnMeasureNames;\n\n                var rowLength = rowKeys.length || 1;\n                var columnLength = columnKeys.length || 1;\n\n                if (measuresInfo.rowAxis) {\n                    rowMeasureNames = measuresInfo.names;\n                    rowMeasureNamesLength = rowMeasureNames.length;\n                } else {\n                    columnMeasureNames = measuresInfo.names;\n                }\n\n                for (i = 0; i < rowLength; i++) {\n                    row = map[rowKeys[i] || ROW_TOTAL_KEY];\n\n                    for (n = 0; n < rowMeasureNamesLength; n++) {\n                        if (measuresInfo.rowAxis) {\n                            columnMeasureNames = [rowMeasureNames[n]];\n                        }\n\n                        for (j = 0; j < columnLength; j++) {\n                            columnKey = columnKeys[j] || ROW_TOTAL_KEY;\n                            column = row.items[columnKey];\n\n                            if (columnKey === ROW_TOTAL_KEY) {\n                                aggregates = row.aggregates;\n                            } else {\n                                aggregates = column ? column.aggregates : {};\n                            }\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\n                return result;\n            },\n\n            _addData: function(result, value, format, resultFunc) {\n                var fmtValue = \"\";\n                var ordinal;\n\n                if (value) {\n                    value = resultFunc ? resultFunc(value) : value.accumulator;\n                    fmtValue = format ? kendo.format(format, value) : value;\n                }\n\n                ordinal = result.length;\n\n                result[ordinal] = {\n                    ordinal: ordinal,\n                    value: value || \"\",\n                    fmtValue: fmtValue\n                };\n            },\n\n            _matchDescriptors: function(dataItem, descriptor, getters) {\n                var parts;\n                var parentField;\n                var expectedValue;\n\n                var names = descriptor.names;\n                var idx = descriptor.expandedIdx;\n                var value;\n\n                while (idx > 0) {\n                    parts = names[--idx].split(\"&\");\n                    if (parts.length > 1) {\n                        parentField = parts[0];\n                        expectedValue = parts[1];\n\n                        value = getters[parentField](dataItem);\n                        value = (value !== undefined$1 && value !== null) ? value.toString() : value;\n\n                        if (value != expectedValue) {\n                            return false;\n                        }\n                    }\n                }\n                return true;\n            },\n\n            _calculateAggregate: function(measureAggregators, aggregatorContext, totalItem) {\n                var result = {};\n                var state;\n                var name;\n\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\n                return result;\n            },\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\n                for (; idx < descriptors.length; idx++) {\n                    descriptor = descriptors[idx];\n\n                    //checks whether the dataItem is relevant to the descriptors\n                    if (!this._matchDescriptors(dataItem, descriptor, getters)) {\n                        continue;\n                    }\n\n                    path = descriptor.names.slice(0, descriptor.expandedIdx).join(\"\");\n                    name = descriptor.names[descriptor.expandedIdx];\n\n\n                    value = getters[name](dataItem);\n                    value = (value !== undefined$1 && value !== null) ? value.toString() : value;\n\n                    parentName = name;\n                    name = name + \"&\" + value;\n                    key = path + name;\n\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\n                    if (path && columns[path] && !columns[path].childrenMap[path + parentName + \"&\" + value]) {\n                        columns[path].childrenMap[path + parentName + \"&\" + value] = true;\n                    }\n\n                    totalItem = rowTotal.items[key] || {\n                        aggregates: {}\n                    };\n\n                    rowTotal.items[key] = {\n                        index: column.index,\n                        aggregates: this._calculateAggregate(measureAggregators, aggregatorContext, totalItem)\n                    };\n\n                    if (updateColumn) {\n                        if (!columns[key]) {\n                            state.columnIndex++;\n                        }\n                        columns[key] = column;\n                    }\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\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\n                        if (measure) {\n                            aggregate = measure.aggregate;\n                            if (typeof aggregate === \"string\") {\n                                defaultAggregate = functions[aggregate.toLowerCase()];\n\n                                if (!defaultAggregate) {\n                                    throw new Error(\"There is no such aggregate function\");\n                                }\n\n                                measure.aggregate = defaultAggregate.aggregate || defaultAggregate;\n                                measure.result = defaultAggregate.result;\n                            }\n\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() { return 1; }\n                    });\n                }\n\n                return aggregators;\n            },\n\n            _buildGetters: function(names) {\n                var result = {};\n                var parts;\n                var name;\n\n                for (var idx = 0; idx < names.length; idx++) {\n                    name = names[idx];\n                    parts = name.split(\"&\");\n\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\n                return result;\n            },\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\n                for (var idx = 0; idx < expanded.length; idx++) {\n                    result.push(mapNames(expanded[idx].name, rootNames));\n                }\n\n                return {\n                    root: rootNames,\n                    expanded: result\n                };\n            },\n\n            _filter: function(data, filter) {\n                if (!filter) {\n                    return data;\n                }\n\n                var expr;\n                var idx = 0;\n                var filters = filter.filters;\n\n                for (; idx < filters.length; idx++) {\n                    expr = filters[idx];\n\n                    if (expr.operator === \"in\") {\n                        filters[idx] = this._normalizeFilter(expr);\n                    }\n                }\n\n                return new kendo.data.Query(data).filter(filter).data;\n            },\n\n            _normalizeFilter: function(filter) {\n                var value = filter.value.split(\",\");\n                var result = [];\n\n                if (!value.length) {\n                    return value;\n                }\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\n                return {\n                    logic: \"or\",\n                    filters: result\n                };\n            },\n\n            process: function(data, options) {\n                data = data || [];\n                options = options || {};\n\n                data = this._filter(data, options.filter);\n\n                var measures = options.measures || [];\n\n                var measuresRowAxis = options.measuresAxis === \"rows\";\n\n                var columnDescriptors = options.columns || [];\n                var rowDescriptors = options.rows || [];\n\n                if (!columnDescriptors.length && rowDescriptors.length && (!measures.length || (measures.length && measuresRowAxis))) {\n                    columnDescriptors = rowDescriptors;\n                    rowDescriptors = [];\n                    measuresRowAxis = false;\n                }\n\n                if (!columnDescriptors.length && !rowDescriptors.length) {\n                    measuresRowAxis = false;\n                }\n\n                if (!columnDescriptors.length && measures.length) {\n                    columnDescriptors = normalizeMembers(options.measures);\n                }\n\n                columnDescriptors = this._parseDescriptors(columnDescriptors);\n                rowDescriptors = this._parseDescriptors(rowDescriptors);\n\n                var aggregatedData = {};\n                var columns = {};\n                var rows = {};\n\n                var rowValue;\n                var state = { columnIndex: 0 };\n\n                var measureAggregators = this._measureAggregators(options);\n\n                var columnGetters = this._buildGetters(columnDescriptors.root);\n                var rowGetters = this._buildGetters(rowDescriptors.root);\n\n                var processed = false;\n\n                var expandedColumns = columnDescriptors.expanded;\n                var expandedRows = rowDescriptors.expanded;\n\n                var dataItem;\n                var aggregatorContext;\n                var hasExpandedRows = expandedRows.length !== 0;\n\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\n                if (columnDescriptors.root.length || rowDescriptors.root.length) {\n                    processed = true;\n\n                    for (idx = 0; idx < length; idx++) {\n                        dataItem = data[idx];\n\n                        aggregatorContext = {\n                            dataItem: dataItem,\n                            index: idx\n                        };\n\n                        rowTotal = aggregatedData[ROW_TOTAL_KEY] || {\n                            items: {},\n                            aggregates: {}\n                        };\n\n                        this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, rowTotal, state, !hasExpandedRows);\n\n                        rowTotal.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, rowTotal);\n                        aggregatedData[ROW_TOTAL_KEY] = rowTotal;\n\n                        for (rowIdx = 0; rowIdx < expandedRows.length; rowIdx++) {\n                            rowDescriptor = expandedRows[rowIdx];\n\n                            if (!this._matchDescriptors(dataItem, rowDescriptor, rowGetters)) {\n                                this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, { items: {}, aggregates: {} }, state, true);\n                                continue;\n                            }\n\n                            path = rowDescriptor.names.slice(0, rowDescriptor.expandedIdx).join(\"\");\n                            rowName = rowDescriptor.names[rowDescriptor.expandedIdx];\n\n                            parentName = rowName;\n\n                            rowValue = rowGetters[rowName](dataItem);\n                            rowValue = rowValue !== undefined$1 ? rowValue.toString() : rowValue;\n\n                            rowName = rowName + \"&\" + rowValue;\n                            key = path + rowName;\n\n                            rows[key] = {\n                                uniquePath: path + parentName,\n                                parentName: parentName,\n                                name: rowName,\n                                value: rowValue\n                            };\n\n                            value = aggregatedData[key] || {\n                                items: {},\n                                aggregates: {}\n                            };\n\n                            this._processColumns(measureAggregators, expandedColumns, columnGetters, columns, aggregatorContext, value, state, true);\n\n                            value.aggregates = this._calculateAggregate(measureAggregators, aggregatorContext, value);\n                            aggregatedData[key] = value;\n                        }\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\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\n                    columns = columnsInfo.tuples;\n                    rows = rowsInfo.tuples;\n\n                    aggregatedData = this._toDataArray(aggregatedData, this._measuresInfo(measureAggregators, measuresRowAxis), rowsInfo.keys, columnsInfo.keys);\n                } else {\n                    aggregatedData = columns = rows = [];\n                }\n\n                return {\n                    axes: {\n                        columns: { tuples: columns },\n                        rows: { tuples: rows }\n                    },\n                    data: aggregatedData\n                };\n            }\n        });\n\n        var PivotTransport = Class.extend({\n            init: function(options, transport) {\n                this.transport = transport;\n                this.options = transport.options || {};\n\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\n                if (val === undefined$1) {\n                    return (options.connection || {}).catalog;\n\n                }\n\n                var connection = options.connection || {};\n                connection.catalog = val;\n\n                this.options.connection = connection;\n                $.extend(this.transport.options, { connection: connection });\n            },\n            cube: function(val) {\n                var options = this.options || {};\n\n                if (val === undefined$1) {\n                    return (options.connection || {}).cube;\n                }\n\n                var connection = options.connection || {};\n                connection.cube = val;\n\n                this.options.connection = connection;\n                extend(true, this.transport.options, { connection: connection });\n            }\n        });\n\n        var PivotDataSourceV2 = DataSource.extend({\n            init: function(options) {\n\n                var cube = ((options || {}).schema || {}).cube;\n\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\n                if (cube) {\n                    this.cubeSchema = $.extend(schema, this._cubeSchema(cube));\n                }\n\n                DataSource.fn.init.call(this, extend(true, {}, {\n                    //schema: schema\n                }, options));\n\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\n                this._columns = normalizeMembers(this.options.columns);\n                this._rows = normalizeMembers(this.options.rows);\n\n                var measures = this.cubeSchema ? this.cubeSchema.measures() : this.options.measures || [];\n\n                if (toString.call(measures) === \"[object Object]\") {\n                    this._measuresAxis = measures.axis || \"columns\";\n                    measures = measures.values || [];\n                }\n\n                this._measures = normalizeMeasures(measures);\n            },\n\n            options: {\n                serverSorting: true,\n                serverPaging: true,\n                serverFiltering: true,\n                serverGrouping: true,\n                serverAggregates: true\n            },\n\n            axes: function() {\n                return {\n                    columns: normalizeAxis(this.columns()),\n                    rows: normalizeAxis(this.rows())\n                };\n            },\n\n            catalog: function(val) {\n                if (val === undefined$1) {\n                    return this.transport.catalog();\n                }\n\n                this.transport.catalog(val);\n                this._mergeState({});// clears current state\n                this.read();\n            },\n\n            cube: function(val) {\n                if (val === undefined$1) {\n                    return this.transport.cube();\n                }\n\n                this.transport.cube(val);\n                this._mergeState({});// clears current state\n                this.read();\n            },\n\n            measuresAxis: function() {\n                return this._measuresAxis || \"columns\";\n            },\n\n            fetch: function(callback) {\n                var that = this;\n                if (this._data === undefined$1 || this._data.length === 0) {\n                    var fn = function() {\n                        if (isFunction(callback)) {\n                            callback.call(that);\n                        }\n                    };\n\n                    return this._query().done(fn);\n                }\n            },\n\n            _createSettings: function(axes) {\n                var settings = [];\n                var key;\n                var dimensions = this.cubeSchema.dimensionsSettings();\n                var displayValueFunc = function(item) { return item[this.key]; };\n                var sortValueFunc = function(value) { return value; };\n                for (var i = 0; i < axes.length; i++) {\n                    key = axes[i].name[0];\n                    settings.push({\n                        key: key,\n                        displayValue: displayValueFunc.bind({ key: key }),\n                        sortValue: sortValueFunc,\n                        caption: (dimensions[key] || {}).caption || key\n                    });\n                }\n                return settings;\n            },\n\n            _cubeSchema: function(cube) {\n                return {\n                    dimensionsSettings: function() {\n                        return cube.dimensions;\n                    },\n                    dimensions: function() {\n                        var result = [];\n                        var dimensions = cube.dimensions;\n\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\n                        if (cube.measures) {\n                            result.push({\n                                name: MEASURES,\n                                caption: MEASURES,\n                                uniqueName: MEASURES,\n                                type: 2\n                            });\n                        }\n\n                        return result;\n                    },\n                    restoreMeasure: function(measures, measure) {\n                        for (var i = 0; i < measures.length; i++) {\n                            if (!measures[i].aggregate) {\n                                measures[i].aggregate = measure.aggregate;\n                                measures[i].value = measure.value;\n                                measures[i].caption = measure.caption;\n                                measures[i].uniqueName = measure.uniqueName;\n                                measures[i].type = 2;\n                            }\n                        }\n                    },\n                    measures: function() {\n                        var result = [];\n                        var measures = cube.measures;\n\n                        for (var key in measures) {\n                            result.push(createLocalMeasure(measures[key].field, key, measures[key].format));\n                        }\n\n                        return result;\n                    },\n                    memberType: function(name) {\n                        var getter = kendo.getter(normalizeName(name), true);\n                        var data = this.options.data || this._pristineData || [];\n                        if (!data.length) {\n                            return null;\n                        }\n\n                        return typeof getter(data[0]);\n                    }.bind(this),\n                    members: function(name) {\n                        var data = this.options.data || this._pristineData || [];\n                        var result = [];\n                        var distinct = {};\n                        var getter;\n                        var value;\n                        var idx = 0;\n\n                        if (name.indexOf(\"[(ALL)]\") !== -1) {\n                            return [\n                                {\n                                    caption: cube.dimensions[name.split(\".\")[0]].caption || name,\n                                    levelUniqueName: name,\n                                    name: name,\n                                    childrenCardinality: 1,\n                                    uniqueName: name\n                                }\n                            ];\n                        }\n\n                        getter = kendo.getter(normalizeName(name), true);\n\n                        for (; idx < data.length; idx++) {\n                            value = getter(data[idx]);\n                            if ((value || value === 0 || value === false) && !distinct[value]) {\n                                distinct[value] = true;\n\n                                result.push({\n                                    caption: value + \"\",\n                                    name: value + \"\",\n                                    childrenCardinality: 0,\n                                    uniqueName: value\n                                });\n                            }\n                        }\n\n                        return result;\n                    }.bind(this)\n                };\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                var deferred = $.Deferred();\n                if (!isPrevented) {\n                    that.trigger(PROGRESS);\n\n                    if (that.options.data) {\n\n                        var originalData = (this.reader.data(this.options.data) || []).slice(0);\n                        if (originalData && !this._pristineData) {\n                            this._pristineData = originalData;\n                        }\n                        var columnSettings = that._createSettings(params.columnAxes);\n                        var rowSettings = that._createSettings(params.rowAxes);\n                        var measures = that.measures();\n                        var dataTree = createDataTree(that.options.data, rowSettings, columnSettings, measures, { dataField: \"aggregate\", columnsData: \"columns\" }, that.filter() || []);\n\n                        var stateArgs = {\n                            dataTree: dataTree,\n                            columnSettings: columnSettings,\n                            rowSettings: rowSettings,\n                            columnAxes: params.columnAxes,\n                            rowAxes: params.rowAxes,\n                            measures: measures.map(function(item) { return item; }).reverse(),\n                            fields: { dataField: \"aggregate\", columnsData: \"columns\" },\n                            sort: flattenSortDescriptors(params.sort || [])\n                        };\n\n                        that._saveState(createLocalDataState(stateArgs));\n                        that.trigger(CHANGE);\n                        deferred.resolve();\n                    } else {\n                        that.transport.read({\n                            data: params,\n                            success: function(newDataState) {\n                                that._saveState(newDataState);\n                                that.trigger(REQUESTEND, { response: newDataState, type: READ });\n                                that.trigger(CHANGE);\n                                if (that._preventRefresh) {\n                                    that._preventRefresh = false;\n                                }\n                                deferred.resolve();\n                            },\n                            error: function(err) {\n                                that.trigger(ERROR, { error: err });\n                            }\n                        });\n                    }\n                }\n                return deferred.promise();\n            },\n\n            _params: function(data) {\n                var that = this;\n                var options = DataSource.fn._params.call(that, data);\n\n                options = extend({\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\n                if ((this.options.type || \"\").toLowerCase() === \"xmla\") {\n                    options.connection = that.options.transport.connection;\n                }\n\n                if (options.filter) {\n                    options.filter = normalizeFilter(options.filter);\n                    options.filter = (options.filter || {}).filters;\n                }\n\n                if (options.sort) {\n                    options.sort = normalizeSort(options.sort);\n                }\n\n                return options;\n            },\n\n            discover: function(options) {\n                var that = this,\n                    transport = that.transport;\n\n                if (transport.discover) {\n                    return transport.discover(options);\n                }\n            },\n\n            schemaMeasures: function() {\n                var that = this;\n                return that.discover(\n                    {\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\n            schemaKPIs: function() {\n                var that = this;\n\n                return that.discover(\n                {\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\n            schemaDimensions: function() {\n                var that = this;\n\n                return that.discover(\n                {\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\n            schemaHierarchies: function(dimensionName) {\n                var that = this;\n\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\n            schemaLevels: function(hierarchyName) {\n                var that = this;\n\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\n            schemaCubes: function() {\n                var that = this;\n\n                return that.discover({\n                    command: \"schemaCubes\",\n                    restrictions: {\n                        catalogName: that.transport.catalog()\n                    }\n                }, function(response) {\n                    return response;\n                });\n            },\n\n            schemaCatalogs: function() {\n                var that = this;\n\n                return that.discover({\n                    command: \"schemaCatalogs\"\n                }, function(response) {\n                    return response;\n                });\n            },\n\n            schemaMembers: function(restrictions) {\n                var that = this;\n\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\n            _saveState: function(state) {\n                var that = this;\n\n                that._columnTuples = state.columns;\n                that._rowTuples = state.rows;\n                that._view = that._data = state.data;\n            },\n\n            columns: function(val) {\n                if (val === undefined$1) {\n                    return this._columns;\n                }\n\n                this._columns = normalizeMembers(val);\n                this.read();\n            },\n\n            rows: function(val) {\n                if (val === undefined$1) {\n                    return this._rows;\n                }\n\n                this._rows = normalizeMembers(val);\n\n                this.read();\n            },\n\n            measures: function(val) {\n                if (val === undefined$1) {\n                    return this._measures;\n                }\n\n                this._measures = normalizeMeasures(val);\n\n                this.read();\n            },\n\n            _mergeState: function(options) {\n                options = DataSource.fn._mergeState.call(this, options);\n\n                return options;\n            },\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                this._mergeState(params);\n\n                return this.read();\n            },\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\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\n                if (cube) {\n                    schema = $.extend(schema, this._cubeSchema(cube));\n                    this.cubeBuilder = new PivotCubeBuilder(cube);\n                }\n\n                DataSource.fn.init.call(this, extend(true, {}, {\n                    schema: schema\n                }, options));\n\n                this.transport = new PivotTransport(this.options.transport || {}, this.transport);\n\n                this._columns = normalizeMembers(this.options.columns);\n                this._rows = normalizeMembers(this.options.rows);\n\n                measures = this.options.measures || [];\n\n                if (toString.call(measures) === \"[object Object]\") {\n                    measuresAxis = measures.axis || \"columns\";\n                    measures = measures.values || [];\n                }\n\n                this._measures = normalizeMeasures(measures);\n                this._measuresAxis = measuresAxis;\n\n                this._skipNormalize = 0;\n                this._axes = {};\n            },\n\n            _cubeSchema: function(cube) {\n                return {\n                    dimensions: function() {\n                        var result = [];\n                        var dimensions = cube.dimensions;\n\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\n                        if (cube.measures) {\n                            result.push({\n                                name: MEASURES,\n                                caption: MEASURES,\n                                uniqueName: MEASURES,\n                                type: 2\n                            });\n                        }\n\n                        return result;\n                    },\n                    hierarchies: function() {\n                        return [];\n                    },\n                    measures: function() {\n                        var result = [];\n                        var measures = cube.measures;\n\n                        for (var key in measures) {\n                            result.push({\n                                name: key,\n                                caption: key,\n                                uniqueName: key,\n                                aggregator: key\n                            });\n                        }\n\n                        return result;\n                    },\n                    members: 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\n                        if (name) {\n                            name = name.split(\".\")[0];\n                        }\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\n                            return result;\n                        }\n\n                        getter = kendo.getter(normalizeName(name), true);\n\n                        for (; idx < data.length; idx++) {\n                            value = getter(data[idx]);\n                            if ((value || value === 0) && !distinct[value]) {\n                                distinct[value] = true;\n\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\n                        return result;\n                    }.bind(this)\n                };\n            },\n\n            options: {\n                serverSorting: true,\n                serverPaging: true,\n                serverFiltering: true,\n                serverGrouping: true,\n                serverAggregates: true\n            },\n\n            catalog: function(val) {\n                if (val === undefined$1) {\n                    return this.transport.catalog();\n                }\n\n                this.transport.catalog(val);\n                this._mergeState({});// clears current state\n                this._axes = {};\n                this.data([]);\n            },\n\n            cube: function(val) {\n                if (val === undefined$1) {\n                    return this.transport.cube();\n                }\n\n                this.transport.cube(val);\n                this._axes = {};\n                this._mergeState({});// clears current state\n                this.data([]);\n            },\n\n            axes: function() {\n                return this._axes;\n            },\n\n            columns: function(val) {\n                if (val === undefined$1) {\n                    return this._columns;\n                }\n\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n\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\n            rows: function(val) {\n                if (val === undefined$1) {\n                    return this._rows;\n                }\n\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n\n                this._rows = normalizeMembers(val);\n\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\n            measures: function(val) {\n                if (val === undefined$1) {\n                    return this._measures;\n                }\n\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n\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\n            measuresAxis: function() {\n                return this._measuresAxis || \"columns\";\n            },\n\n            _expandPath: function(path, axis) {\n                var origin = axis === \"columns\" ? \"columns\" : \"rows\";\n                var other = axis === \"columns\" ? \"rows\" : \"columns\";\n\n                var members = normalizeMembers(path);\n                var memberToExpand = getName(members[members.length - 1]);\n\n                this._lastExpanded = origin;\n\n                members = descriptorsForMembers(this.axes()[origin], members, this.measures());\n\n                for (var idx = 0; idx < members.length; idx++) {\n                    var memberName = getName(members[idx]);\n\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\n                var descriptors = {};\n                descriptors[origin] = members;\n                descriptors[other] = this._descriptorsForAxis(other);\n\n                this._query(descriptors);\n            },\n\n            _descriptorsForAxis: function(axis) {\n                var axes = this.axes();\n                var descriptors = this[axis]() || [];\n\n                if (axes && axes[axis] && axes[axis].tuples && axes[axis].tuples[0]) {\n                    descriptors = descriptorsForAxes(axes[axis].tuples || []);\n                }\n                return descriptors;\n            },\n\n            columnsAxisDescriptors: function() {\n                return this._descriptorsForAxis(\"columns\");\n            },\n\n            rowsAxisDescriptors: function() {\n                return this._descriptorsForAxis(\"rows\");\n            },\n\n            _process: function(data, e) {\n                this._view = data;\n\n                e = e || {};\n                e.items = e.items || this._view;\n\n                this.trigger(CHANGE, e);\n            },\n\n            _query: function(options) {\n                var that = this;\n\n                if (!options) {\n                    this._skipNormalize += 1;\n                    this._clearAxesData = true;\n                }\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\n            query: function(options) {\n                var state = this._mergeState(options);\n\n                if (this._data.length && this.cubeBuilder) {\n                    this._params(state);\n                    this._updateLocalData(this._pristineData);\n\n                    return $.Deferred().resolve().promise();\n                }\n\n                return this.read(state);\n            },\n\n            _mergeState: function(options) {\n                options = DataSource.fn._mergeState.call(this, options);\n\n                if (options !== undefined$1) {\n                    this._measures = normalizeMeasures(options.measures);\n\n                    if (options.columns) {\n                        options.columns = normalizeMembers(options.columns);\n                    } else if (!options.columns) {\n                        this._columns = [];\n                    }\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\n            filter: function(val) {\n                if (val === undefined$1) {\n                    return this._filter;\n                }\n\n                this._skipNormalize += 1;\n                this._clearAxesData = true;\n                this._query({ filter: val, page: 1 });\n            },\n\n            expandColumn: function(path) {\n                this._expandPath(path, \"columns\");\n            },\n\n            expandRow: function(path) {\n                this._expandPath(path, \"rows\");\n            },\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\n            _processResult: function(data, axes) {\n                if (this.cubeBuilder) {\n                    var processedData = this.cubeBuilder.process(data, this._requestData);\n\n                    data = processedData.data;\n                    axes = processedData.axes;\n                }\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\n                if (!columnDescriptors.length && rowDescriptors.length && hasColumnTuples && (this._rowMeasures().length || !this.measures().length)) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n\n                if (!columnDescriptors.length && !rowDescriptors.length && this.measuresAxis() === \"rows\" && hasColumnTuples) {\n                    axes = {\n                        columns: {},\n                        rows: axes.columns\n                    };\n                }\n\n                this._axes = {\n                    columns: normalizeAxis(this._axes.columns),\n                    rows: normalizeAxis(this._axes.rows)\n                };\n\n                axes = {\n                    columns: normalizeAxis(axes.columns),\n                    rows: normalizeAxis(axes.rows)\n                };\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\n                if (this._skipNormalize > 0) {\n                    this._skipNormalize -= 1;\n                }\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\n                if (this._lastExpanded == \"rows\") {\n                    tuples = axes.columns.tuples;\n                    measures = this._columnMeasures();\n                    resultAxis = validateAxis(axes.columns, this._axes.columns, measures);\n\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\n                    if (resultAxis) {\n                        axisToSkip = \"rows\";\n                        axes.rows = resultAxis;\n                        adjustDataByRow(tuples, resultAxis.tuples, axes.columns.tuples.length, measures, data);\n\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\n                this._lastExpanded = null;\n\n                var result = this._mergeAxes(axes, data, axisToSkip);\n                this._axes = result.axes;\n\n                return result.data;\n            },\n\n            _readData: function(data) {\n                var axes = this.reader.axes(data);\n                var newData = this.reader.data(data);\n\n                if (this.cubeBuilder) {\n                    this._rawData = newData;\n                }\n\n                return this._processResult(newData, axes);\n            },\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\n                if (measure) {\n                    length -= 1;\n                }\n\n                for (; idx < length; idx++) {\n                    member = members[idx];\n                    levelNum = Number(member.levelNum);\n\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\n                    if (buildRoot) {\n                        caption = \"All\";\n                        if (levelNum === 0) {\n                            parentName = member.name;\n                        } else {\n                            levelNum -= 1;\n                        }\n\n                        hasChildren = true;\n                        name = hierarchy = levelName = parentName;\n                    }\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\n                if (measure) {\n                    root.members.push({\n                        name: measure.name,\n                        children: []\n                    });\n                }\n\n                return root;\n            },\n\n            _hasRoot: function(target, source, descriptors) {\n                if (source.length) {\n                    return findExistingTuple(source, target).tuple;\n                }\n\n                var members = target.members;\n                var member;\n                var descriptor;\n\n                var isRoot = true;\n                var levelNum;\n\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\n                    if (!(levelNum === 0 || (descriptor && member.name === getName(descriptor)))) {\n                        isRoot = false;\n                        break;\n                    }\n                }\n\n                return isRoot;\n            },\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\n                var oldRowsLength = membersCount(axes.rows.tuples, rowMeasures);\n                var newRowsLength = sourceAxes.rows.tuples.length;\n\n                var oldColumnsLength = membersCount(axes.columns.tuples, columnMeasures);\n                var newColumnsLength = sourceAxes.columns.tuples.length;\n\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\n                var mergedColumns = mergeTuples(axes.columns.tuples, tuples, columnMeasures);\n\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\n                axes.columns.tuples = mergedColumns.tuples;\n                axes.rows.tuples = mergedRows.tuples;\n\n                if (oldColumnsLength !== membersCount(axes.columns.tuples, columnMeasures)) {\n                    //columns are expanded\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                    //rows are expanded\n                    startIndex = mergedRows.index + findDataIndex(mergedRows.parsedRoot, mergedRows.memberIndex, rowMeasures);\n                    data = this._mergeRowData(data, startIndex, newRowsLength, newColumnsLength);\n                }\n\n                if (axes.columns.tuples.length === 0 && axes.rows.tuples.length === 0) {\n                    data = [];\n                }\n\n                return {\n                    axes: axes,\n                    data: data\n                };\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\n                rowsLength = Math.max(rowsLength, 1);\n\n                if (data.length > 0) {\n                    //if there is already data, drop the first new data item\n                    drop = columnMeasures;\n                    offset -= columnMeasures;\n                }\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, [index, 0].concat(toAdd));\n                }\n\n                return data;\n            },\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\n                columnsLength = Math.max(columnsLength, 1);\n                if (data.length > 0) {\n                    //if there is already data, drop the first new data item\n                    rowsLength -= rowMeasures;\n                    newData.splice(0, columnsLength * rowMeasures);\n                }\n\n                for (idx = 0; idx < rowsLength; idx++) {\n                    toAdd = newData.splice(0, columnsLength);\n                    dataIndex = (rowIndex * columnsLength) + (idx * columnsLength);\n                    [].splice.apply(data, [dataIndex, 0].concat(toAdd));\n                }\n\n                return data;\n            },\n\n            _columnMeasures: function() {\n                var measures = this.measures();\n                var columnMeasures = [];\n\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\n                return columnMeasures;\n            },\n\n            _rowMeasures: function() {\n                var measures = this.measures();\n                var rowMeasures = [];\n\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\n                return rowMeasures;\n            },\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\n                this._data = this._observe(data);\n\n                this._ranges = [];\n                this._addRange(this._data);\n\n                this._total = this._data.length;\n                this._pristineTotal = this._total;\n                this._process(this._data);\n            },\n\n            data: function(value) {\n                var that = this;\n                if (value !== undefined$1) {\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\n            _normalizeTuples: function(tuples, source, descriptors, measures) {\n                var length = measures.length || 1;\n                var idx = 0;\n\n                var roots = [];\n                var indexes = {};\n                var measureIdx = 0;\n                var tuple, memberIdx, last;\n\n                if (!tuples.length) {\n                    return;\n                }\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\n                    tuples.splice.apply(tuples, [0, tuples.length].concat(roots).concat(tuples));\n                    idx = length;\n                }\n\n                if (measures.length) {\n                    last = tuple = tuples[idx];\n                    memberIdx = tuple.members.length - 1;\n\n                    while (tuple) {\n                        if (measureIdx >= length) {\n                            measureIdx = 0;\n                        }\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\n                        idx += 1;\n                        measureIdx += 1;\n                        tuple = tuples[idx];\n\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\n                return indexes;\n            },\n\n            _addMissingDataItems: function(result, metadata) {\n                while (metadata.rowIndexes[parseInt(result.length / metadata.columnsLength, 10)] !== undefined$1) {\n                    for (var idx = 0; idx < metadata.columnsLength; idx++) {\n                        result = addEmptyDataItem(result);\n                    }\n                }\n\n                while (metadata.columnIndexes[result.length % metadata.columnsLength] !== undefined$1) {\n                    result = addEmptyDataItem(result);\n                }\n\n                return result;\n            },\n\n            _normalizeOrdinals: function(result, dataItem, metadata) {\n                var lastOrdinal = metadata.lastOrdinal;\n\n                if (!dataItem) {\n                    return addEmptyDataItem(result);\n                }\n\n                if ((dataItem.ordinal - lastOrdinal) > 1) {\n                    lastOrdinal += 1;\n\n                    while (lastOrdinal < dataItem.ordinal && result.length < metadata.length) {\n                        result = this._addMissingDataItems(addEmptyDataItem(result), metadata);\n                        lastOrdinal += 1;\n                    }\n                }\n\n                dataItem.ordinal = result.length;\n                result[result.length] = dataItem;\n\n                return result;\n            },\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\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\n                if (data.length === length) {\n                    return data;\n                }\n\n                while (result.length < length) {\n                    dataItem = data[dataIdx++];\n                    if (dataItem) {\n                        lastOrdinal = dataItem.ordinal;\n                    }\n\n                    result = this._normalizeOrdinals(this._addMissingDataItems(result, options), dataItem, options);\n\n                    options.lastOrdinal = lastOrdinal;\n                }\n\n                return result;\n            },\n\n            discover: function(options, converter) {\n                var that = this,\n                    transport = that.transport;\n\n                return $.Deferred(function(deferred) {\n                    transport.discover(extend({\n                        success: function(response) {\n                           response = that.reader.parse(response);\n\n                            if (that._handleCustomErrors(response)) {\n                                return;\n                            }\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\n            schemaMeasures: function() {\n                var that = this;\n\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\n            schemaKPIs: function() {\n                var that = this;\n\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\n            schemaDimensions: function() {\n                var that = this;\n\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\n            schemaHierarchies: function(dimensionName) {\n                var that = this;\n\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\n            schemaLevels: function(hierarchyName) {\n                var that = this;\n\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\n            schemaCubes: function() {\n                var that = this;\n\n                return that.discover({\n                    data: {\n                        command: \"schemaCubes\",\n                        restrictions: {\n                            catalogName: that.transport.catalog()\n                        }\n                    }\n                }, function(response) {\n                    return that.reader.cubes(response);\n                });\n            },\n\n            schemaCatalogs: function() {\n                var that = this;\n\n                return that.discover({\n                    data: {\n                        command: \"schemaCatalogs\"\n                    }\n                }, function(response) {\n                    return that.reader.catalogs(response);\n                });\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\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\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\n                var options = DataSource.fn._params.call(this, data);\n\n                options = extend({\n                    measures: this.measures(),\n                    measuresAxis: this.measuresAxis(),\n                    columns: this.columns(),\n                    rows: this.rows()\n                }, options);\n\n                if (this.cubeBuilder) {\n                    this._requestData = options;\n                }\n\n                return options;\n            }\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\n            return result;\n        }\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\n        function fillSortTree(items, map) {\n            for (var i = 0; i < items.length; i++) {\n                var currentItem = map[items[i].name];\n\n                if (!$.isEmptyObject(currentItem.childrenMap)) {\n                    items[i].children = [];\n                    for (var name in currentItem.childrenMap) {\n                        items[i].children.push($.extend({}, { name: name, parentName: map[name].parentName }));\n                    }\n\n                    fillSortTree(items[i].children, map);\n                }\n            }\n        }\n\n        function addEmptyDataItem(result) {\n            result[result.length] = { value: \"\", fmtValue: \"\", ordinal: result.length };\n            return result;\n        }\n\n        function validateAxis(newAxis, axis, measures) {\n            if (newAxis.tuples.length < membersCount(axis.tuples, measures)) {\n\n                return axis;\n            }\n\n            return;\n        }\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\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\n                    data[rowIdx * columnsLength + columnIdx].ordinal = rowIdx * targetColumnsLength + dataIdx;\n                }\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\n            for (rowIdx = 0; rowIdx < rowsLength; rowIdx++) {\n                dataIdx = tupleIndex(sourceTuples[rowIdx], targetTuples);\n                dataIdx *= measuresLength;\n                dataIdx += rowIdx % measuresLength;\n\n                for (columnIdx = 0; columnIdx < columnsLength; columnIdx++) {\n                    data[rowIdx * columnsLength + columnIdx].ordinal = dataIdx * columnsLength + columnIdx;\n                }\n            }\n        }\n\n        function tupleIndex(tuple, collection) {\n            return findExistingTuple(collection, tuple).index;\n        }\n\n        function membersCount(tuples, measures) {\n            if (!tuples.length) {\n                return 0;\n            }\n\n            var queue = tuples.slice();\n            var current = queue.shift();\n            var result = 1;\n\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\n                current = queue.shift();\n            }\n\n            if (measures.length) {\n                result = result * measures.length;\n            }\n\n            return result;\n        }\n\n        function normalizeAxis(axis) {\n            if (!axis) {\n                axis = {\n                    tuples: []\n                };\n            }\n\n            if (!axis.tuples) {\n                axis.tuples = [];\n            }\n\n            return axis;\n        }\n\n        function findDataIndex(tuple, memberIndex, measures) {\n            if (!tuple) {\n                return 0;\n            }\n\n            var measuresLength = Math.max(measures.length, 1);\n            var tuples = tuple.members.slice(0, memberIndex);\n            var current = tuples.shift();\n\n            //the initial value is equal to the total number of measures\n            //as the measures member is not extracted from the members of the starting tuple\n            //but should be calculated in the final result\n            var counter = measuresLength;\n\n            while (current) {\n                if (current.name === MEASURES) {\n                    //subtract 1 as the measures member has been already counted as a single standard member\n                    //but we are interested in the total number of measures instead\n                    counter += (measuresLength - 1);\n                } else if (current.children) {\n                    //is member\n                    [].push.apply(tuples, current.children);\n                } else {\n                    //is tuple\n                    counter ++;\n                    [].push.apply(tuples, current.members);\n                }\n\n                current = tuples.shift();\n            }\n\n            return counter;\n        }\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\n            var result = findExistingTuple(target, source[0]);\n\n            if (!result.tuple) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\n            }\n\n            var targetMembers = result.tuple.members;\n            var sourceMembers = source[0].members;\n            var memberIndex = -1;\n\n            if (targetMembers.length !== sourceMembers.length) {\n                return {\n                    parsedRoot: null,\n                    tuples: source,\n                    memberIndex: 0,\n                    index: 0\n                };\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\n                    targetMembers[idx].children = sourceMembers[idx].children;\n                }\n            }\n\n            measures = Math.max(measures.length, 1);\n\n            return {\n                parsedRoot: result.tuple,\n                index: result.index * measures,\n                memberIndex: memberIndex,\n                tuples: target\n            };\n        }\n\n        function equalTuples(first, second) {\n            var equal = true;\n            var idx, length;\n\n            first = first.members;\n            second = second.members;\n\n            for (idx = 0, length = first.length; idx < length; idx++) {\n                if (first[idx].measure || second[idx].measure) {\n                    continue;\n                }\n\n                equal = equal && (getName(first[idx]) === getName(second[idx]));\n            }\n\n            return equal;\n        }\n\n        function findExistingTuple(tuples, toFind) {\n            var idx, length, tuple, found, counter = 0;\n            var memberIndex, membersLength, member;\n\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\n                counter ++;\n\n                for (memberIndex = 0, membersLength = tuple.members.length; memberIndex < membersLength; memberIndex++) {\n                    member = tuple.members[memberIndex];\n                    if (member.measure) {\n                        //counter += member.children.length;\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\n            return {\n                index: counter\n            };\n        }\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\n\n        function findParentMember(tuple, map) {\n            var members = tuple.members;\n            var i, len, member, path = \"\";\n            var parentPath = \"\";\n            var parentMember;\n\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\n                path += member.name;\n                parentMember = map[member.parentName];\n\n                if (!parentMember) {\n                    parentMember = map[path];\n                    if (!parentMember) {\n                        return null;\n                    }\n                }\n\n                if (parentMember) {\n                    parentPath += parentMember.name;\n                }\n            }\n\n            return parentMember;\n        }\n\n        function measurePosition(tuple, measures) {\n            if (measures.length === 0) {\n                return -1;\n            }\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\n        function normalizeTupleMeasures(tuple, index) {\n            if (index < 0) {\n                return;\n            }\n            var member = {\n                name: MEASURES,\n                measure: true,\n                children: [\n                    $.extend({ members: [], dataIndex: tuple.dataIndex }, tuple.members[index])\n                ]\n            };\n            tuple.members.splice(index, 1, member);\n            tuple.dataIndex = undefined$1;\n        }\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\n            for (var i = 0; i < tuples.length; i++) {\n                var tuple = tuples[i];\n\n                //keep the old data index of the tuple\n                tuple.dataIndex = i;\n\n                normalizeTupleMeasures(tuple, measureIndex);\n                var parentMember = findParentMember(tuple, map);\n\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\n                addMembers(tuple.members, map);\n            }\n\n            return result;\n        }\n\n        function prepareDataOnRows(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\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\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] || { value: \"\", fmtValue: \"\", ordinal: calcIndex };\n                }\n            }\n\n            return result;\n        }\n\n        function prepareDataOnColumns(tuples, data) {\n            if (!tuples || !tuples.length) {\n                return data;\n            }\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\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] || { value: \"\", fmtValue: \"\", ordinal: calcIndex };\n                }\n            }\n\n            return result;\n        }\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\n            while (tuple) {\n                //required for multiple measures\n                if (tuple.dataIndex !== undefined$1) {\n                    result.push(tuple.dataIndex);\n                }\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, [0, 0].concat(children));\n                    } else {\n                        [].splice.apply(tuples, [spliceIndex, 0].concat(children));\n                    }\n                    spliceIndex += children.length;\n                }\n\n                tuple = tuples.shift();\n            }\n\n            return result;\n        }\n\n        PivotDataSourceV2.create = function(options) {\n            options = options && options.push ? { data: options } : options;\n\n            var dataSource = options || {},\n                data = dataSource.data;\n\n            dataSource.data = data;\n\n            if (!(dataSource instanceof PivotDataSourceV2) && dataSource instanceof kendo.data.DataSource) {\n                throw new Error(\"Incorrect DataSource type. Only PivotDataSource instances are supported\");\n            }\n\n            return dataSource instanceof PivotDataSourceV2 ? dataSource : new PivotDataSourceV2(dataSource);\n        };\n\n        PivotDataSource.create = function(options) {\n            options = options && options.push ? { data: options } : options;\n\n            var dataSource = options || {},\n                data = dataSource.data;\n\n            dataSource.data = data;\n\n            if (!(dataSource instanceof PivotDataSource) && dataSource instanceof kendo.data.DataSource) {\n                throw new Error(\"Incorrect DataSource type. Only PivotDataSource instances are supported\");\n            }\n\n            return dataSource instanceof PivotDataSource ? dataSource : new PivotDataSource(dataSource);\n        };\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\n        function expandMemberDescriptor(names, sort) {\n            var idx = names.length - 1;\n            var name = names[idx];\n            var sortDescriptor;\n\n            sortDescriptor = sortDescriptorForMember(sort, name);\n\n            if (sortDescriptor && sortDescriptor.dir) {\n                name = \"ORDER(\" + name + \".Children,\" + sortDescriptor.field + \".CurrentMember.MEMBER_CAPTION,\" + sortDescriptor.dir + \")\";\n            } else {\n                name += \".Children\";\n            }\n\n            names[idx] = name;\n\n            return names;\n        }\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\n        function crossJoin(names) {\n            var result = \"CROSSJOIN({\";\n            var r;\n\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\n            result += \"},{\";\n            result += r;\n            result += \"})\";\n            return result;\n        }\n\n        function crossJoinCommand(members, measures) {\n            var tmp = members.slice(0);\n\n            if (measures.length > 1) {\n                tmp.push(\"{\" + measureNames(measures).join(\",\") + \"}\");\n            }\n\n            return crossJoin(tmp);\n        }\n\n        function measureNames(measures) {\n            var idx = 0;\n            var length = measures.length;\n            var result = [];\n            var measure;\n\n            for (; idx < length; idx++) {\n                measure = measures[idx];\n                result.push(measure.name !== undefined$1 ? measure.name : measure);\n            }\n\n            return result;\n        }\n\n        function indexOf(name, items) {\n            var idx, length, index = -1;\n\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\n        function getName(name) {\n            name = name.name || name;\n\n            if (toString.call(name) === \"[object Array]\") {\n                name = name[name.length - 1];\n            }\n\n            return name;\n        }\n\n        function getRootNames(members) {\n            var length = members.length;\n            var names = [];\n            var idx = 0;\n\n            for (; idx < length; idx++) {\n                names.push(members[idx].name[0]);\n            }\n\n            return names;\n        }\n\n        function mapNames(names, rootNames) {\n            var name;\n            var rootName;\n\n            var j;\n            var idx = 0;\n            var length = names.length;\n            var rootLength = rootNames.length;\n\n            rootNames = rootNames.slice(0);\n\n            for (; idx < length; idx++) {\n                name = names[idx];\n\n                for (j = 0; j < rootLength; j++) {\n                    rootName = baseHierarchyPath(rootNames[j]);\n\n                    if (name.indexOf(rootName) !== -1) {\n                        rootNames[j] = name;\n                        break;\n                    }\n                }\n            }\n\n            return {\n                names: rootNames,\n                expandedIdx: j,\n                uniquePath: rootNames.slice(0, j + 1).join(\"\")\n            };\n        }\n\n        function parseDescriptors(members) {\n            var expanded = [];\n            var child = [];\n            var root = [];\n            var member;\n\n            var j, l;\n            var idx = 0;\n            var length = members.length;\n\n            var name;\n            var hierarchyName;\n\n            var found;\n\n            for (; idx < length; idx++) {\n                member = members[idx];\n                name = member.name;\n                found = false;\n\n                if (toString.call(name) !== \"[object Array]\") {\n                    member.name = name = [name];\n                }\n\n                if (name.length > 1) {\n                    child.push(member);\n                } else {\n                    hierarchyName = baseHierarchyPath(name[0]);\n\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\n                    if (!found) {\n                        root.push(member);\n                    }\n\n                    if (member.expand) {\n                        expanded.push(member);\n                    }\n                }\n            }\n\n            expanded = expanded.concat(child);\n\n            return {\n                root: root,\n                expanded: expanded\n            };\n        }\n\n        function serializeMembers(members, measures, sort) {\n            var command = \"\";\n\n            members = members || [];\n\n            var expanded = parseDescriptors(members);\n            var root = expanded.root;\n\n            var rootNames = getRootNames(root);\n            var crossJoinCommands = [];\n\n            expanded = expanded.expanded;\n\n            var length = expanded.length;\n            var idx = 0;\n\n            var memberName;\n            var names = [];\n\n            if (rootNames.length > 1 || measures.length > 1) {\n                crossJoinCommands.push(crossJoinCommand(rootNames, measures));\n\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names = mapNames(memberName, rootNames).names;\n\n                    crossJoinCommands.push(crossJoinCommand(names, measures));\n                }\n\n                command += crossJoinCommands.join(\",\");\n            } else {\n                for (; idx < length; idx++) {\n                    memberName = expandMemberDescriptor(expanded[idx].name, sort);\n                    names.push(memberName[0]); //check if this is ok\n                }\n\n                command += rootNames.concat(names).join(\",\");\n            }\n\n            return command;\n        }\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\n        function serializeExpression(expression) {\n            var command = \"\";\n            var value = expression.value;\n            var field = expression.field;\n            var operator = expression.operator;\n\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\n            return command;\n        }\n\n        function serializeFilters(filter, cube) {\n            var command = \"\", current;\n            var filters = filter.filters;\n            var length = filters.length;\n            var idx;\n\n            for (idx = length - 1; idx >= 0; idx--) {\n\n                current = \"SELECT (\";\n                current += serializeExpression(filters[idx]);\n                current += \") ON 0\";\n\n                if (idx == length - 1) {\n                    current += \" FROM [\" + cube + \"]\";\n                    command = current;\n                } else {\n                    command = current + \" FROM ( \" + command + \" )\";\n                }\n            }\n\n            return command;\n        }\n\n        function serializeOptions(parentTagName, options, capitalize) {\n            var result = \"\";\n\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\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\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\n                command += \"SELECT NON EMPTY {\";\n\n                var columns = options.columns || [];\n                var rows = options.rows || [];\n\n                var measures = options.measures || [];\n                var measuresRowAxis = options.measuresAxis === \"rows\";\n                var sort = options.sort || [];\n\n                if (!columns.length && rows.length && (!measures.length || (measures.length && measuresRowAxis))) {\n                    columns = rows;\n                    rows = [];\n                    measuresRowAxis = false;\n                }\n\n                if (!columns.length && !rows.length) {\n                    measuresRowAxis = false;\n                }\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\n                command += \"} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON COLUMNS\";\n\n                if (rows.length || (measuresRowAxis && measures.length > 1)) {\n                    command += \", NON EMPTY {\";\n\n                    if (rows.length) {\n                        command += serializeMembers(rows, measuresRowAxis ? measures : [], sort);\n                    } else {\n                        command += measureNames(measures).join(\",\");\n                    }\n\n                    command += \"} DIMENSION PROPERTIES CHILDREN_CARDINALITY, PARENT_UNIQUE_NAME ON ROWS\";\n                }\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\n                if (measures.length == 1 && columns.length) {\n                    command += \" WHERE (\" + measureNames(measures).join(\",\") + \")\";\n                }\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\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\n                command += \"<Restrictions>\" + serializeOptions(\"RestrictionList\", options.restrictions, true) + \"</Restrictions>\";\n\n                if (options.connection && options.connection.catalog) {\n                    options.properties = $.extend({}, {\n                        Catalog: options.connection.catalog\n                    }, options.properties);\n                }\n\n                command += \"<Properties>\" + serializeOptions(\"PropertyList\", options.properties) + \"</Properties>\";\n\n                command += '</Discover></Body></Envelope>';\n                return command;\n            }\n        };\n\n        var XmlaTransport = kendo.data.RemoteTransport.extend({\n            init: function(options) {\n                var originalOptions = options;\n\n                options = this.options = extend(true, {}, this.options, options);\n\n                kendo.data.RemoteTransport.call(this, options);\n\n                if (isFunction(originalOptions.discover)) {\n                    this.discover = originalOptions.discover;\n                } else if (typeof originalOptions.discover === \"string\") {\n                    this.options.discover = {\n                        url: originalOptions.discover\n                    };\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\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\n            discover: function(options) {\n                return $.ajax(this.setup(options, \"discover\"));\n            }\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,\n                    success,\n                    error;\n\n                var fetchOptions = that.setup(options.data, READ);\n\n                success = options.success || $.noop;\n                error = options.error || $.noop;\n\n                if (options.parameterMap) {\n                    fetchOptions = that.parameterMap(fetchOptions, READ);\n                }\n\n                fetchData({ url: that.options.read }, fetchOptions)\n                .then(createDataState)\n                .then(function(newDataState) {\n                    success(newDataState);\n                })\n                .catch(function(err) { error(err); });\n            },\n\n            catalog: function(val) {\n                var options = this.options || {};\n\n                if (val === undefined$1) {\n                    return (options.connection || {}).catalog;\n\n                }\n\n                var connection = options.connection || {};\n                connection.catalog = val;\n\n                this.options.connection = connection;\n                $.extend(this.transport.options, { connection: connection });\n            },\n            cube: function(val) {\n                var options = this.options || {};\n\n                if (val === undefined$1) {\n                    return (options.connection || {}).cube;\n                }\n\n                var connection = options.connection || {};\n                connection.cube = val;\n\n                this.options.connection = connection;\n                extend(true, this.transport.options, { connection: connection });\n            },\n\n            discover: function(options) {\n                return fetchDiscover({ url: this.options.read }, options);\n            }\n        });\n\n        function asArray(object) {\n            if (object == null) {\n                return [];\n            }\n\n            var type = toString.call(object);\n            if (type !== \"[object Array]\") {\n                return [object];\n            }\n\n            return object;\n        }\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\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\n                result.tuples.push({ members: members });\n            }\n            return result;\n        }\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    //unknown = 0; time = 1; measure = 2; other = 3; quantitative = 5; accounts = 6; customers = 7; products = 8; scenario = 9; utility = 10; currency = 11; rates = 12; channel = 13; promotion = 14; organization = 15; billOfMaterials = 16; geography = 17;\n\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\n        var xmlaReaderMethods = [\"axes\", \"catalogs\", \"cubes\", \"dimensions\", \"hierarchies\", \"levels\", \"measures\"];\n\n        var XmlaDataReader = kendo.data.XmlDataReader.extend({\n            init: function(options) {\n                kendo.data.XmlDataReader.call(this, options);\n\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\n                for (; idx < length; idx++) {\n                    methodName = xmlaReaderMethods[idx];\n                    option = options[methodName];\n\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\n                var axes = asArray(kendo.getter(\"Axes.Axis\", true)(root));\n                var axis;\n\n                var result = {\n                    columns: {},\n                    rows: {}\n                };\n\n                for (var idx = 0; idx < axes.length; idx++) {\n                    axis = axes[idx];\n\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\n                return result;\n            },\n            data: function(root) {\n                root = kendo.getter(\"ExecuteResponse[\\\"return\\\"].root\", true)(root);\n\n                var cells = asArray(kendo.getter(\"CellData.Cell\", true)(root));\n\n                var result = [];\n                var ordinalGetter = kendo.getter(\"['@CellOrdinal']\");\n                var valueGetter = kendo.getter(\"Value['#text']\");\n                var fmtValueGetter = kendo.getter(\"FmtValue['#text']\");\n\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\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\n                var result = [];\n\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\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\n        extend(true, kendo.data, {\n           PivotDataSource: PivotDataSource,\n           PivotDataSourceV2: PivotDataSourceV2,\n           XmlaTransport: XmlaTransport,\n           XmlaDataReader: XmlaDataReader,\n           PivotCubeBuilder: PivotCubeBuilder,\n           transports: {\n               xmla: XmlaTransport\n           },\n           readers: {\n               xmla: XmlaDataReader\n           }\n        });\n\n        var sortExpr = function(expressions, name) {\n            if (!expressions) {\n                return null;\n            }\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\n            return null;\n        };\n\n        var removeExpr = function(expressions, name) {\n            var result = [];\n\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\n            return result;\n        };\n\n        kendo.ui.PivotSettingTarget = Widget.extend({\n            init: function(element, options) {\n                var that = this;\n\n                Widget.fn.init.call(that, element, options);\n\n                that.element.addClass(\"k-pivot-setting\");\n\n                that.dataSource = kendo.data.PivotDataSource.create(options.dataSource);\n\n                that._refreshHandler = that.refresh.bind(that);\n                that.dataSource.first(CHANGE, that._refreshHandler);\n\n                if (!options.template) {\n                    var actions = '';\n\n                    if (that.options.enabled) {\n                        actions = '<span class=\"k-setting-delete k-chip-action\"><span class=\"k-icon k-i-close\"></span></span>';\n                    }\n\n                    that.options.template = ''\n                        + '<span class=\"k-chip k-chip-md k-rounded-full k-chip-solid k-chip-solid-base\" data-' + kendo.ns + 'name=\"${data.name || data}\">'\n                            + '<span class=\"k-chip-content\">'\n                                + '<span class=\"k-chip-text\">${data.name || data}</span>'\n                            + '</span>'\n                            + '<span class=\"k-chip-actions\">' + actions + '</span>'\n                        + '</span>';\n                }\n\n                that.template = kendo.template(that.options.template);\n                that.emptyTemplate = kendo.template(that.options.emptyTemplate);\n\n                that._sortable();\n\n                that.element.on(\"click\" + NS, '.k-chip, .k-button' , function(e) {\n                    var target = $(e.target);\n                    var action = target.closest('.k-chip-action');\n                    var name = target.closest(\"[\" + kendo.attr(\"name\") + \"]\")\n                                     .attr(kendo.attr(\"name\"));\n\n                    if (!name) {\n                        return;\n                    }\n\n                    if (action.hasClass(\"k-setting-delete\")) {\n                        that.remove(name);\n                        return;\n                    }\n\n                    if (target.closest('.k-chip-actions').length > 0) {\n                        return;\n                    }\n\n                    if (that.options.sortable) {\n                        var sortDirection = $(e.currentTarget).find('.k-i-sort-asc-sm').length ? 'desc' : 'asc';\n\n                        that.sort({\n                            field: name,\n                            dir: sortDirection\n                        });\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\n                that.refresh();\n            },\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: {\n                    empty: \"Drop Fields Here\"\n                }\n            },\n            setDataSource: function(dataSource) {\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.dataSource = this.options.dataSource = dataSource;\n\n                if (this.fieldMenu) {\n                    this.fieldMenu.setDataSource(dataSource);\n                }\n                dataSource.first(CHANGE, this._refreshHandler);\n\n                this.refresh();\n            },\n\n            _sortable: function() {\n                var that = this;\n\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\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\n            _isKPI: function(data) {\n                return data.type === \"kpi\" || data.measure;\n            },\n\n            validate: function(data) {\n                var isMeasure = (data.type == 2 || \"aggregator\" in data || this._isKPI(data));\n\n                if (isMeasure) {\n                    return this.options.setting === \"measures\";\n                }\n\n                if (this.options.setting === \"measures\") {\n                    return isMeasure;\n                }\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\n                items = this.dataSource[this.options.setting === \"columns\" ? \"rows\" : \"columns\"]();\n                if (indexOf(name, items) > -1) {\n                    return false;\n                }\n\n                return true;\n            },\n\n            add: function(name) {\n                var items = this.dataSource[this.options.setting]();\n                var i, l;\n\n                name = Array.isArray(name) ? name.slice(0) : [name];\n\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\n                if (name.length) {\n                    items = items.concat(name);\n                    this.dataSource[this.options.setting](items);\n                }\n            },\n\n            move: function(name, index) {\n                var items = this.dataSource[this.options.setting]();\n                var idx = indexOf(name, items);\n\n                if (idx > -1) {\n                    name = items.splice(idx, 1)[0];\n\n                    items.splice(index, 0, name);\n\n                    this.dataSource[this.options.setting](items);\n                }\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\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\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\n                var expressions = (this.dataSource.sort() || []);\n                var result = removeExpr(expressions, expr.field);\n\n                if (skipExpr && expressions.length !== result.length) {\n                    expr = null;\n                }\n\n                if (expr) {\n                    result.push(expr);\n                }\n\n                this.dataSource.sort(result);\n            },\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\n                if (length) {\n                    for (; idx < length; idx++) {\n                        item = items[idx];\n                        item = item.name === undefined$1 ? { name: item } : item;\n\n                        html += this.template(extend({ sortIcon: this._sortIcon(item.name) }, item));\n                    }\n                } else {\n                    html = this.emptyTemplate(this.options.messages.empty);\n                }\n\n                this.element.html(html);\n            },\n\n            destroy: function() {\n                Widget.fn.destroy.call(this);\n\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.element.off(NS);\n\n                if (this.sortable) {\n                    this.sortable.destroy();\n                }\n\n                if (this.fieldMenu) {\n                    this.fieldMenu.destroy();\n                }\n\n                this.element = null;\n                this._refreshHandler = null;\n            },\n\n            _sortIcon: function(name) {\n                var expressions = this.dataSource.sort();\n                var expr = sortExpr(expressions, getName(name));\n                var icon = \"\";\n\n                if (expr) {\n                    icon = \"k-i-sort-\" + expr.dir;\n                }\n\n                return icon;\n            }\n        });\n\n        kendo.ui.PivotSettingTargetV2 = Widget.extend({\n            init: function(element, options) {\n                var that = this;\n\n                Widget.fn.init.call(that, element, options);\n\n                that.dataSource = kendo.data.PivotDataSourceV2.create(options.dataSource);\n\n                that._refreshHandler = that.refresh.bind(that);\n                that.dataSource.first(CHANGE, that._refreshHandler);\n\n                that.template = kendo.template(that.options.template);\n\n                that._sortable();\n\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\n                    if (!name) {\n                        return;\n                    }\n\n                    that.remove(name);\n                    parent.remove();\n                    that.trigger(\"remove\", { name: name });\n                });\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\n                that.refresh();\n            },\n\n            events: [\"remove\"],\n\n            options: {\n                name: \"PivotSettingTargetV2\",\n                template: null,\n                filterable: false,\n                sortable: false,\n                setting: \"columns\",\n                enabled: true,\n                messages: {\n                    empty: \"Drop Fields Here\"\n                }\n            },\n            setDataSource: function(dataSource) {\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.dataSource = this.options.dataSource = dataSource;\n\n                if (this.fieldMenu) {\n                    this.fieldMenu.setDataSource(dataSource);\n                }\n                dataSource.first(CHANGE, this._refreshHandler);\n\n                this.refresh();\n            },\n\n            _applyState: function() {\n                if (this._sortState !== undefined$1) {\n                    this.dataSource._sort = this._sortState;\n                    this._sortState = undefined$1;\n                }\n\n                if (this._stateFilter !== undefined$1) {\n                    this.dataSource._filter = this._stateFilter;\n                    this._stateFilter = undefined$1;\n                }\n\n                this.dataSource[\"_\" + this.options.setting] = this.options.setting === \"measures\" ? normalizeMeasures(this._savedState) : normalizeMembers(this._savedState);\n            },\n\n            _cancelChanges: function() {\n                this._sortState = undefined$1;\n                this._stateFilter = undefined$1;\n                this._savedState = kendo.deepExtend([], this._initialState);\n                this._redraw();\n            },\n\n            _state: function(newState, modifyInit) {\n                var that = this;\n\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\n            _sortable: function() {\n                var that = this;\n\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\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            add: function(name) {\n                var items = this._state();\n                var i, l;\n\n                name = Array.isArray(name) ? name.slice(0) : [name];\n\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\n                if (name.length) {\n                    items = items.concat(name);\n                    this._state(items);\n                    this._redraw();\n                }\n            },\n\n            move: function(name, index) {\n                var items = this._state();\n                var idx = indexOf(name, items);\n\n                if (idx > -1) {\n                    name = items.splice(idx, 1)[0];\n\n                    items.splice(index, 0, name);\n\n                    this._state(items);\n                    this._redraw();\n                }\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\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\n            _emptyState: function(enable) {\n                var that = this;\n                if (enable) {\n                    that.element.html(this.options.messages.empty)\n                        .addClass(\"k-settings-description\")\n                        .removeClass(\"k-chip-list\");\n                } else {\n                    that.element\n                        .removeClass(\"k-settings-description\")\n                        .addClass(\"k-chip-list\");\n                }\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\n            _targetsHTML: function(items) {\n                var item;\n                var html = \"\";\n                var idx = 0;\n                var options = this.options;\n                var enabled = false;\n\n                if (this.options.setting != \"measures\") {\n                    enabled = options.filterable || options.sortable;\n                }\n\n                if (items.length) {\n                    for (; idx < items.length; idx++) {\n                        item = items[idx];\n                        item = item.name === undefined$1 ? { name: item } : item;\n\n                        html += this.template({ name: item.name, menuenabled: enabled });\n                    }\n                }\n                return html;\n            },\n\n            refresh: function() {\n                if (this.dataSource._preventRefresh) {\n                    return;\n                }\n                var items = this.dataSource[this.options.setting]();\n                this._state(items, true);\n                this._emptyState(!this._state().length);\n                if (items.length) {\n                    this.element.html(this._targetsHTML(items));\n                }\n            },\n\n            destroy: function() {\n                Widget.fn.destroy.call(this);\n\n                this.dataSource.unbind(CHANGE, this._refreshHandler);\n                this.element.off(NS);\n\n                if (this.sortable) {\n                    this.sortable.destroy();\n                }\n\n                if (this.fieldMenu) {\n                    this.fieldMenu.destroy();\n                }\n\n                this.element = null;\n                this._refreshHandler = null;\n            }\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\n                that._element();\n                that._attachEvents();\n            },\n\n            options: {\n                name: \"PivotConfiguratorButton\",\n                text: \"Change settings\",\n                configurator: \"\"\n            },\n\n            destroy: function() {\n                this.element.off(NS);\n            },\n\n            setOptions: function(options) {\n                var that = this;\n                kendo.deepExtend(that.options, options);\n                this.init(this.element, this.options);\n            },\n\n            toggle: function() {\n                var attr = kendo.attr(\"role\");\n                var pivotEl = this.element\n                    .closest(\"[\" + attr + \"=pivotcontainer]\")\n                    .find(\"[\" + attr + \"=pivotgridv2]\");\n                var pivot;\n\n                $(\"#\" + this.options.configurator).toggleClass(\"k-hidden\");\n\n                if (pivotEl.length) {\n                    pivot = pivotEl.getKendoPivotGridV2();\n                    pivot._setContentWidth();\n                    pivot._updateDimensions();\n                }\n            },\n\n            _attachEvents: function() {\n                this.element.on(\"click\" + NS, this.toggle.bind(this));\n            },\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\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\n\n                that._addClasses();\n            },\n\n            options: {\n                name: \"PivotContainer\",\n                configuratorPosition: \"left\"\n            },\n\n            setOptions: function(options) {\n                var that = this;\n                kendo.deepExtend(that.options, options);\n                this.init(this.element, this.options);\n            },\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\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\n                this.element\n                    .addClass(\"k-d-flex k-pos-relative\")\n                    .addClass(className);\n            }\n        });\n\n        var PivotGridV2 = Widget.extend({\n            init: function(element, options) {\n                var that = this;\n\n                Widget.fn.init.call(that, element, options);\n\n                that._dataSource();\n\n                that._bindConfigurator();\n\n                that._wrapper();\n\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\n                that.wrapper.append(that._columnHeadersWrapper);\n                that.wrapper.append(that._rowHeadersWrapper);\n                that.wrapper.append(that._contentWrapper);\n\n                that._columnBuilder = new ColumnRowBuilder( { template: this.options.columnHeaderTemplate, axes: \"columns\" });\n                that._rowBuilder = new ColumnRowBuilder( { template: this.options.rowHeaderTemplate, axes: \"rows\" });\n                that._contentBuilder = new ContentBuilderV2( { template: this.options.dataCellTemplate || DATACELL_TEMPLATE });\n\n                that._scrollable();\n                that._rowHeadersWrapper\n                    .add(that._columnHeadersWrapper)\n                    .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\n                        if (that.trigger(eventName, { path: paths, axis: isRow ? \"rows\" : \"columns\" })) {\n                            return;\n                        }\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\n                        that.dataSource._preventRefresh = true;\n\n                        if (isRow) {\n                            that.dataSource.rows(newHeaders);\n                        } else {\n                            that.dataSource.columns(newHeaders);\n                        }\n                     });\n\n                if (that.options.autoBind) {\n                    that.dataSource.fetch();\n                }\n\n                kendo.notify(that);\n            },\n\n            events: [\n                DATABINDING,\n                DATABOUND,\n                EXPANDMEMBER,\n                COLLAPSEMEMBER\n            ],\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\n            destroy: function() {\n                var that = this;\n                Widget.fn.destroy.call(that);\n\n                if (that._windowResizeHandler) {\n                    $(window).off(RESIZE + NS, that._windowResizeHandler);\n                    that._windowResizeHandler = null;\n                }\n            },\n\n            _dataSource: function() {\n                var that = this;\n                var dataSource = that.options.dataSource;\n\n                dataSource = Array.isArray(dataSource) ? { data: dataSource } : dataSource;\n\n                if (that.dataSource && this._refreshHandler) {\n                    that.dataSource.unbind(CHANGE, that._refreshHandler)\n                                   .unbind(PROGRESS, that._progressHandler)\n                                   .unbind(ERROR, that._errorHandler);\n                } else {\n                    that._refreshHandler = that.refresh.bind(that);\n                    that._progressHandler = that._requestStart.bind(that);\n                    that._errorHandler = that._error.bind(that);\n                }\n\n                that.dataSource = kendo.data.PivotDataSourceV2.create(dataSource)\n                                       .bind(CHANGE, that._refreshHandler)\n                                       .bind(PROGRESS, that._progressHandler)\n                                       .bind(ERROR, that._errorHandler);\n            },\n\n            _resize: function() {\n                var that = this;\n                that.wrapper[0].style.setProperty('--kendo-scrollbar-width', kendo.format(\"{0}px\", getScollWidth()));\n            },\n\n            _scrollable: function() {\n                var that = this;\n                var columnsHeader = that._columnHeadersWrapper;\n                var rowsHeader = that._rowHeadersWrapper;\n\n                that._resize();\n                that._windowResizeHandler = that._resize.bind(that);\n\n                that._contentWrapper.scroll(function() {\n                    kendo.scrollLeft(columnsHeader, this.scrollLeft);\n                    rowsHeader.scrollTop(this.scrollTop);\n                });\n\n                rowsHeader.bind(\"DOMMouseScroll\" + NS + \" mousewheel\" + NS, that._wheelScroll.bind(that));\n                $(window).on(RESIZE + NS, that._windowResizeHandler);\n            },\n\n            _wheelScroll: function(e) {\n                if (e.ctrlKey) {\n                    return;\n                }\n\n                var delta = kendo.wheelDeltaY(e);\n                var scrollTop = this._contentWrapper.scrollTop();\n\n                if (delta) {\n                    e.preventDefault();\n                    $(e.currentTarget).one(\"wheel\" + NS, false);\n\n                    this._rowHeadersWrapper.scrollTop(scrollTop + (-delta));\n                    this._contentWrapper.scrollTop(scrollTop + (-delta));\n                }\n            },\n\n            _wrapper: function() {\n                var height = this.options.height;\n\n                this.wrapper = this.element.addClass(\"k-widget k-pivotgrid\");\n\n                this.wrapper.append('<span class=\"k-pivotgrid-empty-cell\" />');\n\n                if (height) {\n                    this.wrapper.css(\"height\", height);\n                }\n            },\n\n            _progress: function(toggle) {\n                kendo.ui.progress(this.wrapper, toggle);\n            },\n\n            _error: function() {\n                this._progress(false);\n            },\n\n            _requestStart: function() {\n                this._progress(true);\n            },\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\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 rowTable = this._rowHeadersWrapper.children(\"table\");\n\n                contentTable.add(columnTable).add(rowTable).find(\"col\").width(this.options.columnWidth);\n            },\n\n            _bindConfigurator: function() {\n                var configurator = this.options.configurator;\n                if (configurator) {\n                    $(configurator).kendoPivotConfiguratorV2(\"setDataSource\", this.dataSource);\n                }\n            },\n\n            cellInfoByElement: function(element) {\n                element = $(element);\n\n                return this.cellInfo(element.index(), element.parent(\"tr\").index());\n            },\n\n            cellInfo: function(columnIndex, rowIndex) {\n                var contentBuilder = this._contentBuilder;\n                var dataIndex;\n                var dataItem;\n\n                if (columnIndex >= contentBuilder.columnsCount || columnIndex < 0 ||\n                    rowIndex >= contentBuilder.rowsCount || rowIndex < 0) {\n                    return null;\n                }\n\n                dataIndex = rowIndex * contentBuilder.columnsCount + columnIndex;\n                dataItem = contentBuilder.hash[dataIndex < 0 ? 0 : dataIndex];\n\n                return {\n                    columnTuple: dataItem.columnTuple,\n                    rowTuple: dataItem.rowTuple,\n                    dataItem: dataItem.data\n                };\n            },\n\n            refresh: function() {\n                var that = this;\n\n                var dataSource = that.dataSource;\n\n                if (that.trigger(DATABINDING, { action: \"rebind\" } )) {\n                    return;\n                }\n\n                that._columnBuilder.setTuples(dataSource._columnTuples);\n                that._columnHeadersWrapper.html(that._columnBuilder.build());\n\n                that._rowBuilder.setTuples(dataSource._rowTuples);\n                that._rowHeadersWrapper.html(that._rowBuilder.build());\n\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\n                that._contentWrapper.html(that._contentBuilder.build());\n\n                that._setContentWidth();\n                that._updateDimensions();\n\n                that._progress(false);\n\n                that.trigger(DATABOUND);\n            }\n        });\n\n        ui.plugin(PivotConfiguratorButton);\n        ui.plugin(PivotContainer);\n        ui.plugin(PivotGridV2);\n\n        var PivotGrid = Widget.extend({\n            init: function(element, options) {\n                var that = this;\n                var columnBuilder;\n                var rowBuilder;\n\n                Widget.fn.init.call(that, element, options);\n\n                that._dataSource();\n\n                that._bindConfigurator();\n\n                that._wrapper();\n                that._createLayout();\n\n                that._columnBuilder = columnBuilder = new ColumnBuilder();\n                that._rowBuilder = rowBuilder = new RowBuilder();\n                that._contentBuilder = new ContentBuilder();\n\n                that._templates();\n\n                that.columnsHeader\n                    .add(that.rowsHeader)\n                    .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\n                        if (button.parent().is(\"td\")) {\n                            builder = rowBuilder;\n                            action = \"expandRow\";\n                            eventArgs.axis = \"rows\";\n                        }\n\n                        var expanded = button.hasClass(STATE_EXPANDED);\n                        var metadata = builder.metadata[path];\n                        var request = metadata.expanded === undefined$1;\n\n                        eventName = expanded ? COLLAPSEMEMBER : EXPANDMEMBER;\n                        eventArgs.childrenLoaded = metadata.maxChildren > metadata.children;\n\n                        if (that.trigger(eventName, eventArgs)) {\n                            return;\n                        }\n\n                        builder.metadata[path].expanded = !expanded;\n\n                        button.toggleClass(STATE_EXPANDED, !expanded)\n                              .toggleClass(STATE_COLLAPSED, expanded);\n\n                        if (!expanded && request) {\n                            that.dataSource[action](eventArgs.path);\n                        } else {\n                            that.refresh();\n                        }\n                    });\n\n                that._scrollable();\n\n                if (that.options.autoBind) {\n                    that.dataSource.fetch();\n                }\n\n                kendo.notify(that);\n            },\n\n            events: [\n                DATABINDING,\n                DATABOUND,\n                EXPANDMEMBER,\n                COLLAPSEMEMBER\n            ],\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\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\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\n            _bindConfigurator: function() {\n                var configurator = this.options.configurator;\n                if (configurator) {\n                    $(configurator).kendoPivotConfigurator(\"setDataSource\", this.dataSource);\n                }\n            },\n\n            cellInfoByElement: function(element) {\n                element = $(element);\n\n                return this.cellInfo(element.index(), element.parent(\"tr\").index());\n            },\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\n                if (!columnInfo || !rowInfo) {\n                    return null;\n                }\n\n                dataIndex = (rowInfo.index * contentBuilder.rowLength) + columnInfo.index;\n\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\n            setDataSource: function(dataSource) {\n                this.options.dataSource = dataSource;\n\n                this._dataSource();\n\n                if (this.measuresTarget) {\n                    this.measuresTarget.setDataSource(dataSource);\n                }\n\n                if (this.rowsTarget) {\n                    this.rowsTarget.setDataSource(dataSource);\n                }\n\n                if (this.columnsTarget) {\n                    this.columnsTarget.setDataSource(dataSource);\n                }\n\n                this._bindConfigurator();\n\n                if (this.options.autoBind) {\n                    dataSource.fetch();\n                }\n            },\n\n            setOptions: function(options) {\n                Widget.fn.setOptions.call(this, options);\n\n                this._templates();\n            },\n\n            destroy: function() {\n                Widget.fn.destroy.call(this);\n\n                clearTimeout(this._headerReflowTimeout);\n            },\n\n            _dataSource: function() {\n                var that = this;\n                var dataSource = that.options.dataSource;\n\n                dataSource = Array.isArray(dataSource) ? { data: dataSource } : dataSource;\n\n                if (that.dataSource && this._refreshHandler) {\n                    that.dataSource.unbind(CHANGE, that._refreshHandler)\n                                   .unbind(STATERESET, that._stateResetHandler)\n                                   .unbind(PROGRESS, that._progressHandler)\n                                   .unbind(ERROR, that._errorHandler);\n                } else {\n                    that._refreshHandler = that.refresh.bind(that);\n                    that._progressHandler = that._requestStart.bind(that);\n                    that._stateResetHandler = that._stateReset.bind(that);\n                    that._errorHandler = that._error.bind(that);\n                }\n\n                that.dataSource = kendo.data.PivotDataSource.create(dataSource)\n                                       .bind(CHANGE, that._refreshHandler)\n                                       .bind(PROGRESS, that._progressHandler)\n                                       .bind(STATERESET, that._stateResetHandler)\n                                       .bind(ERROR, that._errorHandler);\n            },\n\n            _error: function() {\n                this._progress(false);\n            },\n\n            _requestStart: function() {\n                this._progress(true);\n            },\n\n            _stateReset: function() {\n                this._columnBuilder.reset();\n                this._rowBuilder.reset();\n            },\n\n            _wrapper: function() {\n                var height = this.options.height;\n\n                this.wrapper = this.element.addClass(\"k-widget k-pivot\");\n\n                if (height) {\n                    this.wrapper.css(\"height\", height);\n                }\n            },\n\n            _measureFields: function() {\n                this.measureFields = $(DIV).addClass(\"k-pivot-toolbar k-toolbar k-settings-measures\");\n\n                this.measuresTarget = this._createSettingTarget(this.measureFields, {\n                    setting: \"measures\",\n                    messages: {\n                        empty: this.options.messages.measureFields\n                    }\n                });\n            },\n\n            _createSettingTarget: function(element, options) {\n                var template;\n                var sortable = options.sortable;\n                var icons = '';\n\n                if (sortable) {\n                    icons += '#if (data.sortIcon) {#';\n                    icons += '<span class=\"k-chip-action\"><span class=\"k-icon ${data.sortIcon}-sm\"></span></span>';\n                    icons += '#}#';\n                }\n\n                if (options.filterable || sortable) {\n                    icons += '<span class=\"k-setting-fieldmenu k-chip-action\"><span class=\"k-icon k-i-more-vertical\"></span></span>';\n                }\n                if (this.options.reorderable) {\n                    icons += '<span class=\"k-setting-delete k-chip-action\"><span class=\"k-icon k-i-close\"></span></span>';\n                }\n\n                template = ''\n                    + '<span class=\"k-chip k-chip-md k-rounded-full k-chip-solid k-chip-solid-base\" tabindex=\"0\" data-' + kendo.ns + 'name=\"${data.name}\">'\n                        + '<span class=\"k-chip-content\">'\n                            + '<span class=\"k-chip-text\">${data.name}</span>'\n                        + '</span>'\n                        + '<span class=\"k-chip-actions k-field-actions\">' + icons + '</span>'\n                    + '</span>';\n\n                return new kendo.ui.PivotSettingTarget(element, $.extend({\n                    dataSource: this.dataSource,\n                    template: template,\n                    emptyTemplate: '<span class=\"k-empty\">${data}</span>',\n                    enabled: this.options.reorderable\n                }, options));\n            },\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\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\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\n                that._measureFields();\n                that.columnFields = $(DIV).addClass(\"k-pivot-toolbar k-toolbar k-settings-columns\");\n\n                that.rowFields = $(DIV).addClass(\"k-pivot-toolbar k-toolbar k-settings-rows\");\n                that.columnsHeader = $('<div class=\"k-grid-header-wrap\" />')\n                                        .wrap('<div class=\"k-grid-header\" />');\n\n                that.columnsHeader.parent().css(\"padding-right\", kendo.support.scrollbar());\n\n                that.rowsHeader = $('<div class=\"k-grid k-widget k-alt\"/>');\n                that.content = $('<div class=\"k-grid-content\" />');\n\n                leftContainer.append(that.measureFields);\n                leftContainer.append(that.rowFields);\n                leftContainer.append(that.rowsHeader);\n\n                gridWrapper.append(that.columnsHeader.parent());\n                gridWrapper.append(that.content);\n\n                rightContainer.append(that.columnFields);\n                rightContainer.append(gridWrapper);\n\n                that.wrapper.append(layoutTable);\n\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\n                that._initSettingTargets();\n            },\n\n            _progress: function(toggle) {\n                kendo.ui.progress(this.wrapper, toggle);\n            },\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\n            _columnHeaderReflow: function() {\n                var columnTable = this.columnsHeader.children(\"table\");\n\n                if (!kendo.support.browser.mozilla) {\n                    return;\n                }\n\n                clearTimeout(this._headerReflowTimeout);\n\n                columnTable.css(\"table-layout\", \"auto\");\n\n                this._headerReflowTimeout = setTimeout(function() {\n                    columnTable.css(\"table-layout\", \"\");\n                });\n            },\n\n            _setSectionsWidth: function() {\n                var rowsHeader = this.rowsHeader;\n                var leftColumn = rowsHeader.parent(\".k-pivot-rowheaders\").width(AUTO);\n                var width;\n\n                width = Math.max(outerWidth(this.measureFields), outerWidth(this.rowFields));\n                width = Math.max(rowsHeader.children(\"table\").width(), width);\n\n                leftColumn.width(width);\n            },\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\n                var padding = rowFieldsHeight - this.rowFields.height();\n\n                var firstRowHeight = columnFieldsHeight > measureFieldsHeight ? columnFieldsHeight : measureFieldsHeight;\n                var secondRowHeight = columnsHeight > rowFieldsHeight ? columnsHeight : rowFieldsHeight;\n\n                this.measureFields.height(firstRowHeight);\n                this.columnFields.height(firstRowHeight);\n                this.rowFields.height(secondRowHeight - padding);\n                this.columnsHeader.height(secondRowHeight);\n            },\n\n            _setContentWidth: function() {\n                var contentTable = this.content.find(\"table\");\n                var columnTable = this.columnsHeader.children(\"table\");\n\n                var rowLength = contentTable.children(\"colgroup\").children().length;\n\n                var calculatedWidth = rowLength * this.options.columnWidth;\n                var minWidth = Math.ceil((calculatedWidth / this.content.width()) * 100);\n\n                if (minWidth < 100) {\n                    minWidth = 100;\n                }\n\n                contentTable.add(columnTable).css(\"width\", minWidth + \"%\");\n\n                this._resetColspan(columnTable);\n            },\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\n                if (that.wrapper.is(\":visible\")) {\n                    if (!innerHeight || !height) {\n                        if (skipScrollbar) {\n                            scrollbar = 0;\n                        }\n\n                        content.height(\"auto\");\n                        rowsHeader.height(content.height() - scrollbar);\n                        return;\n                    }\n\n                    innerHeight -= outerHeight(that.columnFields);\n                    innerHeight -= outerHeight(that.columnsHeader.parent());\n\n                    if (innerHeight <= scrollbar * 2) { // do not set height if proper scrollbar cannot be displayed\n                        innerHeight = scrollbar * 2 + 1;\n                        if (!skipScrollbar) {\n                            innerHeight += scrollbar;\n                        }\n                    }\n\n                    content.height(innerHeight);\n\n                    if (skipScrollbar) {\n                        scrollbar = 0;\n                    }\n\n                    rowsHeader.height(innerHeight - scrollbar);\n                }\n            },\n\n            _resetColspan: function(columnTable) {\n                var that = this;\n                var cell = columnTable.children(\"tbody\").children().first().children().first();\n\n                if (that._colspan === undefined$1) {\n                    that._colspan = cell.attr(\"colspan\");\n                }\n\n                cell.attr(\"colspan\", 1);\n\n                clearTimeout(that._layoutTimeout);\n\n                that._layoutTimeout = setTimeout(function() {\n                    cell.attr(\"colspan\", that._colspan);\n                    that._colspan = undefined$1;\n                });\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\n                if (dataSource.measuresAxis() === axis) {\n                    if (dataSource[axis]().length === 0 || hasMeasure) {\n                        result = measures;\n                    }\n                }\n\n                return result;\n            },\n\n            items: function() {\n                return [];\n            },\n\n            refresh: function() {\n                var that = this;\n                var dataSource = that.dataSource;\n\n                var axes = dataSource.axes();\n                var columns = (axes.columns || {}).tuples || [];\n                var rows = (axes.rows || {}).tuples || [];\n\n                var columnBuilder = that._columnBuilder;\n                var rowBuilder = that._rowBuilder;\n\n                var columnAxis = {};\n                var rowAxis = {};\n\n                if (that.trigger(DATABINDING, { action: \"rebind\" } )) {\n                    return;\n                }\n\n                columnBuilder.measures = that._axisMeasures(AXIS_COLUMNS);\n                rowBuilder.measures = that._axisMeasures(AXIS_ROWS);\n\n                that.columnsHeaderTree.render(columnBuilder.build(columns));\n                that.rowsHeaderTree.render(rowBuilder.build(rows));\n\n                columnAxis = {\n                    indexes: columnBuilder._indexes,\n                    measures: columnBuilder.measures,\n                    metadata: columnBuilder.metadata\n                };\n\n                rowAxis = {\n                    indexes: rowBuilder._indexes,\n                    measures: rowBuilder.measures,\n                    metadata: rowBuilder.metadata\n                };\n\n                that.contentTree.render(that._contentBuilder.build(dataSource.view(), columnAxis, rowAxis));\n\n                that._resize();\n\n                if (that.touchScroller) {\n                    that.touchScroller.contentResized();\n                } else {\n                    var touchScroller = kendo.touchScroller(that.content);\n\n                    if (touchScroller && touchScroller.movable) {\n                        that.touchScroller = touchScroller;\n\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\n                that._progress(false);\n\n                that.trigger(DATABOUND);\n            },\n\n            _scrollable: function() {\n                var that = this;\n                var columnsHeader = that.columnsHeader;\n                var rowsHeader = that.rowsHeader;\n\n                that.content.on(\"scroll\", function() {\n                    kendo.scrollLeft(columnsHeader, this.scrollLeft);\n                    rowsHeader.scrollTop(this.scrollTop);\n                });\n\n                rowsHeader.on(\"DOMMouseScroll\" + NS + \" mousewheel\" + NS, that._wheelScroll.bind(that));\n            },\n\n            _wheelScroll: function(e) {\n                if (e.ctrlKey) {\n                    return;\n                }\n\n                var delta = kendo.wheelDeltaY(e);\n                var scrollTop = this.content.scrollTop();\n\n                if (delta) {\n                    e.preventDefault();\n                    //In Firefox DOMMouseScroll event cannot be canceled\n                    $(e.currentTarget).one(\"wheel\" + NS, false);\n\n                    this.rowsHeader.scrollTop(scrollTop + (-delta));\n                    this.content.scrollTop(scrollTop + (-delta));\n                }\n            }\n        });\n\n        var element = kendo.dom.element;\n        var htmlNode = kendo.dom.html;\n\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\n        var buildPath = function(tuple, index) {\n            var path = [];\n            var idx = 0;\n\n            for (; idx <= index; idx++) {\n                path.push(tuple.members[idx].name);\n            }\n\n            return path;\n        };\n\n        var tupleName = function(tuple, index) {\n            var name = \"\";\n            var idx = 0;\n\n            for (; idx <= index; idx++) {\n                name += tuple.members[idx].name;\n            }\n\n            return name;\n        };\n\n        var ContentBuilderV2 = Class.extend({\n            init: function(options) {\n                this.template = kendo.template(options.template);\n                this.hash = [];\n            },\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\n            addColElements: function(count) {\n                var html = \"\";\n\n                for (var index = 0; index < count; index++) {\n                    html += \"<col>\";\n                }\n\n                this.table.find(\"colgroup\").append(html);\n            },\n\n            addRowElements: function(data) {\n                var that = this;\n                var body = that.table.find(\"tbody\");\n                var row;\n\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\n                this.rowsCount = data.length;\n            },\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\n            build: function() {\n                var data = toData((this.data || []).slice(), this.columnHeaderLeafs, this.rowHeaderLeafs, this.columnHeaderBreadth, this.rowHeaderDepth);\n                var that = this;\n\n                var table = $(\"<table class='k-pivotgrid-table'><colgroup></colgroup><tbody class='k-pivotgrid-tbody'></tbody></table>\");\n\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\n                return that.table;\n            }\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\n            setTuples: function(tuples) {\n                this.tuples = tuples;\n            },\n\n            addColElements: function(count) {\n                var html = \"\";\n\n                for (var index = 0; index < count; index++) {\n                    html += \"<col>\";\n                }\n\n                this.table.find(\"colgroup\").append(html);\n            },\n\n            addRowElements: function(columnHeaderRows) {\n                var that = this;\n                var body = that.table.find(\"tbody\");\n                var row;\n\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\n            addColumCell: function(rowEl, rowItem) {\n                var that = this;\n                var cellEl;\n                var cell;\n\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\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\n                var table = $(\"<table class='k-pivotgrid-table'><colgroup></colgroup><tbody class='k-pivotgrid-tbody'></tbody></table>\");\n\n                that.table = table;\n                that.addColElements(this.axes == \"columns\" ? headerLeafs.length : rowHeaderBreadth);\n                that.addRowElements(headerRows);\n\n                return that.table;\n            },\n\n            getTree: function() {\n                return this._tree;\n            },\n\n            getBreadth: function() {\n                return this._breadth;\n            },\n\n            getHeaderLeafs: function() {\n                return this._headerLeafs;\n            }\n        });\n\n        var ColumnBuilder = Class.extend({\n            init: function() {\n                this.measures = 1;\n                this.metadata = {};\n            },\n\n            build: function(tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n\n                return [\n                    element(\"table\", null, [colgroup, tbody])\n                ];\n            },\n\n            reset: function() {\n                this.metadata = {};\n            },\n\n            _colGroup: function() {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n\n                for (; idx < length; idx++) {\n                    children.push(element(\"col\", null));\n                }\n\n                return element(\"colgroup\", null, children);\n            },\n\n            _tbody: function(tuples) {\n                var root = tuples[0];\n\n                this.map = {};\n                this.rows = [];\n                this.rootTuple = root;\n\n                this._indexes = [];\n\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\n                return element(\"tbody\", null, this.rows);\n            },\n\n            _normalize: function() {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n                var row;\n\n                var cellsLength;\n                var cellIdx;\n                var cells;\n                var cell;\n\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n\n                    if (row.rowSpan === 1) {\n                        continue;\n                    }\n\n                    cells = row.children;\n\n                    cellIdx = 0;\n                    cellsLength = cells.length;\n\n                    for (; cellIdx < cellsLength; cellIdx++) {\n                        cell = cells[cellIdx];\n\n                        if (cell.tupleAll) {\n                            cell.attr.rowSpan = row.rowSpan;\n                        }\n                    }\n                }\n            },\n\n            _rowIndex: function(row) {\n                var rows = this.rows;\n                var length = rows.length;\n                var idx = 0;\n\n                for (; idx < length; idx++) {\n                    if (rows[idx] === row) {\n                        break;\n                    }\n                }\n\n                return idx;\n            },\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\n                if (length) {\n                    for (; idx < length; idx++) {\n                        rowLength += cells[idx].attr.colSpan || 1;\n                    }\n                }\n\n                if (!rowLength) {\n                    rowLength = this.measures;\n                }\n\n                return rowLength;\n            },\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\n                var row = map[rowKey];\n\n                if (!row) {\n                    row = element(\"tr\", null, []);\n\n                    row.parentMember = parentMember;\n                    row.collapsed = 0;\n                    row.colSpan = 0;\n                    row.rowSpan = 1;\n\n                    map[rowKey] = row;\n                    parentRow = map[rootName + (Number(levelNum) - 1)];\n\n                    if (parentRow) {\n                        children = parentRow.children;\n\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\n                    this.rows.splice(this._rowIndex(parentRow) + 1, 0, row);\n                } else {\n                    row.notFirst = false;\n\n                    if (!row.parentMember || row.parentMember !== parentMember) {\n                        row.parentMember = parentMember;\n                        row.collapsed = 0;\n                        row.colSpan = 0;\n                    }\n                }\n\n                return row;\n            },\n\n            _measures: function(measures, tuple, className) {\n                var map = this.map;\n                var row = map.measureRow;\n                var measure;\n\n                if (!row) {\n                    row = element(\"tr\", null, []);\n                    map.measureRow = row;\n                    this.rows.push(row);\n                }\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\n                return length;\n            },\n\n            _content: function(member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\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\n            _buildRows: function(tuple, memberIdx, parentMember) {\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n\n                var row, childRow, children, childrenLength;\n                var cell, allCell, cellAttr;\n                var cellChildren = [];\n                var path;\n\n                var idx = 0;\n                var metadata;\n\n                var colSpan;\n                var collapsed = 0;\n                var memberCollapsed = 0;\n\n                if (member.measure) {\n                    this._measures(member.children, tuple);\n                    return;\n                }\n\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n                row = this._row(tuple, memberIdx, parentMember);\n\n                children = member.children;\n                childrenLength = children.length;\n\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\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        collapsed = metadata.maxChildren;\n                        row.collapsed += collapsed;\n\n                        metadata.children = 0;\n                        childrenLength = 0;\n                    }\n\n                    cellAttr = { className: \"k-icon \" + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    cellAttr[kendo.attr(\"path\")] = path;\n\n                    cellChildren.push(element(\"span\", cellAttr));\n                }\n\n                cellChildren.push(this._content(member, tuple));\n                cell = this._cell((row.notFirst ? \" k-first\" : \"\"), cellChildren, member);\n\n                row.children.push(cell);\n                row.colSpan += 1;\n\n                if (childrenLength) {\n                    allCell = this._cell(\" k-alt\", [this._content(member, tuple)], member);\n                    row.children.push(allCell);\n\n                    for (; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx, member);\n                    }\n\n                    colSpan = childRow.colSpan;\n                    collapsed = childRow.collapsed;\n\n                    cell.attr.colSpan = colSpan;\n\n                    metadata.children = colSpan;\n                    metadata.members = 1;\n\n                    row.colSpan += colSpan;\n                    row.collapsed += collapsed;\n                    row.rowSpan = childRow.rowSpan + 1;\n\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\n                            row.collapsed += childRow.collapsed;\n                            memberCollapsed = childRow.collapsed;\n                        }\n\n                        allCell.attr.colSpan = colSpan;\n                        colSpan -= 1;\n\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\n                        row.collapsed += childRow.collapsed;\n                        memberCollapsed = childRow.collapsed;\n                    }\n\n                    metadata.members = colSpan;\n\n                    if (colSpan > 1) {\n                        cell.attr.colSpan = colSpan;\n                        row.colSpan += colSpan - 1;\n                    }\n                }\n\n                if (metadata.maxMembers < (metadata.members + memberCollapsed)) {\n                    metadata.maxMembers = metadata.members + memberCollapsed;\n                }\n\n                children = metadata.children + collapsed;\n\n                if (metadata.maxChildren < children) {\n                    metadata.maxChildren = children;\n                }\n\n                (allCell || cell).tupleAll = true;\n\n                return row;\n            }\n        });\n\n        var RowBuilder = Class.extend({\n            init: function() {\n                this.metadata = {};\n            },\n\n            build: function(tuples) {\n                var tbody = this._tbody(tuples);\n                var colgroup = this._colGroup();\n\n                return [\n                    element(\"table\", null, [colgroup, tbody])\n                ];\n            },\n\n            reset: function() {\n                this.metadata = {};\n            },\n\n            _rowLength: function() {\n                var children = this.rows[0].children;\n                var length = 0;\n                var idx = 0;\n\n                var cell = children[idx];\n\n                while (cell) {\n                    length += (cell.attr.colSpan || 1);\n                    cell = children[++idx];\n                }\n\n                return length;\n            },\n\n            _colGroup: function() {\n                var length = this._rowLength();\n                var children = [];\n                var idx = 0;\n\n                for (; idx < length; idx++) {\n                    children.push(element(\"col\", null));\n                }\n\n                return element(\"colgroup\", null, children);\n            },\n\n            _tbody: function(tuples) {\n                var root = tuples[0];\n\n                this.rootTuple = root;\n                this.rows = [];\n                this.map = {};\n\n                this._indexes = [];\n\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\n                return element(\"tbody\", null, this.rows);\n            },\n\n            _normalize: function() {\n                var rows = this.rows;\n                var rowsLength = rows.length;\n                var rowIdx = 0;\n\n                var members = this.rootTuple.members;\n                var firstMemberName = members[0].name;\n                var membersLength = members.length;\n                var memberIdx = 0;\n\n                var row;\n                var cell;\n                var maxcolSpan;\n                var map = this.map;\n                var allRow;\n\n                for (; rowIdx < rowsLength; rowIdx++) {\n                    row = rows[rowIdx];\n\n                    for (memberIdx = 0; memberIdx < membersLength; memberIdx++) {\n                        maxcolSpan = this[members[memberIdx].name];\n                        cell = row.colSpan[\"dim\" + memberIdx];\n\n                        if (cell && cell.colSpan < maxcolSpan) {\n                            cell.attr.colSpan = (maxcolSpan - cell.colSpan) + 1;\n                        }\n                    }\n                }\n\n                row = map[firstMemberName];\n                allRow = map[firstMemberName + \"all\"];\n\n                if (row) {\n                    row.children[0].attr.className = \"k-first\";\n                }\n\n                if (allRow) {\n                    allRow.children[0].attr.className += \" k-first\";\n                }\n            },\n\n            _row: function(children) {\n                var row = element(\"tr\", null, children);\n                row.rowSpan = 1;\n                row.colSpan = {};\n\n                this.rows.push(row);\n\n                return row;\n            },\n\n            _content: function(member, tuple) {\n                return htmlNode(this.template({\n                    member: member,\n                    tuple: tuple\n                }));\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\n            _buildRows: function(tuple, memberIdx) {\n                var map = this.map;\n                var path;\n\n                var members = tuple.members;\n                var member = members[memberIdx];\n                var nextMember = members[memberIdx + 1];\n\n                var children = member.children;\n                var childrenLength = children.length;\n\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\n                var cell, allCell;\n                var childRow, allRow;\n                var metadata;\n                var className;\n                var cellChildren = [];\n                var expandIconAttr;\n                var idx;\n\n                if (!row || row.hasChild) {\n                    row = this._row();\n                } else {\n                    row.hasChild = true;\n                }\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\n                    row.rowSpan = childrenLength;\n\n                    for (idx = 1; idx < childrenLength; idx++) {\n                        this._row([ this._cell(className, [ this._content(children[idx], tuple) ], children[idx]) ]);\n                    }\n\n                    return row;\n                }\n\n                map[tuplePath + member.name] = row;\n\n                path = kendo.stringify(buildPath(tuple, memberIdx));\n\n                metadata = this.metadata[path];\n                if (!metadata) {\n                    this.metadata[path] = metadata = createMetadata(levelNum, memberIdx);\n                    metadata.rootLevelNum = rootLevelNum;\n                }\n\n                this._indexes.push({\n                    path: path,\n                    tuple: tuple\n                });\n\n                if (member.hasChildren) {\n                    if (metadata.expanded === false) {\n                        childrenLength = 0;\n                        metadata.children = 0;\n                    }\n\n                    expandIconAttr = { className: \"k-icon \" + (childrenLength ? STATE_EXPANDED : STATE_COLLAPSED) };\n                    expandIconAttr[kendo.attr(\"path\")] = path;\n\n                    cellChildren.push(element(\"span\", expandIconAttr));\n                }\n\n                cellChildren.push(this._content(member, tuple));\n\n                className = row.allCell && !childrenLength ? \"k-grid-footer\" : \"\";\n                cell = this._cell(className, cellChildren, member);\n                cell.colSpan = colSpan;\n\n                row.children.push(cell);\n                row.colSpan[\"dim\" + memberIdx] = cell;\n\n                if (!this[rootName] || this[rootName] < colSpan) {\n                    this[rootName] = colSpan;\n                }\n\n                if (childrenLength) {\n                    row.allCell = false;\n                    row.hasChild = false;\n\n                    for (idx = 0; idx < childrenLength; idx++) {\n                        childRow = this._buildRows(children[idx], memberIdx);\n\n                        if (row !== childRow) {\n                            row.rowSpan += childRow.rowSpan;\n                        }\n                    }\n\n                    if (row.rowSpan > 1) {\n                        cell.attr.rowSpan = row.rowSpan;\n                    }\n\n                    metadata.children = row.rowSpan;\n\n                    allCell = this._cell(\"k-grid-footer\", [this._content(member, tuple)], member);\n                    allCell.colSpan = colSpan;\n\n                    allRow = this._row([ allCell ]);\n                    allRow.colSpan[\"dim\" + memberIdx] = allCell;\n                    allRow.allCell = true;\n\n                    map[tuplePath + member.name + \"all\"] = allRow;\n\n                    if (nextMember) {\n                        childRow = this._buildRows(tuple, memberIdx + 1);\n                        allCell.attr.rowSpan = childRow.rowSpan;\n                    }\n\n                    row.rowSpan += allRow.rowSpan;\n\n                    metadata.members = allRow.rowSpan;\n\n                } else if (nextMember) {\n                    row.hasChild = false;\n                    this._buildRows(tuple, memberIdx + 1);\n\n                    (allCell || cell).attr.rowSpan = row.rowSpan;\n\n                    metadata.members = row.rowSpan;\n                }\n\n                if (metadata.maxChildren < metadata.children) {\n                    metadata.maxChildren = metadata.children;\n                }\n\n                if (metadata.maxMembers < metadata.members) {\n                    metadata.maxMembers = metadata.members;\n                }\n\n                return row;\n            }\n        });\n\n        var ContentBuilder = Class.extend({\n            init: function() {\n                this.columnAxis = {};\n                this.rowAxis = {};\n            },\n\n            build: function(data, columnAxis, rowAxis) {\n                var index = columnAxis.indexes[0];\n                var metadata = columnAxis.metadata[index ? index.path : undefined$1];\n\n                this.columnAxis = columnAxis;\n                this.rowAxis = rowAxis;\n\n                this.data = data;\n\n                this.rowLength = metadata ? metadata.maxChildren + metadata.maxMembers : columnAxis.measures.length || 1;\n\n                if (!this.rowLength) {\n                    this.rowLength = 1;\n                }\n\n                var tbody = this._tbody();\n                var colgroup = this._colGroup();\n\n                return [\n                    element(\"table\", null, [colgroup, tbody])\n                ];\n            },\n\n            _colGroup: function() {\n                var length = this.columnAxis.measures.length || 1;\n                var children = [];\n                var idx = 0;\n\n                if (this.rows[0]) {\n                    length = this.rows[0].children.length;\n                }\n\n                for (; idx < length; idx++) {\n                    children.push(element(\"col\", null));\n                }\n\n                return element(\"colgroup\", null, children);\n            },\n\n            _tbody: function() {\n                this.rows = [];\n\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\n                    this._buildRows();\n                } else {\n                    this.rows.push(element(\"tr\", null, [ element(\"td\", null, [ htmlNode(\"&nbsp;\") ]) ]));\n                }\n\n                return element(\"tbody\", null, this.rows);\n            },\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\n                var current;\n                var dataIdx = 0;\n                var firstEmpty = 0;\n\n                var idx = 0;\n                var length = indexes.length;\n                var measureIdx;\n                var index;\n\n                var children;\n                var skipChildren;\n\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\n                    return result;\n                }\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\n                    if (children) {\n                        children -= measuresLength;\n                    }\n\n                    if (current.expanded === false && current.children !== current.maxChildren) {\n                        skipChildren = current.maxChildren;\n                    }\n\n                    if (current.parentMember && current.levelNum === current.rootLevelNum) {\n                        children = -1;\n                    }\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\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\n                        while (result[firstEmpty] !== undefined$1) {\n                            firstEmpty += 1;\n                        }\n                    }\n\n                    if (firstEmpty === total) {\n                        break;\n                    }\n\n                    dataIdx += skipChildren;\n                }\n\n                return result;\n            },\n\n            _buildRows: function() {\n                var rowIndexes = this.rowIndexes;\n                var length = rowIndexes.length;\n                var idx = 0;\n\n                for (; idx < length; idx++) {\n                    var rowIndex = rowIndexes[idx];\n                    if (rowIndex) {\n                        this.rows.push(this._buildRow(rowIndex));\n                    }\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\n                var templateInfo;\n                var cell, cellContent;\n                var attr, dataItem, measure;\n\n                for (; idx < length; idx++) {\n                    columnInfo = columnIndexes[idx];\n\n                    if (columnInfo === undefined$1) {\n                        continue;\n                    }\n\n                    attr = {};\n                    if (columnInfo.children) {\n                        attr.className = \"k-alt\";\n                    }\n\n                    cellContent = \"\";\n                    dataItem = this.data[startIdx + columnInfo.index];\n                    measure = columnInfo.measure || rowInfo.measure;\n\n                    templateInfo = {\n                        columnTuple: columnInfo.tuple,\n                        rowTuple: rowInfo.tuple,\n                        measure: measure,\n                        dataItem: dataItem\n                    };\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\n                    if (!cellContent) {\n                        cellContent = this.dataTemplate(templateInfo);\n                    }\n\n                    cell = element(\"td\", attr, [ htmlNode(cellContent) ]);\n                    cell.value = dataItem.value;\n                    cells.push(cell);\n                }\n\n                attr = {};\n                if (rowInfo.children) {\n                    attr.className = \"k-grid-footer\";\n                }\n\n                return element(\"tr\", attr, cells);\n            }\n        });\n\n        ui.plugin(PivotGrid);\n\n        kendo.PivotExcelExporter = kendo.Class.extend({\n            init: function(options) {\n                this.options = options;\n\n                this.widget = options.widget;\n                this.dataSource = this.widget.dataSource;\n            },\n\n            _columns: function() {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n\n                var width = this.widget.options.columnWidth;\n                var result = [];\n                var idx;\n\n                if (rowHeaderLength && this.dataSource.data()[0]) {\n                    for (idx = 0; idx < rowHeaderLength; idx++) {\n                        result.push({\n                            autoWidth: true\n                        });\n                    }\n                }\n\n                for (idx = 0; idx < columnHeaderLength; idx++) {\n                    result.push({\n                        autoWidth: false,\n                        width: width\n                    });\n                }\n\n                return result;\n            },\n\n            _cells: function(rows, type, callback) {\n                var result = [];\n\n                var i = 0;\n                var length = rows.length;\n\n                var cellsLength;\n                var row, cells;\n                var j, cell;\n\n                for (; i < length; i++) {\n                    row = [];\n                    cells = rows[i].children;\n                    cellsLength = cells.length;\n\n                    for (j = 0; j < cellsLength; j++) {\n                        cell = cells[j];\n\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\n                    if (callback) {\n                        callback(row, i);\n                    }\n\n                    result.push({\n                        cells: row,\n                        type: type\n                    });\n                }\n\n                return result;\n            },\n\n            _rows: function() {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n\n                var columnHeaderLength = columnHeaderTable.children[0].children.length;\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n\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\n                var columnRows = this._cells(columnHeaderRows, \"header\");\n\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\n                var dataCallback = function(row, index) {\n                    var j = 0;\n                    var cell, value;\n                    var cells = contentRows[index].children;\n\n                    for (; j < columnHeaderLength; j++) {\n                        cell = cells[j];\n                        value = Number(cell.value);\n\n                        if (isNaN(value)) {\n                            value = cell.value;\n                        }\n\n                        row.push({\n                            background: \"#dfdfdf\",\n                            color: \"#333\",\n                            value: value,\n                            colSpan: 1,\n                            rowSpan: 1\n                        });\n                    }\n                };\n\n                var rowRows = this._cells(rowHeaderRows, \"data\", dataCallback);\n\n                return columnRows.concat(rowRows);\n            },\n\n            _freezePane: function() {\n                var columnHeaderTable = this.widget.columnsHeaderTree.children[0];\n                var rowHeaderTable = this.widget.rowsHeaderTree.children[0];\n\n                var rowHeaderLength = rowHeaderTable.children[0].children.length;\n                var columnHeaderRows = columnHeaderTable.children[1].children;\n\n                return {\n                    colSplit: rowHeaderLength,\n                    rowSplit: columnHeaderRows.length\n                };\n            },\n\n            workbook: function() {\n                var promise,\n                    resolveFn = function() {\n                        return {\n                            sheets: [ {\n                                columns: this._columns(),\n                                rows: this._rows(),\n                                freezePane: this._freezePane(),\n                                filter: null\n                            } ]\n                        };\n                    };\n\n                if (this.dataSource.view()[0]) {\n                    promise = $.Deferred();\n                    promise.resolve();\n                } else {\n                    promise = this.dataSource.fetch();\n                }\n\n                return promise.then(resolveFn.bind(this));\n            }\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\n                var exporter = new kendo.PivotExcelExporter({\n                    widget: this\n                });\n\n                var resolveFn = function(book) {\n                    if (!this.trigger(\"excelExport\", { workbook: book })) {\n                        var workbook = new kendo.ooxml.Workbook(book);\n\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                };\n\n                exporter.workbook().then(resolveFn.bind(this));\n            }\n        };\n\n        kendo.PivotExcelMixin = PivotExcelMixin;\n\n        if (kendo.ooxml && kendo.ooxml.Workbook) {\n            PivotExcelMixin.extend(PivotGrid.prototype);\n        }\n\n        if (kendo.PDFMixin) {\n            kendo.PDFMixin.extend(PivotGrid.prototype);\n\n            PivotGrid.fn._drawPDF = function() {\n                return this._drawPDFShadow({\n                    width: this.wrapper.width()\n                }, {\n                    avoidLinks: this.options.pdf.avoidLinks\n                });\n            };\n        }\n\n        if (kendo.PDFMixin) {\n            kendo.PDFMixin.extend(PivotGridV2.prototype);\n\n            PivotGridV2.fn._drawPDF = function() {\n                return this._drawPDFShadow({\n                    width: this.wrapper.width()\n                }, {\n                    avoidLinks: this.options.pdf.avoidLinks\n                });\n            };\n        }\n\n    })(window.kendo.jQuery);\n\n}));\n"]}