{"version":3,"file":"kendo.data.js","names":["logic","or","concat","acc","fn","a","identity","and","operatorsMap","isnullorempty","kendo","isBlank","isnotnullorempty","isPresent","contains","b","indexOf","doesnotcontain","doesnotendwith","length","doesnotstartwith","lastIndexOf","endswith","eq","gt","gte","isempty","isnotempty","isnotnull","isnull","lt","lte","neq","startswith","dateRegExp","convertValue","value","ignoreCase","accentFoldingFiltering","isString","date","exec","Date","getTime","toLocaleLowerCase","toLowerCase","isDate","typedGetter","prop","x","isNumeric","transformFilter","field","operator","itemProp","isFunction","getter","op","isCompositeFilterDescriptor","source","filters","transformCompositeFilter","filter","combiner","map","extendAccentFolding","reduce","Object","assign","filterExprNoEval","expr","__meta__","id","name","category","description","depends","features","$","undefined$1","extend","isPlainObject","isEmptyObject","isArray","Array","grep","ajax","each","noop","window","Observable","Class","STRING","FUNCTION","CREATE","READ","UPDATE","DESTROY","CHANGE","SYNC","GET","ERROR","REQUESTSTART","PROGRESS","REQUESTEND","ITEMSLOADED","ITEMLOAD","crud","o","stringify","math","Math","push","join","pop","splice","shift","slice","unshift","toString","stableSort","support","objectKeys","ObservableArray","init","array","type","that","this","ObservableObject","call","wrapAll","_loadPromises","_loadedNodes","at","index","toJSON","serializeFunctions","idx","json","parent","target","wrap","object","Model","bind","e","isGroup","hasOwnProperty","trigger","node","items","action","promise","_loading","done","collection","nodes","loading","result","arguments","apply","omitChangeEvent","sort","howMany","item","i","len","omitCache","children","unbind","forEach","callback","thisArg","context","reduceRight","find","every","some","remove","empty","Symbol","iterator","prototype","LazyObservableArray","data","events","_events","_parent","eventHandler","prefix","key","event","_notifyChange","ownKeys","ignoreObjectKeys","keys","filteredObjectKeys","props","protoKeys","getPrototypeOf","isPrimitiveType","getOwnPropertyNames","f","member","_handlers","charAt","uid","guid","shouldSerialize","get","_set","composite","paths","split","path","obj","set","setter","isSetPrevented","current","change","isObservableArray","isDataSource","DataSource","equal","y","xtype","parsers","number","parseFloat","parseDate","boolean","string","default","defaultValues","defaults","_initializers","dirty","dirtyFields","idField","_defaultId","_parse","parse","fieldName","fields","getFieldByName","editable","accept","isNew","define","base","options","model","originalName","proto","functionFields","nullable","defaultValue","Comparer","selector","compare","localeCompare","create","dir","combine","comparers","StableComparer","asc","valueA","valueB","__position","desc","operators","quote","str","replace","JSON","textOp","impl","ignore","getMatchRegexp","pattern","rx","esc","ch","matches","substring","doesnotmatch","Query","normalizeSort","descriptor","descriptors","d","sortFields","sorts","sortObject","filterExpr","expression","noEval","expressions","fieldFunctions","operatorFunctions","match","operatorMap","equals","isequalto","equalto","ne","notequals","isnotequalto","notequalto","notequal","islessthan","lessthan","less","le","islessthanorequalto","lessthanequal","isgreaterthan","greaterthan","greater","isgreaterthanorequalto","greaterthanequal","ge","notsubstringof","normalizeOperator","normalizeFilter","compareDescriptor","f1","f2","normalizeDescriptor","fieldComparer","normalizeGroup","skipItemSorting","aggregates","normalizeGroupWithoutCompare","groupValueComparer","calculateAggregate","accumulator","state","aggr","functionName","aggregate","functions","accessor","compareFilters","expr1","expr2","filters1","filters2","toArray","range","count","skip","take","select","order","inPlace","orderBy","orderByDescending","comparer","compiled","group","allData","getFilteredData","g","groupPaging","groupAllData","cachedFilteredData","hasSubgroups","itemCount","subgroupCount","groupBy","currentValue","sorted","_sortForGrouping","groupValue","_sortGroups","groups","sum","isNumber","average","max","min","val","isNaN","process","groupDescriptorsWithoutSort","total","customGroupSort","groupDescriptors","anyGroupDescriptorHasCompare","query","groupDescriptorsWithoutCompare","normalizedSort","filterCallback","flatGroups","groupDescriptor","virtual","LocalTransport","read","success","update","destroy","RemoteTransport","parameterMap","url","cache","Cache","add","submit","option","setup","error","parameters","operation","_store","clear","serializeRecords","getters","modelInstance","originalFieldNames","fieldNames","record","setters","convertRecords","convertGroup","wrapDataAccess","originalFunction","converter","wrapDataAccessBase","store","inmemory","DataReader","schema","modelBase","dataFunction","_dataAccessFunction","groupsFunction","serializeFunction","serialize","serializeGetters","fromName","from","_wrapDataAccessBase","errors","fillLastGroup","originalGroup","newGroup","currOriginal","currentNew","mergeGroups","dest","indexFunction","groupsLength","indexFn","groupIndex","itemIndex","flattenGroups","wrapGroupItems","eachGroupItems","func","replaceInRanges","ranges","observable","replaceInRange","replaceWithObservable","view","serverGrouping","viewIndex","indexOfPristineModel","indexOfModel","fieldNameFromModel","convertFilterDescriptorsField","convertDescriptorsField","_map","_prefetch","_data","_pristineData","_ranges","_view","_pristineTotal","_destroyed","_pageSize","pageSize","_page","page","_sort","_sortFields","_filter","_group","_aggregate","_total","_groupPaging","_groupsState","_shouldDetachObservableParents","transport","Transport","pushCreate","_pushCreate","pushUpdate","_pushUpdate","pushDestroy","_pushDestroy","offlineStorage","_storage","getItem","localStorage","setItem","reader","readers","_detachObservableParents","_observe","_online","serverSorting","serverPaging","serverFiltering","serverAggregates","batch","inPlaceSort","clone","online","sync","Deferred","resolve","offlineData","_isGrouped","_isServerGrouped","_isServerGroupPaged","_isGroupPaged","_push","_readData","_flatData","useRanges","getByUid","_getByUid","dataItems","_storeData","_addRange","_process","_observeView","flatView","insert","_createNewModel","_wrapInEmptyGroup","_insertModelInRange","pushInsert","rangeSpan","_getCurrentRangeSpan","pushed","autoSync","pristine","last","pristineData","_updatePristineForModel","_removeItems","itemsToRemove","removePristine","shouldRemovePristine","destroyed","found","_eachItem","_removePristineForModel","pushMove","_moveItems","moved","dataItem","hasGroups","_pushInDestroyed","removeModel","_removeModelFromRanges","created","notFetched","updated","promises","_sendSubmit","_send","when","then","_accept","_syncEnd","_change","cancelChanges","_cancelModel","_changesCanceled","_markOfflineUpdatesAsDirty","__state__","hasChanges","models","response","serverGroup","_handleCustomErrors","values","_executeOnPristineForModel","deepExtend","_eachPristineItem","_pristineForModel","_modelCanceled","_submit","status","reject","deferred","_promise","method","converted","params","_params","_queueRequest","isPrevented","_dequeueRequest","args","_readAggregates","replaceSubset","_serverGroupsTotal","_aggregateResult","itemIds","_skip","endless","j","_changeHandler","updatePristine","end","start","timestamp","_timeStamp","outerStart","outerEnd","_sortRanges","_groupsFlat","_appendToGroupsFlat","_updateOuterRangesLength","_getGroupByUid","xhr","errorThrown","_requestInProgress","_pending","_shouldWrap","_updateTotalForAction","parseInt","handler","first","_calculateAggregates","_take","currentRangeStart","_clearEmptyGroups","_queryProcess","resultData","dataToAggregate","_setView","_setFilterTotal","_mergeState","_currentRangeStart","moreItemsCount","_hasExpandedSubGroups","_findGroupedRange","parents","itemsLength","groupCount","itemsToSkip","taken","_fetchGroupItems","_fetchingGroupItems","skipped","includeParents","excludeHeader","currentItems","_expandedSubGroupItemsCount","includeCurrentItems","subGroup","temp","endSpecified","groupItemsSkip","firstItem","lastItem","expandedSubGroupItemsCount","groupItemCount","getGroupItems","floor","round","subgroups","_composeItemsFilter","findSubgroups","clearTimeout","_timeout","setTimeout","_groupItemsSuccessHandler","totalField","totalCount","_updateRangePristineData","countAdded","_currentRequestTimeStamp","_skipRequestsInProgress","indexOfCurrentGroup","currentGroup","dataLength","indexes","rangesLength","_containsSubGroup","_cloneGroup","subgroup","currentSubGroup","filterTotal","setDefaultValue","fetch","_query","next","totalPages","prev","_pageableQueryOptions","getGroupsFlat","groupsTotal","includeExpanded","_calculateGroupsTotal","itemsField","ignoreState","_groupsTotal","countGroupRange","_emptyAggregates","ceil","inRange","_findRange","lastRange","firstItemUid","enableRequestsInProgress","pageSkip","size","_processRangeData","_originalPageSkip","_originalSize","_adjustPageSkip","_groupRangeExists","_rangeExists","prefetch","skipIdx","takeIdx","startIndex","endIndex","rangeData","rangeEnd","processed","flatData","prevRangeEnd","remote","groupMapOptions","isGroupPaged","startField","endField","_mergeGroups","_getRangesMismatch","mismatch","prevGroup","eventData","_omitPrefetch","paging","sorting","filtering","_prefetchSuccessHandler","force","_multiplePrefetch","prevRange","_getPrevRange","_getNextRange","availableItemsCount","_removeModelFromRange","_updateRangesLength","mismatchFound","mismatchLength","lengthDifference","abs","rangeLength","dataSource","transportOptions","transports","schemas","logToConsole","table","fieldIndex","cells","cell","tbody","tBodies","rows","fieldCount","nodeName","innerHTML","inferTable","optgroup","firstField","secondField","parentNode","disabled","label","text","attributes","specified","inferSelect","Node","hasChildren","childrenField","childrenOptions","hasChildrenObject","_childrenOptions","_initChildren","_loaded","HierarchicalDataSource","_updateChildrenField","append","loaded","level","_childrenLoaded","load","one","_matchFilter","dataMethod","_attachBubbleHandlers","_hierarchicalFilter","_childrenLoading","isLoading","_markHierarchicalQuery","_updateHierarchicalFilter","_find","inferList","list","textChild","className","textField","urlField","spriteCssClassField","imageUrlField","elements","tagName","firstChild","attr","nodeType","nodeValue","trim","_dataSource","Buffer","viewSize","disablePrefetch","_prefetching","buffer","_reset","_syncWithDataSource","setViewSize","_recalculate","itemPresent","dataOffset","prefetchThreshold","midPageThreshold","nextMidRange","nextPageThreshold","nextFullRange","pullBackThreshold","offset","previousMidRange","previousFullRange","_goToRange","nextRange","syncDataSource","prefetchOffset","expanding","_expanding","_syncPending","_firstItemUid","BatchBuffer","batchSize","batchBuffer","endreached","prefetching","prefetched","reset","resize","jQuery","kendo$1"],"sources":["kendo.data.js"],"mappings":"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","sourcesContent":["import './kendo.core.js';\nimport './kendo.data.odata.js';\nimport './kendo.data.xml.js';\n\n/*\nThis code is copied/inspired by the internal @progress/kendo-data-query repo:\nhttps://github.com/telerik/kendo-data-query/tree/develop/src/filtering\n\n!!!\n1. If updates are to be synced consider the accentFoldingFiltering,\n   which at the moment is not present as a feature in the data-query-package.\n\n2. Double-check available operators as well.\n\n3. Make sure objs are strings -> i.e., replace (a || \"\") to (a + '')\n!!!\n\nIn future, if we consider reusing the code directly we should revise the above omissions.\n*/\n\nconst logic = {\n    \"or\": {\n        concat: (acc, fn) => a => acc(a) || fn(a),\n        identity: () => false\n    },\n    \"and\": {\n        concat: (acc, fn) => a => acc(a) && fn(a),\n        identity: () => true\n    }\n};\n\nconst operatorsMap = {\n    isnullorempty: (a) => kendo.isBlank(a) || a === '',\n    isnotnullorempty: (a) => kendo.isPresent(a) && a !== '',\n    contains: (a, b) => (a + '').indexOf(b) >= 0,\n    doesnotcontain: (a, b) => (a + '').indexOf(b) === -1,\n    doesnotendwith: (a, b) => (a + '').indexOf(b, (a || \"\").length - (b || \"\").length) < 0,\n    doesnotstartwith: (a, b) => (a + '').lastIndexOf(b, 0) === -1,\n    endswith: (a, b) => (a + '').indexOf(b, (a || \"\").length - (b || \"\").length) >= 0,\n    eq: (a, b) => a === b,\n    gt: (a, b) => a > b,\n    gte: (a, b) => a >= b,\n    isempty: (a) => a === '',\n    isnotempty: (a) => a !== '',\n    isnotnull: (a) => kendo.isPresent(a),\n    isnull: (a) => kendo.isBlank(a),\n    lt: (a, b) => a < b,\n    lte: (a, b) => a <= b,\n    neq: (a, b) => a != b,\n    startswith: (a, b) => (a + '').lastIndexOf(b, 0) === 0\n};\n\nconst dateRegExp = /^\\/Date\\((.*?)\\)\\/$/;\n\nconst convertValue = (value, ignoreCase, accentFoldingFiltering) => {\n    if (value != null && kendo.isString(value)) {\n        const date = dateRegExp.exec(value);\n        if (date) {\n            return new Date(+date[1]).getTime();\n        } else if (ignoreCase) {\n            return accentFoldingFiltering ? value.toLocaleLowerCase(accentFoldingFiltering) : value.toLowerCase();\n        }\n    } else if (value != null && kendo.isDate(value)) {\n        return value.getTime();\n    }\n    return value;\n};\n\nconst typedGetter = (prop, value, ignoreCase, accentFoldingFiltering) => {\n    if (!kendo.isPresent(value)) {\n        return prop;\n    }\n\n    let acc = prop;\n\n    if (kendo.isString(value)) {\n        const date = dateRegExp.exec(value);\n        if (date) {\n            value = new Date(+date[1]);\n        } else {\n            acc = a => {\n                const x = prop(a);\n                if (typeof x === 'string' && ignoreCase) {\n                    return accentFoldingFiltering ? x.toLocaleLowerCase(accentFoldingFiltering) : x.toLowerCase();\n                } else {\n                    return kendo.isNumeric(x) ? x + \"\" : x;\n                }\n            };\n        }\n    }\n\n    if (kendo.isDate(value)) {\n        return a => {\n            const x = acc(a);\n            return kendo.isDate(x) ? x.getTime() : x;\n        };\n    }\n    return acc;\n};\n\nconst transformFilter = ({ field, ignoreCase, value, operator = 'eq', accentFoldingFiltering }) => {\n    field = !kendo.isPresent(field) ? a => a : field;\n\n    ignoreCase = kendo.isPresent(ignoreCase) ? ignoreCase : true;\n\n    const itemProp = typedGetter(\n        kendo.isFunction(field) ? field : kendo.getter(field, true),\n        value,\n        ignoreCase,\n        accentFoldingFiltering\n    );\n\n    value = convertValue(value, ignoreCase, accentFoldingFiltering);\n\n    const op = kendo.isFunction(operator) ? operator : operatorsMap[operator];\n\n    return a => op(itemProp(a), value, ignoreCase);\n};\n\nconst isCompositeFilterDescriptor = (source) => kendo.isPresent(source.filters);\n\nconst transformCompositeFilter = (filter) => {\n    const accentFoldingFiltering = filter.accentFoldingFiltering;\n    const combiner = logic[filter.logic || 'and'];\n    return filter.filters\n        .filter(kendo.isPresent)\n        .map(x => (isCompositeFilterDescriptor(x) ? transformCompositeFilter(extendAccentFolding(x, accentFoldingFiltering)) : transformFilter(extendAccentFolding(x, accentFoldingFiltering))))\n        .reduce(combiner.concat, combiner.identity);\n};\n\nconst extendAccentFolding = (filter, accentFoldingFiltering) => (kendo.isPresent(accentFoldingFiltering) ? Object.assign(filter, { accentFoldingFiltering }) : filter);\n\nconst filterExprNoEval = function(expr) {\n    return transformCompositeFilter(expr);\n};\n\nvar __meta__ = {\n    id: \"data\",\n    name: \"Data source\",\n    category: \"framework\",\n    description: \"Powerful component for using local and remote data.Fully supports CRUD, Sorting, Paging, Filtering, Grouping, and Aggregates.\",\n    depends: [ \"core\" ],\n    features: [ {\n        id: \"data-odata\",\n        name: \"OData\",\n        description: \"Support for accessing Open Data Protocol (OData) services.\",\n        depends: [ \"data.odata\" ]\n    }, {\n        id: \"data-signalr\",\n        name: \"SignalR\",\n        description: \"Support for binding to SignalR hubs.\",\n        depends: [ \"data.signalr\" ]\n    }, {\n        id: \"data-XML\",\n        name: \"XML\",\n        description: \"Support for binding to XML.\",\n        depends: [ \"data.xml\" ]\n    }]\n};\n\n\n(function($, undefined$1) {\n    var extend = $.extend,\n        isPlainObject = $.isPlainObject,\n        isEmptyObject = $.isEmptyObject,\n        isArray = Array.isArray,\n        grep = $.grep,\n        ajax = $.ajax,\n        map,\n        each = $.each,\n        noop = $.noop,\n        kendo = window.kendo,\n        isFunction = kendo.isFunction,\n        Observable = kendo.Observable,\n        Class = kendo.Class,\n        STRING = \"string\",\n        FUNCTION = \"function\",\n        ASCENDING = \"asc\",\n        CREATE = \"create\",\n        READ = \"read\",\n        UPDATE = \"update\",\n        DESTROY = \"destroy\",\n        CHANGE = \"change\",\n        SYNC = \"sync\",\n        GET = \"get\",\n        ERROR = \"error\",\n        REQUESTSTART = \"requestStart\",\n        PROGRESS = \"progress\",\n        REQUESTEND = \"requestEnd\",\n        ITEMSLOADED = \"itemsLoaded\",\n        ITEMLOAD = \"itemLoad\",\n        crud = [CREATE, READ, UPDATE, DESTROY],\n        identity = function(o) { return o; },\n        getter = kendo.getter,\n        stringify = kendo.stringify,\n        math = Math,\n        push = [].push,\n        join = [].join,\n        pop = [].pop,\n        splice = [].splice,\n        shift = [].shift,\n        slice = [].slice,\n        unshift = [].unshift,\n        toString = {}.toString,\n        stableSort = kendo.support.stableSort,\n        dateRegExp = /^\\/Date\\((.*?)\\)\\/$/,\n        objectKeys = [];\n\n    var ObservableArray = Observable.extend({\n        init: function(array, type) {\n            var that = this;\n\n            that.type = type || ObservableObject;\n\n            Observable.fn.init.call(that);\n\n            that.length = array.length;\n\n            that.wrapAll(array, that);\n            that._loadPromises = [];\n            that._loadedNodes = [];\n        },\n\n        at: function(index) {\n            return this[index];\n        },\n\n        toJSON: function(serializeFunctions) {\n            var idx, length = this.length, value, json = new Array(length);\n\n            for (idx = 0; idx < length; idx++) {\n                value = this[idx];\n\n                if (value instanceof ObservableObject) {\n                    value = value.toJSON(serializeFunctions);\n                }\n\n                json[idx] = value;\n            }\n\n            return json;\n        },\n\n        parent: noop,\n\n        wrapAll: function(source, target) {\n            var that = this,\n                idx,\n                length,\n                parent = function() {\n                    return that;\n                };\n\n            target = target || [];\n\n            for (idx = 0, length = source.length; idx < length; idx++) {\n                target[idx] = that.wrap(source[idx], parent);\n            }\n\n            return target;\n        },\n\n        wrap: function(object, parent) {\n            var that = this,\n                observable;\n\n            if (object !== null && toString.call(object) === \"[object Object]\") {\n                observable = object instanceof that.type || object instanceof Model;\n\n                if (!observable) {\n                    object = object instanceof ObservableObject ? object.toJSON() : object;\n                    object = new that.type(object);\n                }\n\n                object.parent = parent;\n\n                object.bind(CHANGE, function(e) {\n                    var isGroup = object.hasOwnProperty(\"hasSubgroups\");\n                    that.trigger(CHANGE, {\n                        field: e.field,\n                        node: e.node,\n                        index: e.index,\n                        items: e.items || [this],\n                        action: e.node || isGroup ? (e.action || \"itemloaded\") : \"itemchange\"\n                    });\n                });\n\n                object.bind(ITEMLOAD, function(e) {\n                    that._loadPromises.push(e.promise);\n                    that._loading = true;\n\n                    e.promise.done(function() {\n                        that._loadedNodes.push(e.node);\n                        var index = that._loadPromises.indexOf(e.promise);\n                        that._loadPromises.splice(index, 1);\n\n                        if (!that._loadPromises.length) {\n                            that._loading = false;\n                            that.trigger(ITEMSLOADED, { collection: that, nodes: that._loadedNodes });\n                            that._loadedNodes = [];\n                        }\n                    });\n                });\n            }\n\n            return object;\n        },\n\n        loading: function() {\n            return this._loading;\n        },\n\n        push: function() {\n            var index = this.length,\n                items = this.wrapAll(arguments),\n                result;\n\n            result = push.apply(this, items);\n\n            if (!this.omitChangeEvent) {\n                this.trigger(CHANGE, {\n                    action: \"add\",\n                    index: index,\n                    items: items\n                });\n            }\n\n            return result;\n        },\n\n        slice: slice,\n\n        sort: [].sort,\n\n        join: join,\n\n        pop: function() {\n            var length = this.length, result = pop.apply(this);\n\n            if (length) {\n                this.trigger(CHANGE, {\n                    action: \"remove\",\n                    index: length - 1,\n                    items: [result]\n                });\n            }\n\n            return result;\n        },\n\n        splice: function(index, howMany, item) {\n            var items = this.wrapAll(slice.call(arguments, 2)),\n                result, i, len;\n\n            result = splice.apply(this, [index, howMany].concat(items));\n\n            if (result.length) {\n                if (!this.omitChangeEvent) {\n                    this.trigger(CHANGE, {\n                        action: \"remove\",\n                        index: index,\n                        items: this.omitCache && this.omitCache.length ? result.concat(this.omitCache) : result\n                    });\n                    this.omitCache = [];\n                }\n\n                for (i = 0, len = result.length; i < len; i++) {\n                    if (result[i] && result[i].children) {\n                        result[i].unbind(CHANGE);\n                    }\n                }\n            }\n\n            if (item) {\n                if (!this.omitChangeEvent) {\n                    this.trigger(CHANGE, {\n                        action: \"add\",\n                        index: index,\n                        items: items\n                    });\n                }\n            }\n            return result;\n        },\n\n        shift: function() {\n            var length = this.length, result = shift.apply(this);\n\n            if (length) {\n                this.trigger(CHANGE, {\n                    action: \"remove\",\n                    index: 0,\n                    items: [result]\n                });\n            }\n\n            return result;\n        },\n\n        unshift: function() {\n            var items = this.wrapAll(arguments),\n                result;\n\n            result = unshift.apply(this, items);\n\n            this.trigger(CHANGE, {\n                action: \"add\",\n                index: 0,\n                items: items\n            });\n\n            return result;\n        },\n\n        indexOf: function(item) {\n            var that = this,\n                idx,\n                length;\n\n            for (idx = 0, length = that.length; idx < length; idx++) {\n                if (that[idx] === item) {\n                    return idx;\n                }\n            }\n            return -1;\n        },\n\n        forEach: function(callback, thisArg) {\n            var idx = 0;\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                callback.call(context, this[idx], idx, this);\n            }\n        },\n\n        map: function(callback, thisArg) {\n            var idx = 0;\n            var result = [];\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                result[idx] = callback.call(context, this[idx], idx, this);\n            }\n\n            return result;\n        },\n\n        reduce: function(callback) {\n            var idx = 0,\n                result,\n                length = this.length;\n\n            if (arguments.length == 2) {\n                result = arguments[1];\n            } else if (idx < length) {\n                result = this[idx++];\n            }\n\n            for (; idx < length; idx++) {\n                result = callback(result, this[idx], idx, this);\n            }\n\n            return result;\n        },\n\n        reduceRight: function(callback) {\n            var idx = this.length - 1,\n                result;\n\n            if (arguments.length == 2) {\n                result = arguments[1];\n            } else if (idx > 0) {\n                result = this[idx--];\n            }\n\n            for (; idx >= 0; idx--) {\n                result = callback(result, this[idx], idx, this);\n            }\n\n            return result;\n        },\n\n        filter: function(callback, thisArg) {\n            var idx = 0;\n            var result = [];\n            var item;\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                item = this[idx];\n                if (callback.call(context, item, idx, this)) {\n                    result[result.length] = item;\n                }\n            }\n\n            return result;\n        },\n\n        find: function(callback, thisArg) {\n            var idx = 0;\n            var item;\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                item = this[idx];\n                if (callback.call(context, item, idx, this)) {\n                    return item;\n                }\n            }\n        },\n\n        every: function(callback, thisArg) {\n            var idx = 0;\n            var item;\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                item = this[idx];\n                if (!callback.call(context, item, idx, this)) {\n                    return false;\n                }\n            }\n\n            return true;\n        },\n\n        some: function(callback, thisArg) {\n            var idx = 0;\n            var item;\n            var length = this.length;\n            var context = thisArg || window;\n\n            for (; idx < length; idx++) {\n                item = this[idx];\n                if (callback.call(context, item, idx, this)) {\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        // non-standard collection methods\n        remove: function(item) {\n            var idx = this.indexOf(item);\n\n            if (idx !== -1) {\n                this.splice(idx, 1);\n            }\n        },\n\n        empty: function() {\n            this.splice(0, this.length);\n        }\n    });\n\n    // Polyfill for Symbol.iterator\n    if (typeof Symbol !== \"undefined\" && Symbol.iterator && !ObservableArray.prototype[Symbol.iterator]) {\n        ObservableArray.prototype[Symbol.iterator] = [][Symbol.iterator];\n    }\n\n    var LazyObservableArray = ObservableArray.extend({\n        init: function(data, type, events) {\n            var parentFn = function() { return this; };\n\n            Observable.fn.init.call(this);\n\n            this.type = type || ObservableObject;\n\n            if (events) {\n                this._events = events;\n            }\n\n            for (var idx = 0; idx < data.length; idx++) {\n                this[idx] = data[idx];\n            }\n\n            this.length = idx;\n            this._parent = parentFn.bind(this);\n        },\n        at: function(index) {\n            var item = this[index];\n\n            if (!(item instanceof this.type)) {\n                item = this[index] = this.wrap(item, this._parent);\n            } else {\n                item.parent = this._parent;\n            }\n\n            return item;\n        }\n    });\n\n    function eventHandler(context, type, field, prefix) {\n        return function(e) {\n            var event = {}, key;\n\n            for (key in e) {\n                event[key] = e[key];\n            }\n\n            if (prefix) {\n                event.field = field + \".\" + e.field;\n            } else {\n                event.field = field;\n            }\n\n            if (type == CHANGE && context._notifyChange) {\n                context._notifyChange(event);\n            }\n\n            context.trigger(type, event);\n        };\n    }\n\n    function isPrimitiveType(value) {\n        return (typeof value === \"object\" && Object.getPrototypeOf(value) === Object.getPrototypeOf({}))\n                || Object.getPrototypeOf(value) === Object.getPrototypeOf(new Date())\n                || typeof value !== \"object\";\n      }\n\n    function ownKeys(value, ignoreObjectKeys) {\n        var props = [];\n        var protoKeys = [];\n        var keys, filteredObjectKeys;\n\n        value = value || {};\n\n        if (!isPrimitiveType(value)) {\n            protoKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(value)).filter(f => f.indexOf(\"__\") !== 0);\n        }\n\n        keys = Object.getOwnPropertyNames(value).concat(protoKeys);\n\n        filteredObjectKeys = objectKeys.filter(function(key) {\n            return keys.indexOf(key) < 0;\n        });\n\n        while (value) {\n            Object.getOwnPropertyNames(value).forEach(function(prop) {\n                if (props.indexOf(prop) === -1 && (!ignoreObjectKeys || filteredObjectKeys.indexOf(prop) < 0)) {\n                    props.push(prop);\n                }\n            });\n            value = Object.getPrototypeOf(value);\n        }\n\n        return props;\n    }\n\n    objectKeys = ownKeys({}, false);\n\n    var ObservableObject = Observable.extend({\n        init: function(value) {\n            var that = this,\n                member,\n                keys = ownKeys(value, true),\n                parent = function() {\n                    return that;\n                };\n\n            Observable.fn.init.call(this);\n\n            this._handlers = {};\n\n            keys.forEach(function(field) {\n                member = value[field];\n\n                if (typeof member === \"object\" && member && !member.getTime && field.charAt(0) != \"_\") {\n                    member = that.wrap(member, field, parent);\n                }\n\n                that[field] = member;\n            });\n\n            that.uid = kendo.guid();\n        },\n\n        shouldSerialize: function(field, serializeFunctions) {\n            return this.hasOwnProperty(field) && field !== \"_handlers\" && field !== \"_events\" && ((serializeFunctions && serializeFunctions[field]) || typeof this[field] !== FUNCTION) && field !== \"uid\";\n        },\n\n        forEach: function(f) {\n            for (var i in this) {\n                if (this.shouldSerialize(i)) {\n                    f(this[i], i);\n                }\n            }\n        },\n\n        toJSON: function(serializeFunctions) {\n            var result = {}, value, field;\n\n            for (field in this) {\n                if (this.shouldSerialize(field, serializeFunctions)) {\n                    value = this[field];\n\n                    if (value instanceof ObservableObject || value instanceof ObservableArray) {\n                        value = value.toJSON(serializeFunctions);\n                    }\n\n                    result[field] = value;\n                }\n            }\n\n            return result;\n        },\n\n        get: function(field) {\n            var that = this, result;\n\n            that.trigger(GET, { field: field });\n\n            if (field === \"this\") {\n                result = that;\n            } else {\n                result = kendo.getter(field, true)(that);\n            }\n\n            return result;\n        },\n\n        _set: function(field, value) {\n            var that = this;\n            var composite = field.indexOf(\".\") >= 0;\n\n            if (composite) {\n                var paths = field.split(\".\"),\n                    path = \"\";\n\n                while (paths.length > 1) {\n                    path += paths.shift();\n                    var obj = kendo.getter(path, true)(that);\n                    if (obj instanceof ObservableObject) {\n                        obj.set(paths.join(\".\"), value);\n                        return composite;\n                    }\n                    path += \".\";\n                }\n            }\n\n            kendo.setter(field)(that, value);\n\n            return composite;\n        },\n\n        set: function(field, value) {\n            var that = this,\n                isSetPrevented = false,\n                composite = field.indexOf(\".\") >= 0,\n                current = kendo.getter(field, true)(that);\n\n            if (current !== value) {\n                if (current instanceof Observable && this._handlers[field]) {\n                    if (this._handlers[field].get) {\n                       current.unbind(GET, this._handlers[field].get);\n                    }\n                    current.unbind(CHANGE, this._handlers[field].change);\n                }\n\n                isSetPrevented = that.trigger(\"set\", { field: field, value: value });\n\n                if (!isSetPrevented) {\n                    if (!composite) {\n                        value = that.wrap(value, field, function() { return that; });\n                    }\n                    if (!that._set(field, value) || field.indexOf(\"(\") >= 0 || field.indexOf(\"[\") >= 0) {\n                        that.trigger(CHANGE, { field: field });\n                    }\n                }\n            }\n\n            return isSetPrevented;\n        },\n\n        parent: noop,\n\n        wrap: function(object, field, parent) {\n            var that = this;\n            var get;\n            var change;\n            var type = toString.call(object);\n\n            if (object != null && (type === \"[object Object]\" || type === \"[object Array]\")) {\n                var isObservableArray = object instanceof ObservableArray;\n                var isDataSource = object instanceof DataSource;\n\n                if (type === \"[object Object]\" && !isDataSource && !isObservableArray) {\n                    if (!(object instanceof ObservableObject)) {\n                        object = new ObservableObject(object);\n                    }\n\n                    get = eventHandler(that, GET, field, true);\n                    object.bind(GET, get);\n                    change = eventHandler(that, CHANGE, field, true);\n                    object.bind(CHANGE, change);\n\n                    that._handlers[field] = { get: get, change: change };\n                } else if (type === \"[object Array]\" || isObservableArray || isDataSource) {\n                    if (!isObservableArray && !isDataSource) {\n                        object = new ObservableArray(object);\n                    }\n\n                    change = eventHandler(that, CHANGE, field, false);\n\n                    object.bind(CHANGE, change);\n\n                    that._handlers[field] = { change: change };\n                }\n\n                object.parent = parent;\n            }\n\n            return object;\n        }\n    });\n\n    function equal(x, y) {\n        if (x === y) {\n            return true;\n        }\n\n        var xtype = kendo.type(x), ytype = kendo.type(y), field;\n\n        if (xtype !== ytype) {\n            return false;\n        }\n\n        if (xtype === \"date\") {\n            return x.getTime() === y.getTime();\n        }\n\n        if (xtype !== \"object\" && xtype !== \"array\") {\n            return false;\n        }\n\n        for (field in x) {\n            if (!equal(x[field], y[field])) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    var parsers = {\n        \"number\": function(value) {\n            if (typeof value === STRING && value.toLowerCase() === \"null\") {\n                return null;\n            }\n            return kendo.parseFloat(value);\n        },\n\n        \"date\": function(value) {\n            if (typeof value === STRING && value.toLowerCase() === \"null\") {\n                return null;\n            }\n            return kendo.parseDate(value);\n        },\n\n        \"boolean\": function(value) {\n            if (typeof value === STRING) {\n                if (value.toLowerCase() === \"null\") {\n                    return null;\n                } else {\n                    return value.toLowerCase() === \"true\";\n                }\n            }\n            return value != null ? !!value : value;\n        },\n\n        \"string\": function(value) {\n            if (typeof value === STRING && value.toLowerCase() === \"null\") {\n                return null;\n            }\n            return value != null ? (value + \"\") : value;\n        },\n\n        \"default\": function(value) {\n            return value;\n        }\n    };\n\n    var defaultValues = {\n        \"string\": \"\",\n        \"number\": 0,\n        \"date\": new Date(),\n        \"boolean\": false,\n        \"default\": \"\"\n    };\n\n    function getFieldByName(obj, name) {\n        var field,\n            fieldName;\n\n        for (fieldName in obj) {\n            field = obj[fieldName];\n            if (isPlainObject(field) && field.field && field.field === name) {\n                return field;\n            } else if (field === name) {\n                return field;\n            }\n        }\n        return null;\n    }\n\n    var Model = ObservableObject.extend({\n        init: function(data) {\n            var that = this;\n\n            if (!data || $.isEmptyObject(data)) {\n                data = $.extend({}, that.defaults, data);\n\n                if (that._initializers) {\n                    for (var idx = 0; idx < that._initializers.length; idx++) {\n                         var name = that._initializers[idx];\n                         data[name] = that.defaults[name]();\n                    }\n                }\n            }\n\n            ObservableObject.fn.init.call(that, data);\n\n            that.dirty = false;\n            that.dirtyFields = {};\n\n            if (that.idField) {\n                that.id = that.get(that.idField);\n\n                if (that.id === undefined$1) {\n                    that.id = that._defaultId;\n                }\n            }\n        },\n\n        shouldSerialize: function(field) {\n            return ObservableObject.fn.shouldSerialize.call(this, field) &&\n                field !== \"uid\" && !(this.idField !== \"id\" && field === \"id\") &&\n                field !== \"dirty\" && field !== \"dirtyFields\" && field !== \"_accessors\";\n        },\n\n        _parse: function(field, value) {\n            var that = this,\n                fieldName = field,\n                fields = (that.fields || {}),\n                parse;\n\n            field = fields[field];\n            if (!field) {\n                field = getFieldByName(fields, fieldName);\n            }\n            if (field) {\n                parse = field.parse;\n                if (!parse && field.type) {\n                    parse = parsers[field.type.toLowerCase()];\n                }\n            }\n\n            return parse ? parse(value) : value;\n        },\n\n        _notifyChange: function(e) {\n            var action = e.action;\n\n            if (action == \"add\" || action == \"remove\") {\n                this.dirty = true;\n                this.dirtyFields[e.field] = true;\n            }\n        },\n\n        editable: function(field) {\n            field = (this.fields || {})[field];\n            return field ? field.editable !== false : true;\n        },\n\n        set: function(field, value) {\n            var that = this;\n            var dirty = that.dirty;\n\n            if (that.editable(field)) {\n                value = that._parse(field, value);\n\n                if (!equal(value, that.get(field))) {\n                    that.dirty = true;\n                    that.dirtyFields[field] = true;\n\n                    if (ObservableObject.fn.set.call(that, field, value) && !dirty) {\n                        that.dirty = dirty;\n\n                        if (!that.dirty) {\n                            that.dirtyFields[field] = false;\n                        }\n                    }\n                } else {\n                    that.trigger(\"equalSet\", { field: field, value: value });\n                }\n            }\n        },\n\n        accept: function(data) {\n            var that = this,\n                parent = function() { return that; },\n                field;\n\n            for (field in data) {\n                var value = data[field];\n\n                if (field.charAt(0) != \"_\") {\n                    value = that.wrap(data[field], field, parent);\n                }\n\n                that._set(field, value);\n            }\n\n            if (that.idField) {\n                that.id = that.get(that.idField);\n            }\n\n            that.dirty = false;\n            that.dirtyFields = {};\n        },\n\n        isNew: function() {\n            return this.id === this._defaultId;\n        }\n    });\n\n    Model.define = function(base, options) {\n        if (options === undefined$1) {\n            options = base;\n            base = Model;\n        }\n\n        var model,\n            proto = extend({ defaults: {} }, options),\n            name,\n            field,\n            type,\n            value,\n            idx,\n            length,\n            fields = {},\n            originalName,\n            id = proto.id,\n            functionFields = [];\n\n        if (id) {\n            proto.idField = id;\n        }\n\n        if (proto.id) {\n            delete proto.id;\n        }\n\n        if (id) {\n            proto.defaults[id] = proto._defaultId = \"\";\n        }\n\n        if (toString.call(proto.fields) === \"[object Array]\") {\n            for (idx = 0, length = proto.fields.length; idx < length; idx++) {\n                field = proto.fields[idx];\n                if (typeof field === STRING) {\n                    fields[field] = {};\n                } else if (field.field) {\n                    fields[field.field] = field;\n                }\n            }\n            proto.fields = fields;\n        }\n\n        for (name in proto.fields) {\n            field = proto.fields[name];\n            type = field.type || \"default\";\n            value = null;\n            originalName = name;\n\n            name = typeof (field.field) === STRING ? field.field : name;\n\n            if (!field.nullable) {\n                value = proto.defaults[originalName !== name ? originalName : name] = field.defaultValue !== undefined$1 ? field.defaultValue : defaultValues[type.toLowerCase()];\n\n                if (typeof value === \"function\") {\n                    functionFields.push(name);\n                }\n            }\n\n            if (options.id === name) {\n                proto._defaultId = value;\n            }\n\n            proto.defaults[originalName !== name ? originalName : name] = value;\n\n            if ($.isPlainObject(field)) {\n                field.parse = field.parse || parsers[type];\n            } else {\n                field = {\n                    parse: parsers[type]\n                };\n            }\n        }\n\n        if (functionFields.length > 0) {\n            proto._initializers = functionFields;\n        }\n\n        model = base.extend(proto);\n        model.define = function(options) {\n            return Model.define(model, options);\n        };\n\n        if (proto.fields) {\n            model.fields = proto.fields;\n            model.idField = proto.idField;\n        }\n\n        return model;\n    };\n\n    var Comparer = {\n        selector: function(field) {\n            return isFunction(field) ? field : getter(field);\n        },\n\n        compare: function(field) {\n            var selector = this.selector(field);\n            return function(a, b) {\n                a = selector(a);\n                b = selector(b);\n\n                if (a == null && b == null) {\n                    return 0;\n                }\n\n                if (a == null) {\n                    return -1;\n                }\n\n                if (b == null) {\n                    return 1;\n                }\n\n                if (a.localeCompare) {\n                    return a.localeCompare(b);\n                }\n\n                return a > b ? 1 : (a < b ? -1 : 0);\n            };\n        },\n\n        create: function(sort) {\n            var compare = sort.compare || this.compare(sort.field);\n\n            if (sort.dir == \"desc\") {\n                return function(a, b) {\n                    return compare(b, a, true);\n                };\n            }\n\n            return compare;\n        },\n\n        combine: function(comparers) {\n            return function(a, b) {\n                var result = comparers[0](a, b),\n                    idx,\n                    length;\n\n                for (idx = 1, length = comparers.length; idx < length; idx ++) {\n                    result = result || comparers[idx](a, b);\n                }\n\n                return result;\n            };\n        }\n    };\n\n    var StableComparer = extend({}, Comparer, {\n        asc: function(field) {\n            var selector = this.selector(field);\n            return function(a, b) {\n                var valueA = selector(a);\n                var valueB = selector(b);\n\n                if (valueA && valueA.getTime && valueB && valueB.getTime) {\n                    valueA = valueA.getTime();\n                    valueB = valueB.getTime();\n                }\n\n                if (valueA === valueB) {\n                    return a.__position - b.__position;\n                }\n\n                if (valueA == null) {\n                    return -1;\n                }\n\n                if (valueB == null) {\n                    return 1;\n                }\n\n                if (valueA.localeCompare) {\n                    return valueA.localeCompare(valueB);\n                }\n\n                return valueA > valueB ? 1 : -1;\n            };\n        },\n\n        desc: function(field) {\n            var selector = this.selector(field);\n            return function(a, b) {\n                var valueA = selector(a);\n                var valueB = selector(b);\n\n                if (valueA && valueA.getTime && valueB && valueB.getTime) {\n                    valueA = valueA.getTime();\n                    valueB = valueB.getTime();\n                }\n\n                if (valueA === valueB) {\n                    return a.__position - b.__position;\n                }\n\n                if (valueA == null) {\n                    return 1;\n                }\n\n                if (valueB == null) {\n                    return -1;\n                }\n\n                if (valueB.localeCompare) {\n                    return valueB.localeCompare(valueA);\n                }\n\n                return valueA < valueB ? 1 : -1;\n            };\n        },\n        create: function(sort) {\n           return this[sort.dir](sort.field);\n        }\n    });\n\n    map = function(array, callback) {\n        var idx, length = array.length, result = new Array(length);\n\n        for (idx = 0; idx < length; idx++) {\n            result[idx] = callback(array[idx], idx, array);\n        }\n\n        return result;\n    };\n\n    var operators = (function() {\n\n        function quote(str) {\n            if (typeof str == \"string\") {\n                str = str.replace(/[\\r\\n]+/g, \"\");\n            }\n            return JSON.stringify(str);\n        }\n\n        function textOp(impl) {\n            return function(a, b, ignore, accentFoldingFiltering) {\n                b += \"\";\n                if (ignore) {\n                    a = \"(\" + a + \" + '').toString()\" + ((accentFoldingFiltering) ? \".toLocaleLowerCase('\" + accentFoldingFiltering + \"')\" : \".toLowerCase()\");\n                    b = ((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase());\n                }\n                return impl(a, quote(b), ignore);\n            };\n        }\n\n        function operator(op, a, b, ignore, accentFoldingFiltering) {\n            if (b != null) {\n                if (typeof b === STRING) {\n                    var date = dateRegExp.exec(b);\n                    if (date) {\n                        b = new Date(+date[1]);\n                    } else if (ignore) {\n                        b = quote(((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase()));\n                        a = \"((\" + a + \" || '')+'')\" + ((accentFoldingFiltering) ? \".toLocaleLowerCase('\" + accentFoldingFiltering + \"')\" : \".toLowerCase()\");\n                    } else {\n                        b = quote(b);\n                    }\n                }\n\n                if (b.getTime) {\n                    //b looks like a Date\n                    a = \"(\" + a + \"&&\" + a + \".getTime?\" + a + \".getTime():\" + a + \")\";\n                    b = b.getTime();\n                }\n            }\n\n            return a + \" \" + op + \" \" + b;\n        }\n\n        function getMatchRegexp(pattern) {\n            // take a pattern, as supported by Excel match filter, and\n            // convert it to the equivalent JS regular expression.\n            // Excel patterns support:\n            //\n            //   * - match any sequence of characters\n            //   ? - match a single character\n            //\n            // to match a literal * or ?, they must be prefixed by a tilde (~)\n            for (var rx = \"/^\", esc = false, i = 0; i < pattern.length; ++i) {\n                var ch = pattern.charAt(i);\n                if (esc) {\n                    rx += \"\\\\\" + ch;\n                } else if (ch == \"~\") {\n                    esc = true;\n                    continue;\n                } else if (ch == \"*\") {\n                    rx += \".*\";\n                } else if (ch == \"?\") {\n                    rx += \".\";\n                } else if (\".+^$()[]{}|\\\\/\\n\\r\\u2028\\u2029\\xA0\".indexOf(ch) >= 0) {\n                    rx += \"\\\\\" + ch;\n                } else {\n                    rx += ch;\n                }\n                esc = false;\n            }\n            return rx + \"$/\";\n        }\n\n        return {\n            quote: function(value) {\n                if (value && value.getTime) {\n                    return \"new Date(\" + value.getTime() + \")\";\n                }\n                return quote(value);\n            },\n            eq: function(a, b, ignore, accentFoldingFiltering) {\n                return operator(\"==\", a, b, ignore, accentFoldingFiltering);\n            },\n            neq: function(a, b, ignore, accentFoldingFiltering) {\n                return operator(\"!=\", a, b, ignore, accentFoldingFiltering);\n            },\n            gt: function(a, b, ignore) {\n                return operator(\">\", a, b, ignore);\n            },\n            gte: function(a, b, ignore) {\n                return operator(\">=\", a, b, ignore);\n            },\n            lt: function(a, b, ignore) {\n                return operator(\"<\", a, b, ignore);\n            },\n            lte: function(a, b, ignore) {\n                return operator(\"<=\", a, b, ignore);\n            },\n            startswith: textOp(function(a, b) {\n                return a + \".lastIndexOf(\" + b + \", 0) == 0\";\n            }),\n            doesnotstartwith: textOp(function(a, b) {\n                return a + \".lastIndexOf(\" + b + \", 0) == -1\";\n            }),\n            endswith: textOp(function(a, b) {\n                var n = b ? b.length - 2 : 0;\n                return a + \".indexOf(\" + b + \", \" + a + \".length - \" + n + \") >= 0\";\n            }),\n            doesnotendwith: textOp(function(a, b) {\n                var n = b ? b.length - 2 : 0;\n                return a + \".indexOf(\" + b + \", \" + a + \".length - \" + n + \") < 0\";\n            }),\n            contains: textOp(function(a, b) {\n                return a + \".indexOf(\" + b + \") >= 0\";\n            }),\n            doesnotcontain: textOp(function(a, b) {\n                return a + \".indexOf(\" + b + \") == -1\";\n            }),\n            matches: textOp(function(a, b) {\n                b = b.substring(1, b.length - 1);\n                return getMatchRegexp(b) + \".test(\" + a + \")\";\n            }),\n            doesnotmatch: textOp(function(a, b) {\n                b = b.substring(1, b.length - 1);\n                return \"!\" + getMatchRegexp(b) + \".test(\" + a + \")\";\n            }),\n            isempty: function(a) {\n                return a + \" === ''\";\n            },\n            isnotempty: function(a) {\n                return a + \" !== ''\";\n            },\n            isnull: function(a) {\n                return \"(\" + a + \" == null)\";\n            },\n            isnotnull: function(a) {\n                return \"(\" + a + \" != null)\";\n            },\n            isnullorempty: function(a) {\n                return \"(\" + a + \" === null) || (\" + a + \" === '')\";\n            },\n            isnotnullorempty: function(a) {\n                return \"(\" + a + \" !== null) && (\" + a + \" !== '')\";\n            }\n        };\n    })();\n\n    function Query(data) {\n        this.data = data || [];\n    }\n\n    // Continue to support legacy unsafe-eval for the spreadsheet\n    Query.filterExpr = function(expression, options = { noEval: false }) {\n        if (options.noEval) {\n            // using no-eval for most cases\n            return filterExprNoEval(expression);\n        }\n\n        var expressions = [],\n            logic = { and: \" && \", or: \" || \" },\n            idx,\n            length,\n            filter,\n            expr,\n            fieldFunctions = [],\n            operatorFunctions = [],\n            field,\n            operator,\n            filters = expression.filters;\n\n        for (idx = 0, length = filters.length; idx < length; idx++) {\n            filter = filters[idx];\n            field = filter.field;\n            operator = filter.operator;\n\n            if (filter.filters) {\n                expr = Query.filterExpr(filter);\n                //Nested function fields or operators - update their index e.g. __o[0] -> __o[1]\n                filter = expr.expression\n                .replace(/__o\\[(\\d+)\\]/g, function(match, index) {\n                    index = +index;\n                    return \"__o[\" + (operatorFunctions.length + index) + \"]\";\n                })\n                .replace(/__f\\[(\\d+)\\]/g, function(match, index) {\n                    index = +index;\n                    return \"__f[\" + (fieldFunctions.length + index) + \"]\";\n                });\n\n                operatorFunctions.push.apply(operatorFunctions, expr.operators);\n                fieldFunctions.push.apply(fieldFunctions, expr.fields);\n            } else {\n                if (typeof field === FUNCTION) {\n                    expr = \"__f[\" + fieldFunctions.length + \"](d)\";\n                    fieldFunctions.push(field);\n                } else {\n                    expr = kendo.expr(field);\n                }\n\n                if (typeof operator === FUNCTION) {\n                    filter = \"__o[\" + operatorFunctions.length + \"](\" + expr + \", \" + operators.quote(filter.value) + \")\";\n                    operatorFunctions.push(operator);\n                } else {\n                    filter = operators[(operator || \"eq\").toLowerCase()](expr, filter.value, filter.ignoreCase !== undefined$1 ? filter.ignoreCase : true, expression.accentFoldingFiltering);\n                }\n            }\n\n            expressions.push(filter);\n        }\n\n        return { expression: \"(\" + expressions.join(logic[expression.logic]) + \")\", fields: fieldFunctions, operators: operatorFunctions };\n    };\n\n    function normalizeSort(field, dir) {\n        if (field) {\n            var descriptor = typeof field === STRING ? { field: field, dir: dir } : field,\n            descriptors = isArray(descriptor) ? descriptor : (descriptor !== undefined$1 ? [descriptor] : []);\n\n            return grep(descriptors, function(d) { return !!d.dir; });\n        }\n    }\n\n    function sortFields(sorts, dir) {\n        var sortObject = {};\n\n        if (sorts) {\n            var descriptor = typeof sorts === STRING ? { field: sorts, dir: dir } : sorts,\n            descriptors = isArray(descriptor) ? descriptor : (descriptor !== undefined$1 ? [descriptor] : []);\n\n            for (var i = 0; i < descriptors.length; i++) {\n                sortObject[descriptors[i].field] = { dir: descriptors[i].dir, index: i + 1 };\n            }\n        }\n\n        return sortObject;\n    }\n\n    var operatorMap = {\n        \"==\": \"eq\",\n        equals: \"eq\",\n        isequalto: \"eq\",\n        equalto: \"eq\",\n        equal: \"eq\",\n        \"!=\": \"neq\",\n        ne: \"neq\",\n        notequals: \"neq\",\n        isnotequalto: \"neq\",\n        notequalto: \"neq\",\n        notequal: \"neq\",\n        \"<\": \"lt\",\n        islessthan: \"lt\",\n        lessthan: \"lt\",\n        less: \"lt\",\n        \"<=\": \"lte\",\n        le: \"lte\",\n        islessthanorequalto: \"lte\",\n        lessthanequal: \"lte\",\n        \">\": \"gt\",\n        isgreaterthan: \"gt\",\n        greaterthan: \"gt\",\n        greater: \"gt\",\n        \">=\": \"gte\",\n        isgreaterthanorequalto: \"gte\",\n        greaterthanequal: \"gte\",\n        ge: \"gte\",\n        notsubstringof: \"doesnotcontain\",\n        isnull: \"isnull\",\n        isempty: \"isempty\",\n        isnotempty: \"isnotempty\"\n    };\n\n    function normalizeOperator(expression) {\n        var idx,\n        length,\n        filter,\n        operator,\n        filters = expression.filters;\n\n        if (filters) {\n            for (idx = 0, length = filters.length; idx < length; idx++) {\n                filter = filters[idx];\n                operator = filter.operator;\n\n                if (operator && typeof operator === STRING) {\n                    filter.operator = operatorMap[operator.toLowerCase()] || operator;\n                }\n\n                normalizeOperator(filter);\n            }\n        }\n    }\n\n    function normalizeFilter(expression) {\n        if (expression && !isEmptyObject(expression)) {\n            if (isArray(expression) || !expression.filters) {\n                expression = {\n                    logic: \"and\",\n                    filters: isArray(expression) ? expression : [expression]\n                };\n            }\n\n            normalizeOperator(expression);\n\n            return expression;\n        }\n    }\n\n    Query.normalizeFilter = normalizeFilter;\n\n    function compareDescriptor(f1, f2) {\n        if (f1.logic || f2.logic) {\n            return false;\n        }\n\n        return f1.field === f2.field && f1.value === f2.value && f1.operator === f2.operator;\n    }\n\n    function normalizeDescriptor(filter) {\n        filter = filter || {};\n\n        if (isEmptyObject(filter)) {\n            return { logic: \"and\", filters: [] };\n        }\n\n        return normalizeFilter(filter);\n    }\n\n    function fieldComparer(a, b) {\n        if (b.logic || (a.field > b.field)) {\n            return 1;\n        } else if (a.field < b.field) {\n            return -1;\n        } else {\n            return 0;\n        }\n    }\n\n    function compareFilters(expr1, expr2) {\n        expr1 = normalizeDescriptor(expr1);\n        expr2 = normalizeDescriptor(expr2);\n\n        if (expr1.logic !== expr2.logic) {\n            return false;\n        }\n\n        var f1, f2;\n        var filters1 = (expr1.filters || []).slice();\n        var filters2 = (expr2.filters || []).slice();\n\n        if (filters1.length !== filters2.length) {\n            return false;\n        }\n\n        filters1 = filters1.sort(fieldComparer);\n        filters2 = filters2.sort(fieldComparer);\n\n        for (var idx = 0; idx < filters1.length; idx++) {\n            f1 = filters1[idx];\n            f2 = filters2[idx];\n\n            if (f1.logic && f2.logic) {\n                if (!compareFilters(f1, f2)) {\n                    return false;\n                }\n            } else if (!compareDescriptor(f1, f2)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    Query.compareFilters = compareFilters;\n\n    function normalizeAggregate(expressions) {\n        return isArray(expressions) ? expressions : [expressions];\n    }\n\n    function normalizeGroup(field, dir, compare, skipItemSorting) {\n        var descriptor = typeof field === STRING ? { field: field, dir: dir, compare: compare, skipItemSorting: skipItemSorting } : field,\n        descriptors = isArray(descriptor) ? descriptor : (descriptor !== undefined$1 ? [descriptor] : []);\n\n        return map(descriptors, function(d) {\n            return {\n                field: d.field,\n                dir: d.dir || \"asc\",\n                aggregates: d.aggregates,\n                compare: d.compare,\n                skipItemSorting: d.skipItemSorting\n            };\n        });\n    }\n\n    function normalizeGroupWithoutCompare(field, dir, compare) {\n        var descriptors = normalizeGroup(field, dir, compare);\n\n        for (var i = 0; i < descriptors.length; i++) {\n            delete descriptors[i].compare;\n        }\n\n        return descriptors;\n    }\n\n    function anyGroupDescriptorHasCompare(groupDescriptors) {\n        var descriptors = isArray(groupDescriptors) ? groupDescriptors : [groupDescriptors];\n\n        for (var i = 0; i < descriptors.length; i++) {\n            if (descriptors[i] && isFunction(descriptors[i].compare)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    Query.prototype = {\n        toArray: function() {\n            return this.data;\n        },\n        range: function(index, count) {\n            return new Query(this.data.slice(index, index + count));\n        },\n        skip: function(count) {\n            return new Query(this.data.slice(count));\n        },\n        take: function(count) {\n            return new Query(this.data.slice(0, count));\n        },\n        select: function(selector) {\n            return new Query(map(this.data, selector));\n        },\n        order: function(selector, dir, inPlace) {\n            var sort = { dir: dir };\n\n            if (selector) {\n                if (selector.compare) {\n                    sort.compare = selector.compare;\n                } else {\n                    sort.field = selector;\n                }\n            }\n\n            if (inPlace) {\n                return new Query(this.data.sort(Comparer.create(sort)));\n            }\n\n            return new Query(this.data.slice(0).sort(Comparer.create(sort)));\n        },\n        orderBy: function(selector, inPlace) {\n            return this.order(selector, \"asc\", inPlace);\n        },\n        orderByDescending: function(selector, inPlace) {\n            return this.order(selector, \"desc\", inPlace);\n        },\n        sort: function(field, dir, comparer, inPlace) {\n            var idx,\n            length,\n            descriptors = normalizeSort(field, dir),\n            comparers = [];\n\n            comparer = comparer || Comparer;\n\n            if (descriptors.length) {\n                for (idx = 0, length = descriptors.length; idx < length; idx++) {\n                    comparers.push(comparer.create(descriptors[idx]));\n                }\n\n                return this.orderBy({ compare: comparer.combine(comparers) }, inPlace);\n            }\n\n            return this;\n        },\n\n        filter: function(expressions) {\n            var compiled,\n            data = this.data,\n            result = [];\n\n            expressions = normalizeFilter(expressions);\n\n            if (!expressions || expressions.filters.length === 0) {\n                return this;\n            }\n\n            compiled = Query.filterExpr(expressions, { noEval: true });\n\n            result = data.filter(compiled);\n            return new Query(result);\n        },\n\n        group: function(descriptors, allData, options) {\n            descriptors = normalizeGroup(descriptors || []);\n            allData = allData || this.data;\n\n            var that = this,\n            result = new Query(that.data),\n            descriptor;\n\n            var getFilteredData = (g, data) => {\n                data = data || new Query(allData).filter([{\n                    field: g.field,\n                    operator: \"eq\",\n                    value: g.value,\n                    ignoreCase: false\n                }]);\n\n                return data;\n            };\n\n            if (descriptors.length > 0) {\n                descriptor = descriptors[0];\n\n                if (options && options.groupPaging) {\n                    result = new Query(allData).groupAllData(descriptor, allData).select(function(group) {\n                        var cachedFilteredData;\n\n                        var items = descriptors.length > 1 ? new Query(group.items).group(descriptors.slice(1), getFilteredData(group, cachedFilteredData).toArray(), options).toArray() : group.items;\n\n                        return {\n                            field: group.field,\n                            value: group.value,\n                            hasSubgroups: descriptors.length > 1,\n                            items: items,\n                            aggregates: descriptor.aggregates && descriptor.aggregates.length ? getFilteredData(group, cachedFilteredData).aggregate(descriptor.aggregates) : {},\n                            uid: kendo.guid(),\n                            itemCount: items.length,\n                            subgroupCount: items.length\n                        };\n                    });\n\n                } else {\n                    result = result.groupBy(descriptor).select(function(group) {\n                        var cachedFilteredData;\n                        return {\n                            field: group.field,\n                            value: group.value,\n                            items: descriptors.length > 1 ? new Query(group.items).group(descriptors.slice(1), getFilteredData(group, cachedFilteredData).toArray()).toArray() : group.items,\n                            hasSubgroups: descriptors.length > 1,\n                            aggregates: descriptor.aggregates && descriptor.aggregates.length ? getFilteredData(group, cachedFilteredData).aggregate(descriptor.aggregates) : {},\n                        };\n                    });\n                }\n            }\n            return result;\n        },\n\n        groupBy: function(descriptor) {\n            var that = this;\n\n            if (isEmptyObject(descriptor) || !this.data.length) {\n                return new Query([]);\n            }\n\n            var field = descriptor.field,\n                sorted = descriptor.skipItemSorting ? this.data : this._sortForGrouping(field, descriptor.dir || \"asc\"),\n                accessor = kendo.accessor(field),\n                item,\n                groupValue = accessor.get(sorted[0], field),\n                group = {\n                    field: field,\n                    value: groupValue,\n                    items: []\n                },\n                currentValue,\n                idx,\n                len,\n                result = [group];\n\n            for (idx = 0, len = sorted.length; idx < len; idx++) {\n                item = sorted[idx];\n                currentValue = accessor.get(item, field);\n                if (!groupValueComparer(groupValue, currentValue)) {\n                    groupValue = currentValue;\n                    group = {\n                        field: field,\n                        value: groupValue,\n                        items: []\n                    };\n                    result.push(group);\n                }\n                group.items.push(item);\n            }\n\n            result = that._sortGroups(result, descriptor);\n\n            return new Query(result);\n        },\n\n        groupAllData: function(descriptor, allData) {\n            if (isEmptyObject(descriptor) || this.data && !this.data.length) {\n                return new Query([]);\n            }\n\n            var field = descriptor.field,\n                sorted = descriptor.skipItemSorting ? allData : new Query(allData).sort(field, descriptor.dir || \"asc\", StableComparer).toArray(),\n                accessor = kendo.accessor(field),\n                item,\n                groupValue = accessor.get(sorted[0], field),\n                group = {\n                    field: field,\n                    value: groupValue,\n                    items: []\n                },\n                currentValue,\n                idx,\n                len,\n                result = [group];\n\n            for (idx = 0, len = sorted.length; idx < len; idx++) {\n                item = sorted[idx];\n                currentValue = accessor.get(item, field);\n                if (!groupValueComparer(groupValue, currentValue)) {\n                    groupValue = currentValue;\n                    group = {\n                        field: field,\n                        value: groupValue,\n                        items: []\n                    };\n                    result.push(group);\n                }\n                group.items.push(item);\n            }\n\n            result = this._sortGroups(result, descriptor);\n\n            return new Query(result);\n        },\n\n        _sortForGrouping: function(field, dir) {\n            var idx, length,\n                data = this.data;\n\n            if (!stableSort) {\n                for (idx = 0, length = data.length; idx < length; idx++) {\n                    data[idx].__position = idx;\n                }\n\n                data = new Query(data).sort(field, dir, StableComparer).toArray();\n\n                for (idx = 0, length = data.length; idx < length; idx++) {\n                    delete data[idx].__position;\n                }\n                return data;\n            }\n\n            return this.sort(field, dir).toArray();\n        },\n\n        _sortGroups: function(groups, descriptor) {\n            var result = groups;\n\n            if (descriptor && isFunction(descriptor.compare)) {\n                result = new Query(result).order({ compare: descriptor.compare }, descriptor.dir || ASCENDING).toArray();\n            }\n\n            return result;\n        },\n\n        aggregate: function(aggregates) {\n            var idx,\n                len,\n                result = {},\n                state = {};\n\n            if (aggregates && aggregates.length) {\n                for (idx = 0, len = this.data.length; idx < len; idx++) {\n                    calculateAggregate(result, aggregates, this.data[idx], idx, len, state);\n                }\n            }\n            return result;\n        }\n    };\n\n    function groupValueComparer(a, b) {\n        if (a && a.getTime && b && b.getTime) {\n            return a.getTime() === b.getTime();\n        }\n        return a === b;\n    }\n\n    function calculateAggregate(accumulator, aggregates, item, index, length, state) {\n        aggregates = aggregates || [];\n        var idx,\n            aggr,\n            functionName,\n            len = aggregates.length;\n\n        for (idx = 0; idx < len; idx++) {\n            aggr = aggregates[idx];\n            functionName = aggr.aggregate;\n            var field = aggr.field;\n            accumulator[field] = accumulator[field] || {};\n            state[field] = state[field] || {};\n            state[field][functionName] = state[field][functionName] || {};\n            accumulator[field][functionName] = functions[functionName.toLowerCase()](accumulator[field][functionName], item, kendo.accessor(field), index, length, state[field][functionName]);\n        }\n    }\n\n    var functions = {\n        sum: function(accumulator, item, accessor) {\n            var value = accessor.get(item);\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(accumulator) {\n            return (accumulator || 0) + 1;\n        },\n        average: function(accumulator, item, accessor, index, length, state) {\n            var value = accessor.get(item);\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            if (index == length - 1 && isNumber(accumulator)) {\n                accumulator = accumulator / state.count;\n            }\n            return accumulator;\n        },\n        max: function(accumulator, item, accessor) {\n            var value = accessor.get(item);\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(accumulator, item, accessor) {\n            var value = accessor.get(item);\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    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 toJSON(array) {\n        var idx, length = array.length, result = new Array(length);\n\n        for (idx = 0; idx < length; idx++) {\n            result[idx] = array[idx].toJSON();\n        }\n\n        return result;\n    }\n\n    Query.normalizeGroup = normalizeGroup;\n    Query.normalizeSort = normalizeSort;\n\n    Query.process = function(data, options, inPlace) {\n        options = options || {};\n\n        var group = options.group;\n        var customGroupSort = anyGroupDescriptorHasCompare(normalizeGroup(group || []));\n        var query = new Query(data),\n            groupDescriptorsWithoutCompare = normalizeGroupWithoutCompare(group || []),\n            normalizedSort = normalizeSort(options.sort || []),\n            sort = customGroupSort ? normalizedSort : groupDescriptorsWithoutCompare.concat(normalizedSort),\n            groupDescriptorsWithoutSort,\n            total,\n            filterCallback = options.filterCallback,\n            filter = options.filter,\n            skip = options.skip,\n            take = options.take;\n\n        if (sort && inPlace) {\n            query = query.sort(sort, undefined$1, undefined$1, inPlace);\n        }\n\n        if (filter) {\n            query = query.filter(filter);\n\n            if (filterCallback) {\n                query = filterCallback(query);\n            }\n\n            total = query.toArray().length;\n        }\n\n        if (sort) {\n            if (!inPlace) {\n                query = query.sort(sort);\n            }\n\n            if (group) {\n                data = query.toArray();\n            }\n        }\n\n        if (customGroupSort) {\n            query = query.group(group, data, options);\n\n            if (skip !== undefined$1 && take !== undefined$1 && !options.groupPaging) {\n                query = new Query(flatGroups(query.toArray())).range(skip, take);\n\n                groupDescriptorsWithoutSort = map(groupDescriptorsWithoutCompare, function(groupDescriptor) {\n                    return extend({}, groupDescriptor, {\n                        skipItemSorting: true\n                    });\n                });\n\n                query = query.group(groupDescriptorsWithoutSort, data, options);\n            }\n        } else {\n            if (skip !== undefined$1 && take !== undefined$1) {\n                total = query.data.length;\n\n                if (skip + take > total && options.virtual) {\n                    skip -= skip + take - total;\n                    skip = skip < 0 ? 0 : skip;\n                }\n                query = query.range(skip, take);\n            }\n\n            if (group && (!isEmptyObject(group) || group.length !== 0)) {\n                query = query.group(group, data, options);\n            }\n        }\n\n        return {\n            total: total,\n            data: query.toArray()\n        };\n    };\n\n    var LocalTransport = Class.extend({\n        init: function(options) {\n            this.data = options.data;\n        },\n\n        read: function(options) {\n            options.success(this.data);\n        },\n        update: function(options) {\n            options.success(options.data);\n        },\n        create: function(options) {\n            options.success(options.data);\n        },\n        destroy: function(options) {\n            options.success(options.data);\n        }\n    });\n\n    var RemoteTransport = Class.extend( {\n        init: function(options) {\n            var that = this, parameterMap;\n\n            options = that.options = extend({}, that.options, options);\n\n            each(crud, function(index, type) {\n                if (typeof options[type] === STRING) {\n                    options[type] = {\n                        url: options[type]\n                    };\n                }\n            });\n\n            that.cache = options.cache ? Cache.create(options.cache) : {\n                find: noop,\n                add: noop\n            };\n\n            parameterMap = options.parameterMap;\n\n            if (options.submit) {\n                that.submit = options.submit;\n            }\n\n            if (isFunction(options.push)) {\n                that.push = options.push;\n            }\n\n            if (!that.push) {\n                that.push = identity;\n            }\n\n            that.parameterMap = isFunction(parameterMap) ? parameterMap : function(options) {\n                var result = {};\n\n                each(options, function(option, value) {\n                    if (option in parameterMap) {\n                        option = parameterMap[option];\n                        if (isPlainObject(option)) {\n                            value = option.value(value);\n                            option = option.key;\n                        }\n                    }\n\n                    result[option] = value;\n                });\n\n                return result;\n            };\n        },\n\n        options: {\n            parameterMap: identity\n        },\n\n        create: function(options) {\n            return ajax(this.setup(options, CREATE));\n        },\n\n        read: function(options) {\n            var that = this,\n                success,\n                error,\n                result,\n                cache = that.cache;\n\n            options = that.setup(options, READ);\n\n            success = options.success || noop;\n            error = options.error || noop;\n\n            result = cache.find(options.data);\n\n            if (result !== undefined$1) {\n                success(result);\n            } else {\n                options.success = function(result) {\n                    cache.add(options.data, result);\n\n                    success(result);\n                };\n\n                $.ajax(options);\n            }\n        },\n\n        update: function(options) {\n            return ajax(this.setup(options, UPDATE));\n        },\n\n        destroy: function(options) {\n            return ajax(this.setup(options, DESTROY));\n        },\n\n        setup: function(options, type) {\n            options = options || {};\n\n            var that = this,\n                parameters,\n                operation = that.options[type],\n                data = isFunction(operation.data) ? operation.data(options.data) : operation.data;\n\n            options = extend(true, {}, operation, options);\n            parameters = extend(true, {}, data, options.data);\n\n            options.data = that.parameterMap(parameters, type);\n\n            if (isFunction(options.url)) {\n                options.url = options.url(parameters);\n            }\n\n            return options;\n        }\n    });\n\n    var Cache = Class.extend({\n        init: function() {\n            this._store = {};\n        },\n        add: function(key, data) {\n            if (key !== undefined$1) {\n                this._store[stringify(key)] = data;\n            }\n        },\n        find: function(key) {\n            return this._store[stringify(key)];\n        },\n        clear: function() {\n            this._store = {};\n        },\n        remove: function(key) {\n            delete this._store[stringify(key)];\n        }\n    });\n\n    Cache.create = function(options) {\n        var store = {\n            \"inmemory\": function() { return new Cache(); }\n        };\n\n        if (isPlainObject(options) && isFunction(options.find)) {\n            return options;\n        }\n\n        if (options === true) {\n            return new Cache();\n        }\n\n        return store[options]();\n    };\n\n    function serializeRecords(data, getters, modelInstance, originalFieldNames, fieldNames) {\n        var record,\n            getter,\n            originalName,\n            idx,\n            setters = {},\n            length;\n\n        for (idx = 0, length = data.length; idx < length; idx++) {\n            record = data[idx];\n            for (getter in getters) {\n                originalName = fieldNames[getter];\n\n                if (originalName && originalName !== getter) {\n                    if (!setters[originalName]) {\n                        setters[originalName] = kendo.setter(originalName);\n                    }\n                    setters[originalName](record, getters[getter](record));\n                    delete record[getter];\n                }\n            }\n        }\n    }\n\n    function convertRecords(data, getters, modelInstance, originalFieldNames, fieldNames) {\n        var record,\n            getter,\n            originalName,\n            idx,\n            length;\n\n        for (idx = 0, length = data.length; idx < length; idx++) {\n            record = data[idx];\n            for (getter in getters) {\n                record[getter] = modelInstance._parse(getter, getters[getter](record));\n\n                originalName = fieldNames[getter];\n                if (originalName && originalName !== getter) {\n                    delete record[originalName];\n                }\n            }\n        }\n    }\n\n    function convertGroup(data, getters, modelInstance, originalFieldNames, fieldNames) {\n        var record,\n            idx,\n            fieldName,\n            length;\n\n        for (idx = 0, length = data.length; idx < length; idx++) {\n            record = data[idx];\n\n            fieldName = originalFieldNames[record.field];\n            if (fieldName && fieldName != record.field) {\n                record.field = fieldName;\n            }\n\n            record.value = modelInstance._parse(record.field, record.value);\n\n            if (record.items) {\n                if (record.hasSubgroups) {\n                    convertGroup(record.items, getters, modelInstance, originalFieldNames, fieldNames);\n                } else {\n                    convertRecords(record.items, getters, modelInstance, originalFieldNames, fieldNames);\n                }\n            }\n        }\n    }\n\n    function wrapDataAccess(originalFunction, model, converter, getters, originalFieldNames, fieldNames) {\n        return function(data) {\n            data = originalFunction(data);\n\n            return wrapDataAccessBase(model, converter, getters, originalFieldNames, fieldNames)(data);\n        };\n    }\n\n    function wrapDataAccessBase(model, converter, getters, originalFieldNames, fieldNames) {\n        return function(data) {\n\n            if (data && !isEmptyObject(getters)) {\n                if (toString.call(data) !== \"[object Array]\" && !(data instanceof ObservableArray)) {\n                    data = [data];\n                }\n\n                converter(data, getters, new model(), originalFieldNames, fieldNames);\n            }\n\n            return data || [];\n        };\n    }\n\n    var DataReader = Class.extend({\n        init: function(schema) {\n            var that = this, member, get, model, base;\n\n            schema = schema || {};\n\n            for (member in schema) {\n                get = schema[member];\n\n                that[member] = typeof get === STRING ? getter(get) : get;\n            }\n\n            base = schema.modelBase || Model;\n\n            if (isPlainObject(that.model)) {\n                that.model = model = base.define(that.model);\n            }\n\n            var dataFunction = that.data.bind(that);\n\n            that._dataAccessFunction = dataFunction;\n\n            if (that.model) {\n                var groupsFunction = that.groups.bind(that),\n                    serializeFunction = that.serialize.bind(that),\n                    originalFieldNames = {},\n                    getters = {},\n                    serializeGetters = {},\n                    fieldNames = {},\n                    shouldSerialize = false,\n                    fieldName,\n                    name;\n\n                model = that.model;\n\n                if (model.fields) {\n                    each(model.fields, function(field, value) {\n                        var fromName;\n\n                        fieldName = field;\n\n                        if (isPlainObject(value) && value.field) {\n                            fieldName = value.field;\n                        } else if (typeof value === STRING) {\n                            fieldName = value;\n                        }\n\n                        if (isPlainObject(value) && value.from) {\n                            fromName = value.from;\n                        }\n\n                        shouldSerialize = shouldSerialize || (fromName && fromName !== field) || fieldName !== field;\n                        name = fromName || fieldName;\n                        getters[field] = name.indexOf(\".\") !== -1 ? getter(name, true) : getter(name);\n                        serializeGetters[field] = getter(field);\n                        originalFieldNames[fromName || fieldName] = field;\n                        fieldNames[field] = fromName || fieldName;\n                    });\n\n                    if (!schema.serialize && shouldSerialize) {\n                        that.serialize = wrapDataAccess(serializeFunction, model, serializeRecords, serializeGetters, originalFieldNames, fieldNames);\n                    }\n                }\n\n                that._dataAccessFunction = dataFunction;\n                that._wrapDataAccessBase = wrapDataAccessBase(model, convertRecords, getters, originalFieldNames, fieldNames);\n                that.data = wrapDataAccess(dataFunction, model, convertRecords, getters, originalFieldNames, fieldNames);\n                that.groups = wrapDataAccess(groupsFunction, model, convertGroup, getters, originalFieldNames, fieldNames);\n            }\n        },\n        errors: function(data) {\n            return data ? data.errors : null;\n        },\n        parse: identity,\n        data: identity,\n        total: function(data) {\n            return data.length;\n        },\n        groups: identity,\n        aggregates: function() {\n            return {};\n        },\n        serialize: function(data) {\n            return data;\n        }\n    });\n\n    function fillLastGroup(originalGroup, newGroup) {\n        var currOriginal;\n        var currentNew;\n\n        if (newGroup.items && newGroup.items.length) {\n            for (var i = 0; i < newGroup.items.length; i++) {\n                currOriginal = originalGroup.items[originalGroup.items.length - 1];\n                currentNew = newGroup.items[i];\n                if (currOriginal && currentNew) {\n                    if (currOriginal.hasSubgroups && currOriginal.value == currentNew.value) {\n                        fillLastGroup(currOriginal, currentNew);\n                    } else if (currOriginal.field && currOriginal.value == currentNew.value) {\n                        currOriginal.items.omitChangeEvent = true;\n                        currOriginal.items.push.apply(currOriginal.items, currentNew.items);\n                        currOriginal.items.omitChangeEvent = false;\n                    } else {\n                        originalGroup.items.omitChangeEvent = true;\n                        originalGroup.items.push.apply(originalGroup.items, [currentNew]);\n                        originalGroup.items.omitChangeEvent = false;\n                    }\n                } else if (currentNew) {\n                    originalGroup.items.omitChangeEvent = true;\n                    originalGroup.items.push.apply(originalGroup.items, [currentNew]);\n                    originalGroup.items.omitChangeEvent = false;\n                }\n            }\n        }\n    }\n    function mergeGroups(target, dest, skip, take) {\n        var group,\n            idx = 0,\n            items;\n\n        while (dest.length && take) {\n            group = dest[idx];\n            items = group.items;\n\n            var length = items.length;\n\n            if (target && target.field === group.field && target.value === group.value) {\n                if (target.hasSubgroups && target.items.length) {\n                    mergeGroups(target.items[target.items.length - 1], group.items, skip, take);\n                } else {\n                    items = items.slice(skip, skip + take);\n                    target.items = target.items.concat(items);\n                }\n                dest.splice(idx--, 1);\n            } else if (group.hasSubgroups && items.length) {\n                mergeGroups(group, items, skip, take);\n                if (!group.items.length) {\n                    dest.splice(idx--, 1);\n                }\n            } else {\n                items = items.slice(skip, skip + take);\n                group.items = items;\n\n                if (!group.items.length) {\n                    dest.splice(idx--, 1);\n                }\n            }\n\n            if (items.length === 0) {\n                skip -= length;\n            } else {\n                skip = 0;\n                take -= items.length;\n            }\n\n            if (++idx >= dest.length) {\n                break;\n            }\n        }\n\n        if (idx < dest.length) {\n            dest.splice(idx, dest.length - idx);\n        }\n    }\n\n    function flatGroups(groups, indexFunction) {\n        var result = [];\n        var groupsLength = (groups || []).length;\n        var group;\n        var items;\n        var indexFn = isFunction(indexFunction) ? indexFunction : function(array, index) {\n            return array[index];\n        };\n\n        for (var groupIndex = 0; groupIndex < groupsLength; groupIndex++) {\n            group = indexFn(groups, groupIndex);\n\n            if (group.hasSubgroups) {\n                result = result.concat(flatGroups(group.items));\n            } else {\n                items = group.items;\n\n                for (var itemIndex = 0; itemIndex < items.length; itemIndex++) {\n                    result.push(indexFn(items, itemIndex));\n                }\n            }\n        }\n        return result;\n    }\n\n    function flattenGroups(data) {\n        var idx,\n            result = [],\n            length,\n            items,\n            itemIndex;\n\n        for (idx = 0, length = data.length; idx < length; idx++) {\n            var group = data.at(idx);\n            if (group.items) {\n                if (group.hasSubgroups) {\n                    result = result.concat(flattenGroups(group.items));\n                } else {\n                    items = group.items;\n                    for (itemIndex = 0; itemIndex < items.length; itemIndex++) {\n                        result.push(items.at(itemIndex));\n                    }\n                }\n            }\n        }\n        return result;\n    }\n\n    function wrapGroupItems(data, model) {\n        var idx, length, group;\n        if (model) {\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                group = data.at(idx);\n                if (group.items) {\n                    if (group.hasSubgroups) {\n                        wrapGroupItems(group.items, model);\n                    } else {\n                        group.items = new LazyObservableArray(group.items, model, group.items._events);\n                    }\n                }\n            }\n        }\n    }\n\n    function eachGroupItems(data, func) {\n        for (var idx = 0; idx < data.length; idx++) {\n            if (data[idx].hasSubgroups) {\n                if (eachGroupItems(data[idx].items, func)) {\n                    return true;\n                }\n            } else if (func(data[idx].items, data[idx])) {\n                return true;\n            }\n        }\n    }\n\n    function replaceInRanges(ranges, data, item, observable) {\n        for (var idx = 0; idx < ranges.length; idx++) {\n            if (ranges[idx].data === data) {\n                break;\n            }\n            if (replaceInRange(ranges[idx].data, item, observable)) {\n                break;\n            }\n        }\n    }\n\n    function replaceInRange(items, item, observable) {\n        for (var idx = 0, length = items.length; idx < length; idx++) {\n            if (items[idx] && items[idx].hasSubgroups) {\n                return replaceInRange(items[idx].items, item, observable);\n            } else if (items[idx] === item || items[idx] === observable) {\n               items[idx] = observable;\n               return true;\n            }\n        }\n    }\n\n    function replaceWithObservable(view, data, ranges, type, serverGrouping) {\n        for (var viewIndex = 0, length = view.length; viewIndex < length; viewIndex++) {\n            var item = view[viewIndex];\n\n            if (!item || item instanceof type) {\n                continue;\n            }\n\n            if (item.hasSubgroups !== undefined$1 && !serverGrouping) {\n                replaceWithObservable(item.items, data, ranges, type, serverGrouping);\n            } else {\n                for (var idx = 0; idx < data.length; idx++) {\n                    if (data[idx] === item) {\n                        view[viewIndex] = data.at(idx);\n                        replaceInRanges(ranges, data, item, view[viewIndex]);\n                        break;\n                    }\n                }\n            }\n        }\n    }\n\n    function removeModel(data, model) {\n        if (!data) {\n            return;\n        }\n        var length = data.length;\n        var dataItem;\n        var idx;\n\n        for (idx = 0; idx < length; idx++) {\n            dataItem = data[idx];\n\n            if (dataItem.uid && dataItem.uid == model.uid) {\n                data.splice(idx, 1);\n                return dataItem;\n            }\n        }\n    }\n\n    function indexOfPristineModel(data, model) {\n        if (model) {\n            return indexOf(data, function(item) {\n                return (item.uid && item.uid == model.uid) || (item[model.idField] === model.id && model.id !== model._defaultId);\n            });\n        }\n        return -1;\n    }\n\n    function indexOfModel(data, model) {\n        if (model) {\n            return indexOf(data, function(item) {\n                return item.uid == model.uid;\n            });\n        }\n        return -1;\n    }\n\n    function indexOf(data, comparer) {\n        var idx, length;\n        if (!data) {\n            return;\n        }\n\n        for (idx = 0, length = data.length; idx < length; idx++) {\n            if (comparer(data[idx])) {\n                return idx;\n            }\n        }\n\n        return -1;\n    }\n\n    function fieldNameFromModel(fields, name) {\n        if (fields && !isEmptyObject(fields)) {\n            var descriptor = fields[name];\n            var fieldName;\n            if (isPlainObject(descriptor)) {\n                fieldName = descriptor.from || descriptor.field || name;\n            } else {\n                fieldName = fields[name] || name;\n            }\n\n            if (isFunction(fieldName)) {\n                return name;\n            }\n\n            return fieldName;\n        }\n        return name;\n    }\n\n    function convertFilterDescriptorsField(descriptor, model) {\n        var idx,\n            length,\n            target = {};\n\n        for (var field in descriptor) {\n            if (field !== \"filters\") {\n                target[field] = descriptor[field];\n            }\n        }\n\n        if (descriptor.filters) {\n            target.filters = [];\n            for (idx = 0, length = descriptor.filters.length; idx < length; idx++) {\n                target.filters[idx] = convertFilterDescriptorsField(descriptor.filters[idx], model);\n            }\n        } else {\n            target.field = fieldNameFromModel(model.fields, target.field);\n        }\n        return target;\n    }\n\n    function convertDescriptorsField(descriptors, model) {\n        var idx,\n            length,\n            result = [],\n            target,\n            descriptor;\n\n        for (idx = 0, length = descriptors.length; idx < length; idx ++) {\n            target = {};\n\n            descriptor = descriptors[idx];\n\n            for (var field in descriptor) {\n                target[field] = descriptor[field];\n            }\n\n            target.field = fieldNameFromModel(model.fields, target.field);\n\n            if (target.aggregates && isArray(target.aggregates)) {\n                target.aggregates = convertDescriptorsField(target.aggregates, model);\n            }\n            result.push(target);\n        }\n        return result;\n    }\n\n    var DataSource = Observable.extend({\n        init: function(options) {\n            var that = this, model, data;\n\n            if (options) {\n                data = options.data;\n            }\n\n            options = that.options = extend({}, that.options, options);\n\n            that._map = {};\n            that._prefetch = {};\n            that._data = [];\n            that._pristineData = [];\n            that._ranges = [];\n            that._view = [];\n            that._pristineTotal = 0;\n            that._destroyed = [];\n            that._pageSize = options.pageSize;\n            that._page = options.page || (options.pageSize ? 1 : undefined$1);\n            that._sort = normalizeSort(options.sort);\n            that._sortFields = sortFields(options.sort);\n            that._filter = normalizeFilter(options.filter);\n            that._group = normalizeGroup(options.group);\n            that._aggregate = options.aggregate;\n            that._total = options.total;\n            that._groupPaging = options.groupPaging;\n\n            if (that._groupPaging) {\n                that._groupsState = {};\n            }\n            that._shouldDetachObservableParents = true;\n\n            Observable.fn.init.call(that);\n\n            that.transport = Transport.create(options, data, that);\n\n            if (isFunction(that.transport.push)) {\n                that.transport.push({\n                    pushCreate: that._pushCreate.bind(that),\n                    pushUpdate: that._pushUpdate.bind(that),\n                    pushDestroy: that._pushDestroy.bind(that)\n                });\n            }\n\n            if (options.offlineStorage != null) {\n                if (typeof options.offlineStorage == \"string\") {\n                    var key = options.offlineStorage;\n\n                    that._storage = {\n                        getItem: function() {\n                            return JSON.parse(localStorage.getItem(key));\n                        },\n                        setItem: function(item) {\n                            localStorage.setItem(key, stringify(that.reader.serialize(item)));\n                        }\n                    };\n                } else {\n                    that._storage = options.offlineStorage;\n                }\n            }\n\n            that.reader = new kendo.data.readers[options.schema.type || \"json\" ](options.schema);\n\n            model = that.reader.model || {};\n\n            that._detachObservableParents();\n\n            that._data = that._observe(that._data);\n            that._online = true;\n\n            that.bind([\"push\", ERROR, CHANGE, REQUESTSTART, SYNC, REQUESTEND, PROGRESS], options);\n        },\n\n        options: {\n            data: null,\n            schema: {\n               modelBase: Model\n            },\n            offlineStorage: null,\n            serverSorting: false,\n            serverPaging: false,\n            serverFiltering: false,\n            serverGrouping: false,\n            serverAggregates: false,\n            batch: false,\n            inPlaceSort: false\n        },\n\n        clone: function() {\n            return this;\n        },\n\n        online: function(value) {\n            if (value !== undefined$1) {\n                if (this._online != value) {\n                    this._online = value;\n\n                    if (value) {\n                        return this.sync();\n                    }\n                }\n\n                return $.Deferred().resolve().promise();\n            } else {\n                return this._online;\n            }\n        },\n\n        offlineData: function(state) {\n            if (this.options.offlineStorage == null) {\n                return null;\n            }\n\n            if (state !== undefined$1) {\n                return this._storage.setItem(state);\n            }\n\n            return this._storage.getItem() || [];\n        },\n\n        _isGrouped: function() {\n            var group = this.group() || [];\n\n            return group.length;\n        },\n\n        _isServerGrouped: function() {\n            var group = this.group() || [];\n\n            return this.options.serverGrouping && group.length;\n        },\n\n        _isServerGroupPaged: function() {\n            return this._isServerGrouped() && this._groupPaging;\n        },\n\n        _isGroupPaged: function() {\n            var group = this._group || [];\n\n            return this._groupPaging && group.length;\n        },\n\n        _pushCreate: function(result) {\n            this._push(result, \"pushCreate\");\n        },\n\n        _pushUpdate: function(result) {\n            this._push(result, \"pushUpdate\");\n        },\n\n        _pushDestroy: function(result) {\n            this._push(result, \"pushDestroy\");\n        },\n\n        _push: function(result, operation) {\n            var data = this._readData(result);\n\n            if (!data) {\n                data = result;\n            }\n\n            this[operation](data);\n        },\n\n        _flatData: function(data, skip) {\n            if (data) {\n                if (this._isServerGrouped()) {\n                    return flattenGroups(data);\n                }\n\n                if (!skip) {\n                    for (var idx = 0; idx < data.length; idx++) {\n                        data.at(idx);\n                    }\n                }\n            }\n\n            return data;\n        },\n\n        parent: noop,\n\n        get: function(id) {\n            var idx, length, data = this._flatData(this._data, this.options.useRanges);\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                if (data[idx].id == id) {\n                    return data[idx];\n                }\n            }\n        },\n\n        getByUid: function(id) {\n            return this._getByUid(id, this._data);\n        },\n\n        _getByUid: function(id, dataItems) {\n            var idx, length, data = this._flatData(dataItems, this.options.useRanges);\n\n            if (!data) {\n                return;\n            }\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                if (data[idx].uid == id) {\n                    return data[idx];\n                }\n            }\n        },\n\n        indexOf: function(model) {\n            return indexOfModel(this._data, model);\n        },\n\n        at: function(index) {\n            return this._data.at(index);\n        },\n\n        data: function(value) {\n            var that = this;\n            if (value !== undefined$1) {\n                that._detachObservableParents();\n                that._data = this._observe(value);\n\n                that._pristineData = value.slice(0);\n\n                that._storeData();\n\n                that._ranges = [];\n                that.trigger(\"reset\");\n                that._addRange(that._data);\n\n                that._total = that._data.length;\n                that._pristineTotal = that._total;\n\n                that._process(that._data);\n            } else {\n                if (that._data) {\n                    for (var idx = 0; idx < that._data.length; idx++) {\n                        that._data.at(idx);\n                    }\n                }\n\n                return that._data;\n            }\n        },\n\n        view: function(value) {\n            if (value === undefined$1) {\n                return this._view;\n            } else {\n                this._view = this._observeView(value);\n            }\n        },\n\n        _observeView: function(data) {\n            var that = this;\n            replaceWithObservable(data, that._data, that._ranges, that.reader.model || ObservableObject, that._isServerGrouped());\n\n            var view = new LazyObservableArray(data, that.reader.model);\n            view.parent = function() { return that.parent(); };\n            return view;\n        },\n\n        flatView: function() {\n            var groups = this.group() || [];\n\n            if (groups.length) {\n                return flattenGroups(this._view);\n            } else {\n                return this._view;\n            }\n        },\n\n        add: function(model) {\n            return this.insert(this._data.length, model);\n        },\n\n        _createNewModel: function(model) {\n            if (this.reader.model) {\n                return new this.reader.model(model);\n            }\n\n            if (model instanceof ObservableObject) {\n                return model;\n            }\n\n            return new ObservableObject(model);\n        },\n\n        insert: function(index, model) {\n            if (!model) {\n                model = index;\n                index = 0;\n            }\n\n            if (!(model instanceof Model)) {\n                model = this._createNewModel(model);\n            }\n\n            if (this._isServerGrouped()) {\n                this._data.splice(index, 0, this._wrapInEmptyGroup(model));\n            } else {\n                this._data.splice(index, 0, model);\n            }\n\n            this._insertModelInRange(index, model);\n\n            return model;\n        },\n\n        pushInsert: function(index, items) {\n            var that = this;\n            var rangeSpan = that._getCurrentRangeSpan();\n\n            if (!items) {\n                items = index;\n                index = 0;\n            }\n\n            if (!isArray(items)) {\n                items = [items];\n            }\n\n            var pushed = [];\n            var autoSync = this.options.autoSync;\n            this.options.autoSync = false;\n\n            try {\n                for (var idx = 0; idx < items.length; idx ++) {\n                    var item = items[idx];\n\n                    var result = this.insert(index, item);\n\n                    pushed.push(result);\n\n                    var pristine = result.toJSON();\n\n                    if (this._isServerGrouped()) {\n                        pristine = this._wrapInEmptyGroup(pristine);\n                    }\n\n                    this._pristineData.push(pristine);\n\n                    if (rangeSpan && rangeSpan.length) {\n                        $(rangeSpan).last()[0].pristineData.push(pristine);\n                    }\n\n                    index++;\n                }\n            } finally {\n                this.options.autoSync = autoSync;\n            }\n\n            if (pushed.length) {\n                this.trigger(\"push\", {\n                    type: \"create\",\n                    items: pushed\n                });\n            }\n        },\n\n        pushCreate: function(items) {\n            this.pushInsert(this._data.length, items);\n        },\n\n        pushUpdate: function(items) {\n            if (!isArray(items)) {\n                items = [items];\n            }\n\n            var pushed = [];\n\n            for (var idx = 0; idx < items.length; idx ++) {\n                var item = items[idx];\n                var model = this._createNewModel(item);\n\n                var target = this.get(model.id);\n\n                if (target) {\n                    pushed.push(target);\n\n                    target.accept(item);\n\n                    target.trigger(CHANGE);\n\n                    this._updatePristineForModel(target, item);\n                } else {\n                    this.pushCreate(item);\n                }\n            }\n\n            if (pushed.length) {\n                this.trigger(\"push\", {\n                    type: \"update\",\n                    items: pushed\n                });\n            }\n        },\n\n        pushDestroy: function(items) {\n            var pushed = this._removeItems(items);\n\n            if (pushed.length) {\n                this.trigger(\"push\", {\n                    type: \"destroy\",\n                    items: pushed\n                });\n            }\n        },\n\n        _removeItems: function(itemsToRemove, removePristine) {\n            if (!isArray(itemsToRemove)) {\n                itemsToRemove = [itemsToRemove];\n            }\n\n            var shouldRemovePristine = typeof removePristine !== \"undefined\" ? removePristine : true;\n\n            var destroyed = [];\n            var autoSync = this.options.autoSync;\n            this.options.autoSync = false;\n            try {\n                for (var idx = 0; idx < itemsToRemove.length; idx ++) {\n                    var item = itemsToRemove[idx];\n                    var model = this._createNewModel(item);\n                    var found = false;\n                    var index = idx;\n\n                    this._eachItem(this._data, function(items) {\n                        // Ensure all children of a parent are removed before the change event is triggered.\n                        if (index !== itemsToRemove.length - 1) {\n                            items.omitChangeEvent = true;\n                            items.omitCache = [];\n                        } else {\n                            items.omitChangeEvent = false;\n                        }\n\n                        for (var idx = 0; idx < items.length; idx++) {\n                            var item = items.at(idx);\n                            if (item.id === model.id) {\n                                /* When the change event is omitted, certain calculations such as 'total' are broken because only the last item reaches the change handler.\n                                   Keep track of all child items that had their change event omitted and when the change is finally triggered, concat them to the result.*/\n                                if (items.omitChangeEvent) {\n                                    items.omitCache.push(item);\n                                }\n                                destroyed.push(item);\n                                items.splice(idx, 1);\n                                found = true;\n                                break;\n                            }\n                        }\n                    });\n\n                    if (found && shouldRemovePristine) {\n                        this._removePristineForModel(model);\n                        this._destroyed.pop();\n                    }\n                }\n            } finally {\n                this.options.autoSync = autoSync;\n            }\n\n            return destroyed;\n        },\n\n        pushMove: function(index, items) {\n            var pushed = this._moveItems(index, items);\n\n            if (pushed.length) {\n                this.trigger(\"push\", {\n                    type: \"update\",\n                    items: pushed\n                });\n            }\n        },\n\n        _moveItems: function(index, items) {\n            if (!isArray(items)) {\n                items = [items];\n            }\n\n            var moved = [];\n            var autoSync = this.options.autoSync;\n            this.options.autoSync = false;\n\n            try {\n                for (var i = 0; i < items.length; i ++) {\n                    var item = items[i];\n                    var model = this._createNewModel(item);\n\n                    this._eachItem(this._data, function(dataItems) {\n                        for (var idx = 0; idx < dataItems.length; idx++) {\n                            var dataItem = dataItems.at(idx);\n                            if (dataItem.id === model.id) {\n                                moved.push(dataItem);\n                                dataItems.splice(index >= idx ? --index : index, 0, dataItems.splice(idx, 1)[0]);\n                                index++;\n                                break;\n                            }\n                        }\n                    });\n                }\n            } finally {\n                this.options.autoSync = autoSync;\n            }\n\n            return moved;\n        },\n\n        remove: function(model) {\n            var result,\n                that = this,\n                hasGroups = that._isServerGrouped();\n\n            if (hasGroups && model.uid && (!model.isNew || !model.isNew())) {\n                that._pushInDestroyed(model);\n            }\n\n            this._eachItem(that._data, function(items) {\n                result = removeModel(items, model);\n\n                if (result && hasGroups) {\n                    return true;\n                }\n            });\n\n            this._removeModelFromRanges(model);\n\n            return model;\n        },\n\n        destroyed: function() {\n            return this._destroyed;\n        },\n\n        created: function() {\n            var idx,\n                length,\n                result = [],\n                data = this._flatData(this._data, this.options.useRanges);\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                if (data[idx].isNew && data[idx].isNew() && !data[idx].notFetched) {\n                    result.push(data[idx]);\n                }\n            }\n            return result;\n        },\n\n        updated: function() {\n            var idx,\n                length,\n                result = [],\n                data = this._flatData(this._data, this.options.useRanges);\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                if ((data[idx].isNew && !data[idx].isNew()) && data[idx].dirty) {\n                    result.push(data[idx]);\n                }\n            }\n            return result;\n        },\n\n        sync: function() {\n            var that = this,\n                created = [],\n                updated = [],\n                destroyed = that._destroyed;\n\n            var promise = $.Deferred().resolve().promise();\n\n            if (that.online()) {\n\n                if (!that.reader.model) {\n                    return promise;\n                }\n\n                created = that.created();\n                updated = that.updated();\n\n                var promises = [];\n\n                if (that.options.batch && that.transport.submit) {\n                    promises = that._sendSubmit(created, updated, destroyed);\n                } else {\n                    promises.push.apply(promises, that._send(\"create\", created));\n                    promises.push.apply(promises, that._send(\"update\", updated));\n                    promises.push.apply(promises, that._send(\"destroy\", destroyed));\n                }\n\n                promise = $.when\n                 .apply(null, promises)\n                 .then(function() {\n                    var idx, length;\n\n                    for (idx = 0, length = arguments.length; idx < length; idx++) {\n                        if (arguments[idx]) {\n                            that._accept(arguments[idx]);\n                        }\n                    }\n\n                    that._storeData(true);\n\n                    that._syncEnd();\n\n                    that._change({ action: \"sync\" });\n\n                    that.trigger(SYNC);\n\n                    if (that._isServerGroupPaged()) {\n                        that.read();\n                    }\n                });\n            } else {\n                that._storeData(true);\n\n                that._syncEnd();\n\n                that._change({ action: \"sync\" });\n            }\n\n            return promise;\n        },\n\n        _syncEnd: noop,\n\n        cancelChanges: function(model) {\n            var that = this;\n\n            if (model instanceof kendo.data.Model) {\n                that._cancelModel(model);\n            } else {\n                that._destroyed = [];\n                that._detachObservableParents();\n                that._data = that._observe(that._pristineData);\n                if (that.options.serverPaging) {\n                    that._total = that._pristineTotal;\n                }\n\n                that._ranges = [];\n                that._addRange(that._data, 0);\n\n                that._changesCanceled();\n\n                that._change();\n\n                that._markOfflineUpdatesAsDirty();\n\n                if (that._isServerGrouped()) {\n                    that.read();\n                }\n            }\n        },\n\n        _changesCanceled: noop,\n\n        _markOfflineUpdatesAsDirty: function() {\n            var that = this;\n\n            if (that.options.offlineStorage != null) {\n                that._eachItem(that._data, function(items) {\n                    for (var idx = 0; idx < items.length; idx++) {\n                        var item = items.at(idx);\n                        if (item.__state__ == \"update\" || item.__state__ == \"create\") {\n                            item.dirty = true;\n                        }\n                    }\n                });\n            }\n        },\n\n        hasChanges: function() {\n            var idx,\n                length,\n                data = this._flatData(this._data, this.options.useRanges);\n\n            if (this._destroyed.length) {\n                return true;\n            }\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                if ((data[idx].isNew && data[idx].isNew()) || data[idx].dirty) {\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        _accept: function(result) {\n            var that = this,\n                models = result.models,\n                response = result.response,\n                idx = 0,\n                serverGroup = that._isServerGrouped(),\n                pristine = that._pristineData,\n                type = result.type,\n                length;\n\n            that.trigger(REQUESTEND, { response: response, type: type });\n\n            if (response && !isEmptyObject(response)) {\n                response = that.reader.parse(response);\n\n                if (that._handleCustomErrors(response)) {\n                    return;\n                }\n\n                response = that.reader.data(response);\n\n                if (!isArray(response)) {\n                    response = [response];\n                }\n            } else {\n                response = $.map(models, function(model) { return model.toJSON(); } );\n            }\n\n            if (type === \"destroy\") {\n                that._destroyed = [];\n            }\n\n            for (idx = 0, length = models.length; idx < length; idx++) {\n                if (type !== \"destroy\") {\n                    models[idx].accept(response[idx]);\n\n                    if (type === \"create\") {\n                        pristine.push(serverGroup ? that._wrapInEmptyGroup(models[idx].toJSON()) : response[idx]);\n                    } else if (type === \"update\") {\n                        that._updatePristineForModel(models[idx], response[idx]);\n                    }\n                } else {\n                    that._removePristineForModel(models[idx]);\n                }\n            }\n        },\n\n        _updatePristineForModel: function(model, values) {\n            this._executeOnPristineForModel(model, function(index, items) {\n                kendo.deepExtend(items[index], values);\n            });\n        },\n\n        _executeOnPristineForModel: function(model, callback) {\n            this._eachPristineItem(\n                function(items) {\n                    var index = indexOfPristineModel(items, model);\n                    if (index > -1) {\n                        callback(index, items);\n                        return true;\n                    }\n                });\n        },\n\n        _removePristineForModel: function(model) {\n            this._executeOnPristineForModel(model, function(index, items) {\n                items.splice(index, 1);\n            });\n        },\n\n        _readData: function(data) {\n            var read = !this._isServerGrouped() ? this.reader.data : this.reader.groups;\n            return read.call(this.reader, data);\n        },\n\n        _eachPristineItem: function(callback) {\n            var that = this;\n            var options = that.options;\n            var rangeSpan = that._getCurrentRangeSpan();\n\n            that._eachItem(that._pristineData, callback);\n\n            if (options.serverPaging && options.useRanges) {\n                each(rangeSpan, function(i, range) {\n                    that._eachItem(range.pristineData, callback);\n                });\n            }\n        },\n\n       _eachItem: function(data, callback) {\n            if (data && data.length) {\n                if (this._isServerGrouped()) {\n                    eachGroupItems(data, callback);\n                } else {\n                    callback(data);\n                }\n            }\n        },\n\n        _pristineForModel: function(model) {\n            var pristine,\n                idx,\n                callback = function(items) {\n                    idx = indexOfPristineModel(items, model);\n                    if (idx > -1) {\n                        pristine = items[idx];\n                        return true;\n                    }\n                };\n\n            this._eachPristineItem(callback);\n\n            return pristine;\n        },\n\n        _cancelModel: function(model) {\n            var that = this;\n            var pristine = this._pristineForModel(model);\n\n            this._eachItem(this._data, function(items) {\n                var idx = indexOfModel(items, model);\n                if (idx >= 0) {\n                    if (pristine && (!model.isNew() || pristine.__state__)) {\n                        items[idx].accept(pristine);\n\n                        if (pristine.__state__ == \"update\") {\n                            items[idx].dirty = true;\n                        }\n\n                    } else {\n                        that._modelCanceled(model);\n\n                        items.splice(idx, 1);\n\n                        that._removeModelFromRanges(model);\n                    }\n                }\n            });\n        },\n\n        _modelCanceled: noop,\n\n        _submit: function(promises, data) {\n            var that = this;\n\n            that.trigger(REQUESTSTART, { type: \"submit\" });\n\n            that.trigger(PROGRESS);\n\n            that.transport.submit(extend({\n                success: function(response, type) {\n                    var promise = $.grep(promises, function(x) {\n                        return x.type == type;\n                    })[0];\n\n                    if (promise) {\n                        promise.resolve({\n                            response: response,\n                            models: promise.models,\n                            type: type\n                        });\n                    }\n                },\n                error: function(response, status, error) {\n                    for (var idx = 0; idx < promises.length; idx++) {\n                        promises[idx].reject(response);\n                    }\n\n                    that.error(response, status, error);\n                }\n            }, data));\n        },\n\n        _sendSubmit: function(created, updated, destroyed) {\n            var that = this,\n                promises = [];\n\n            if (that.options.batch) {\n                if (created.length) {\n                    promises.push($.Deferred(function(deferred) {\n                        deferred.type = \"create\";\n                        deferred.models = created;\n                    }));\n                }\n\n                if (updated.length) {\n                    promises.push($.Deferred(function(deferred) {\n                        deferred.type = \"update\";\n                        deferred.models = updated;\n                    }));\n                }\n\n                if (destroyed.length) {\n                    promises.push($.Deferred(function(deferred) {\n                        deferred.type = \"destroy\";\n                        deferred.models = destroyed;\n                    }));\n                }\n\n                that._submit(promises, {\n                    data: {\n                        created: that.reader.serialize(toJSON(created)),\n                        updated: that.reader.serialize(toJSON(updated)),\n                        destroyed: that.reader.serialize(toJSON(destroyed))\n                    }\n                });\n            }\n\n            return promises;\n        },\n\n        _promise: function(data, models, type) {\n            var that = this;\n\n            return $.Deferred(function(deferred) {\n                that.trigger(REQUESTSTART, { type: type });\n\n                that.trigger(PROGRESS);\n\n                that.transport[type].call(that.transport, extend({\n                    success: function(response) {\n                        deferred.resolve({\n                            response: response,\n                            models: models,\n                            type: type\n                        });\n                    },\n                    error: function(response, status, error) {\n                        deferred.reject(response);\n                        that.error(response, status, error);\n                    }\n                }, data));\n            }).promise();\n        },\n\n        _send: function(method, data) {\n            var that = this,\n                idx,\n                length,\n                promises = [],\n                converted = that.reader.serialize(toJSON(data));\n\n            if (that.options.batch) {\n                if (data.length) {\n                    promises.push(that._promise( { data: { models: converted } }, data , method));\n                }\n            } else {\n                for (idx = 0, length = data.length; idx < length; idx++) {\n                    promises.push(that._promise( { data: converted[idx] }, [ data[idx] ], method));\n                }\n            }\n\n            return promises;\n        },\n\n        read: function(data) {\n            var that = this, params = that._params(data);\n            var deferred = $.Deferred();\n\n            that._queueRequest(params, function() {\n                var isPrevented = that.trigger(REQUESTSTART, { type: \"read\" });\n                if (!isPrevented) {\n                    that.trigger(PROGRESS);\n\n                    that._ranges = [];\n                    that.trigger(\"reset\");\n                    if (that.online()) {\n                        that.transport.read({\n                            data: params,\n                            success: function(data) {\n                                that._ranges = [];\n                                that.success(data, params);\n\n                                deferred.resolve();\n                            },\n                            error: function() {\n                                var args = slice.call(arguments);\n\n                                that.error.apply(that, args);\n\n                                deferred.reject.apply(deferred, args);\n                            }\n                        });\n                    } else if (that.options.offlineStorage != null) {\n                        that.success(that.offlineData(), params);\n\n                        deferred.resolve();\n                    }\n                } else {\n                    that._dequeueRequest();\n\n                    deferred.resolve(isPrevented);\n                }\n            });\n\n            return deferred.promise();\n        },\n\n        _readAggregates: function(data) {\n            return this.reader.aggregates(data);\n        },\n\n        success: function(data) {\n            var that = this,\n                options = that.options,\n                items,\n                replaceSubset;\n\n            that.trigger(REQUESTEND, { response: data, type: \"read\" });\n\n            if (that.online()) {\n                data = that.reader.parse(data);\n\n                if (that._handleCustomErrors(data)) {\n                    that._dequeueRequest();\n                    return;\n                }\n\n                that._total = that.reader.total(data);\n\n                if (that._isServerGroupPaged()) {\n                    that._serverGroupsTotal = that._total;\n                }\n\n                if (that._pageSize > that._total) {\n                    that._pageSize = that._total;\n                    if (that.options.pageSize && that.options.pageSize > that._pageSize) {\n                        that._pageSize = that.options.pageSize;\n                    }\n                }\n\n                if (that._aggregate && options.serverAggregates) {\n                    that._aggregateResult = that._readAggregates(data);\n                }\n\n                data = that._readData(data);\n\n                that._destroyed = [];\n            } else {\n                data = that._readData(data);\n\n                items = [];\n                var itemIds = {};\n                var model = that.reader.model;\n                var idField = model ? model.idField : \"id\";\n                var idx;\n\n                for (idx = 0; idx < this._destroyed.length; idx++) {\n                    var id = this._destroyed[idx][idField];\n                    itemIds[id] = id;\n                }\n\n                for (idx = 0; idx < data.length; idx++) {\n                    var item = data[idx];\n                    var state = item.__state__;\n                    if (state == \"destroy\") {\n                        if (!itemIds[item[idField]]) {\n                            this._pushInDestroyed(this._createNewModel(item));\n                        }\n                    } else {\n                        items.push(item);\n                    }\n                }\n\n                data = items;\n\n                that._total = data.length;\n            }\n\n            that._pristineTotal = that._total;\n            replaceSubset = that._skip && that._data.length && that._skip < that._data.length;\n\n            if (that.options.endless) {\n                if (replaceSubset) {\n                    that._pristineData.splice(that._skip, that._pristineData.length);\n                }\n                items = data.slice(0);\n                for (var j = 0; j < items.length; j++) {\n                    that._pristineData.push(items[j]);\n                }\n            } else {\n                that._pristineData = data.slice(0);\n            }\n\n            that._detachObservableParents();\n\n            if (that.options.endless) {\n                that._data.unbind(CHANGE, that._changeHandler);\n\n                if (that._isServerGrouped() && that._data[that._data.length - 1].value === data[0].value) {\n                    fillLastGroup(that._data[that._data.length - 1], data[0]);\n                    data.shift();\n                }\n\n                data = that._observe(data);\n                if (replaceSubset) {\n                    that._data.splice(that._skip, that._data.length);\n                }\n                for (var i = 0; i < data.length; i++) {\n                    that._data.push(data[i]);\n                }\n                that._data.bind(CHANGE, that._changeHandler);\n            } else {\n                that._data = that._observe(data);\n            }\n\n            that._markOfflineUpdatesAsDirty();\n\n            that._storeData();\n\n            that._addRange(that._data);\n\n            that._process(that._data);\n\n            that._dequeueRequest();\n        },\n\n        _detachObservableParents: function() {\n            if (this._data && this._shouldDetachObservableParents) {\n                for (var idx = 0; idx < this._data.length; idx++) {\n                    if (this._data[idx].parent) {\n                        this._data[idx].parent = noop;\n                    }\n                }\n            }\n        },\n\n        _storeData: function(updatePristine) {\n            var serverGrouping = this._isServerGrouped();\n            var model = this.reader.model;\n\n            function items(data) {\n                var state = [];\n\n                for (var idx = 0; idx < data.length; idx++) {\n                    var dataItem = data.at(idx);\n                    var item = dataItem.toJSON();\n\n                    if (serverGrouping && dataItem.items) {\n                        item.items = items(dataItem.items);\n                    } else {\n                        item.uid = dataItem.uid;\n\n                        if (model) {\n                            if (dataItem.isNew()) {\n                                item.__state__ = \"create\";\n                            } else if (dataItem.dirty) {\n                                item.__state__ = \"update\";\n                            }\n                        }\n                    }\n                    state.push(item);\n                }\n\n                return state;\n            }\n\n            if (this.options.offlineStorage != null) {\n                var state = items(this._data);\n\n                var destroyed = [];\n\n                for (var idx = 0; idx < this._destroyed.length; idx++) {\n                    var item = this._destroyed[idx].toJSON();\n                    item.__state__ = \"destroy\";\n                    destroyed.push(item);\n                }\n\n                this.offlineData(state.concat(destroyed));\n\n                if (updatePristine) {\n                    this._pristineData = this.reader.reader ? this.reader.reader._wrapDataAccessBase(state) : this.reader._wrapDataAccessBase(state);\n                }\n            }\n        },\n\n        _addRange: function(data, skip) {\n            var that = this,\n                start = typeof (skip) !== \"undefined\" ? skip : (that._skip || 0),\n                end,\n                range = {\n                    data: data,\n                    pristineData: data.toJSON(),\n                    timestamp: that._timeStamp()\n                };\n\n            if (this._isGroupPaged()) {\n                end = start + data.length;\n                range.outerStart = start;\n                range.outerEnd = end;\n            } else {\n                end = start + that._flatData(data, true).length;\n            }\n\n            range.start = start;\n            range.end = end;\n            that._ranges.push(range);\n            that._sortRanges();\n\n            if (that._isGroupPaged()) {\n                if (!that._groupsFlat) {\n                    that._groupsFlat = [];\n                }\n                that._appendToGroupsFlat(range.data);\n                that._updateOuterRangesLength();\n            }\n        },\n\n        _appendToGroupsFlat: function(data) {\n            var length = data.length;\n\n            for (var i = 0; i < length; i++) {\n                this._groupsFlat.push(data[i]);\n            }\n        },\n\n        _getGroupByUid: function(uid) {\n            var length = this._groupsFlat.length;\n            var group;\n\n            for (var i = 0; i < length; i++) {\n                group = this._groupsFlat[i];\n                if (group.uid === uid) {\n                    return group;\n                }\n            }\n        },\n\n        _sortRanges: function() {\n            this._ranges.sort(function(x, y) {\n                return x.start - y.start;\n            });\n        },\n\n        error: function(xhr, status, errorThrown) {\n            this._dequeueRequest();\n            this.trigger(REQUESTEND, { });\n            this.trigger(ERROR, { xhr: xhr, status: status, errorThrown: errorThrown });\n        },\n\n        _params: function(data) {\n            var that = this,\n                options = extend({\n                    take: that.take(),\n                    skip: that.skip(),\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                    groupPaging: !!that._groupPaging\n                }, data);\n\n            if (!that.options.serverPaging) {\n                delete options.take;\n                delete options.skip;\n                delete options.page;\n                delete options.pageSize;\n            }\n\n            if (!that.options.serverGrouping) {\n                delete options.group;\n            } else if (that.reader.model && options.group) {\n                options.group = convertDescriptorsField(options.group, that.reader.model);\n            }\n\n            if (!that.options.serverFiltering) {\n                delete options.filter;\n            } else if (that.reader.model && options.filter) {\n               options.filter = convertFilterDescriptorsField(options.filter, that.reader.model);\n            }\n\n            if (!that.options.serverSorting) {\n                delete options.sort;\n            } else if (that.reader.model && options.sort) {\n                options.sort = convertDescriptorsField(options.sort, that.reader.model);\n            }\n\n            if (!that.options.serverAggregates) {\n                delete options.aggregate;\n            } else if (that.reader.model && options.aggregate) {\n                options.aggregate = convertDescriptorsField(options.aggregate, that.reader.model);\n            }\n\n            if (!that.options.groupPaging) {\n                delete options.groupPaging;\n            }\n\n            return options;\n        },\n\n        _queueRequest: function(options, callback) {\n            var that = this;\n            if (!that._requestInProgress) {\n                that._requestInProgress = true;\n                that._pending = undefined$1;\n                callback();\n            } else {\n                that._pending = { callback: callback.bind(that), options: options };\n            }\n        },\n\n        _dequeueRequest: function() {\n            var that = this;\n            that._requestInProgress = false;\n            if (that._pending) {\n                that._queueRequest(that._pending.options, that._pending.callback);\n            }\n        },\n\n        _handleCustomErrors: function(response) {\n            if (this.reader.errors) {\n                var errors = this.reader.errors(response);\n                if (errors) {\n                    this.trigger(ERROR, { xhr: null, status: \"customerror\", errorThrown: \"custom error\", errors: errors });\n                    return true;\n                }\n            }\n            return false;\n        },\n\n        _shouldWrap: function(data) {\n            var model = this.reader.model;\n\n            if (model && data.length) {\n                return !(data[0] instanceof model);\n            }\n\n            return false;\n        },\n\n        _observe: function(data) {\n            var that = this,\n                model = that.reader.model;\n\n            that._shouldDetachObservableParents = true;\n\n            if (data instanceof ObservableArray) {\n                that._shouldDetachObservableParents = false;\n                if (that._shouldWrap(data)) {\n                    data.type = that.reader.model;\n                    data.wrapAll(data, data);\n                }\n            } else {\n                var arrayType = that.pageSize() && !that.options.serverPaging ? LazyObservableArray : ObservableArray;\n                data = new arrayType(data, that.reader.model);\n                data.parent = function() { return that.parent(); };\n            }\n\n            if (that._isServerGrouped()) {\n                wrapGroupItems(data, model);\n            }\n\n            if (that._changeHandler && that._data && that._data instanceof ObservableArray &&\n                !(that.options.useRanges && that.options.serverPaging)) {\n                that._data.unbind(CHANGE, that._changeHandler);\n            } else {\n                that._changeHandler = that._change.bind(that);\n            }\n\n            return data.bind(CHANGE, that._changeHandler);\n        },\n\n        _updateTotalForAction: function(action, items) {\n            var that = this;\n\n            var total = parseInt(that._total, 10);\n\n            if (!isNumber(that._total)) {\n                total = parseInt(that._pristineTotal, 10);\n            }\n            if (action === \"add\") {\n                total += items.length;\n            } else if (action === \"remove\") {\n                total -= items.length;\n            } else if (action !== \"itemchange\" && action !== \"sync\" && !that.options.serverPaging) {\n                total = that._pristineTotal;\n            } else if (action === \"sync\") {\n                total = that._pristineTotal = parseInt(that._total, 10);\n            }\n\n            that._total = total;\n        },\n\n        _pushInDestroyed: function(model) {\n            var isPushed = this._destroyed.find(function(item) {\n                return item.uid === model.uid;\n            });\n            if (!isPushed) {\n                this._destroyed.push(model);\n            }\n        },\n\n        _change: function(e) {\n            var that = this, idx, length, action = e ? e.action : \"\";\n\n            if (action === \"remove\") {\n                for (idx = 0, length = e.items.length; idx < length; idx++) {\n                    if (!e.items[idx].isNew || !e.items[idx].isNew()) {\n                        that._pushInDestroyed(e.items[idx]);\n                    }\n                }\n            }\n\n            if (that.options.autoSync && (action === \"add\" || action === \"remove\" || action === \"itemchange\")) {\n\n                var handler = function(args) {\n                    if (args.action === \"sync\") {\n                        that.unbind(\"change\", handler);\n                        that._updateTotalForAction(action, e.items);\n                    }\n                };\n\n                that.first(\"change\", handler);\n\n                that.sync();\n\n            } else {\n                that._updateTotalForAction(action, e ? e.items : []);\n\n                that._process(that._data, e);\n            }\n        },\n\n        _calculateAggregates: function(data, options) {\n            options = options || {};\n\n            var query = new Query(data),\n                aggregates = options.aggregate,\n                filter = options.filter;\n\n            if (filter) {\n                query = query.filter(filter);\n            }\n\n            return query.aggregate(aggregates);\n        },\n\n        _process: function(data, e) {\n            var that = this,\n                options = {},\n                result;\n\n            if (that.options.serverPaging !== true) {\n                options.skip = that._skip;\n                options.take = that._take || that._pageSize;\n\n                if (options.skip === undefined$1 && that._page !== undefined$1 && that._pageSize !== undefined$1) {\n                    options.skip = (that._page - 1) * that._pageSize;\n                }\n\n                if (that.options.useRanges) {\n                    options.skip = that.currentRangeStart();\n                }\n            }\n\n            if (that.options.serverSorting !== true) {\n                options.sort = that._sort;\n            }\n\n            if (that.options.serverFiltering !== true) {\n                options.filter = that._filter;\n            }\n\n            if (that.options.serverGrouping !== true) {\n                options.group = that._group;\n            }\n\n            if (that.options.serverAggregates !== true) {\n                options.aggregate = that._aggregate;\n            }\n\n            if (that.options.serverGrouping) {\n                that._clearEmptyGroups(data);\n            }\n\n            options.groupPaging = that._groupPaging;\n\n            if (that._isGroupPaged() && e && (e.action === \"page\" || e.action === \"expandGroup\" || e.action === \"collapseGroup\")) {\n                result = that._queryProcess(data, {\n                    aggregate: that._aggregate\n                });\n            } else {\n                result = that._queryProcess(data, options);\n            }\n\n            if (that._filter && e && e.action === \"add\") {\n                var model = e.items[0],\n                    resultData = result.data;\n\n                if (that._isGrouped() && !this._isServerGrouped()) {\n                    resultData = flattenGroups(resultData);\n                }\n\n                var modelIsInView = resultData.find(function(item) {\n                    return item.uid === model.uid;\n                });\n\n                if (!modelIsInView) {\n                    result.data.splice(model.index, 0, that._isGrouped() ? that._wrapInEmptyGroup(model) : model);\n                    result.total++;\n                }\n            }\n\n            if (that.options.serverAggregates !== true) {\n                // for performance reasons, calculate aggregates for part of the data only after query process\n                // this is necessary in the TreeList when paging\n                that._aggregateResult = that._calculateAggregates(result.dataToAggregate || data, options);\n            }\n\n            that._setView(result, options, e);\n\n            that._setFilterTotal(result.total, false);\n\n            e = e || {};\n\n            e.items = e.items || that._view;\n\n            that.trigger(CHANGE, e);\n        },\n\n        _setView: function(result, options, e) {\n            var that = this;\n\n            if (that._isGroupPaged() && !that._isServerGrouped()) {\n                if (e && (e.action === \"page\" || e.action === \"expandGroup\" || e.action === \"collapseGroup\")) {\n                    that.view(result.data);\n                    that._updateOuterRangesLength();\n                } else {\n                    that._ranges = [];\n                    var query = new Query(result.data);\n                    that._addRange(that._observe(result.data));\n\n                    if (options.skip + options.take > result.data.length) {\n                        options.skip = result.data.length - options.take;\n                    }\n\n                    that.view(query.range(options.skip, options.take).toArray());\n                }\n\n            } else {\n                that.view(result.data);\n            }\n        },\n\n        _clearEmptyGroups: function(data) {\n            for (var idx = data.length - 1; idx >= 0; idx--) {\n                var group = data[idx];\n                if (group.hasSubgroups) {\n                    this._clearEmptyGroups(group.items);\n                }\n\n                if (group.items && !group.items.length && !group.itemCount) {\n                    splice.apply(group.parent(), [idx, 1]);\n                }\n            }\n        },\n\n        _queryProcess: function(data, options) {\n            if (this.options.inPlaceSort) {\n                return Query.process(data, options, this.options.inPlaceSort);\n            }\n            else {\n                return Query.process(data, options);\n            }\n        },\n\n        _mergeState: function(options) {\n            var that = this;\n\n            if (options !== undefined$1) {\n                that._pageSize = options.pageSize;\n                that._page = options.page;\n                that._sort = options.sort;\n                that._filter = options.filter;\n                that._group = options.group;\n                that._aggregate = options.aggregate;\n                that._skip = that._currentRangeStart = options.skip;\n                that._take = options.take;\n\n                if (that._skip === undefined$1) {\n                    that._skip = that._currentRangeStart = that.skip();\n                    options.skip = that.skip();\n                }\n\n                if (that._take === undefined$1 && that._pageSize !== undefined$1) {\n                    that._take = that._pageSize;\n                    options.take = that._take;\n                }\n\n                if (that.options.virtual) {\n                    options.virtual = that.options.virtual;\n                }\n\n                if (options.sort) {\n                    that._sort = options.sort = normalizeSort(options.sort);\n                    that._sortFields = sortFields(options.sort);\n                }\n\n                if (options.filter) {\n                    that._filter = options.filter = (that.options.accentFoldingFiltering && !$.isEmptyObject(options.filter)) ? $.extend({}, normalizeFilter(options.filter), { accentFoldingFiltering: that.options.accentFoldingFiltering }) : normalizeFilter(options.filter);\n                }\n\n                if (options.group) {\n                    that._group = options.group = normalizeGroup(options.group);\n                }\n                if (options.aggregate) {\n                    that._aggregate = options.aggregate = normalizeAggregate(options.aggregate);\n                }\n            }\n            return options;\n        },\n\n        query: function(options) {\n            var result;\n            var remote = this.options.serverSorting || this.options.serverPaging || this.options.serverFiltering || this.options.serverGrouping || this.options.serverAggregates;\n\n            if (remote || ((this._data === undefined$1 || this._data.length === 0) && !this._destroyed.length)) {\n                if (this.options.endless) {\n                    var moreItemsCount = options.pageSize - this.pageSize();\n                    if (moreItemsCount > 0) {\n                        moreItemsCount = this.pageSize();\n                        options.page = options.pageSize / moreItemsCount;\n                        options.pageSize = moreItemsCount;\n                    } else {\n                        options.page = 1;\n                        this.options.endless = false;\n                    }\n                }\n                return this.read(this._mergeState(options));\n            }\n\n            var isPrevented = this.trigger(REQUESTSTART, { type: \"read\" });\n            if (!isPrevented) {\n                this.trigger(PROGRESS);\n                if (options) {\n                    options.groupPaging = this._groupPaging;\n                }\n                result = this._queryProcess(this._data, this._mergeState(options));\n\n                this._setFilterTotal(result.total, true);\n\n                this._aggregateResult = this._calculateAggregates(result.dataToAggregate || this._data, options);\n                this._setView(result, options);\n                this.trigger(REQUESTEND, { type: \"read\" });\n                this.trigger(CHANGE, { items: result.data, action: options ? options.action : \"\" });\n            }\n\n            return $.Deferred().resolve(isPrevented).promise();\n        },\n\n        _hasExpandedSubGroups: function(group) {\n            var result = false;\n            var length = group.items ? group.items.length : 0;\n\n            if (!group.hasSubgroups) {\n                return false;\n            }\n\n            for (var i = 0; i < length; i++) {\n                if (this._groupsState[group.items[i].uid]) {\n                    result = true;\n                    break;\n                }\n            }\n            return result;\n        },\n\n        _findGroupedRange: function(data, result, options, parents, callback) {\n            var that = this;\n            var length = data.length;\n            var group;\n            var current;\n            var itemsLength;\n            var groupCount;\n            var itemsToSkip;\n\n            for (var i = 0; i < length; i++) {\n                group = data[i];\n\n                if (options.taken >= options.take) {\n                    break;\n                }\n\n                if (!that._getGroupByUid(group.uid)) {\n                    that._groupsFlat.push(group);\n                }\n\n                if (that._groupsState[group.uid]) {\n                    if (that._isServerGroupPaged()) {\n                       if (that._fetchGroupItems(group, options, parents, callback)) {\n                            that._fetchingGroupItems = true;\n                            return;\n                       }\n                       groupCount = (group.subgroupCount || group.itemCount) + 1;\n                       itemsToSkip = options.skip - options.skipped;\n                       if (!that._hasExpandedSubGroups(group) && itemsToSkip > groupCount) {\n                           options.skipped += groupCount;\n                           continue;\n                       }\n                    }\n\n                    if (options.includeParents && options.skipped < options.skip) {\n                        options.skipped++;\n                        group.excludeHeader = true;\n                    } else if (options.includeParents) {\n                        options.taken++;\n                        group.excludeHeader = false;\n                    }\n\n                    if (group.hasSubgroups && group.items && group.items.length) {\n                        group.currentItems = [];\n\n                        if (!parents) {\n                            parents = [];\n                        }\n                        parents.push(group);\n\n                        that._findGroupedRange(group.items, group.currentItems, options, parents, callback);\n                        parents.pop();\n\n                        if (group.currentItems.length || options.taken > 0) {\n                            result.push(group);\n                        } else {\n                            group.excludeHeader = false;\n                        }\n                    } else {\n                        current = [];\n                        itemsLength = group.items.length;\n\n                        for (var j = 0; j < itemsLength; j++) {\n                            if (options.skipped < options.skip) {\n                                options.skipped++;\n                                continue;\n                            }\n\n                            if (options.taken >= options.take) {\n                                break;\n                            }\n                            current.push(group.items[j]);\n                            options.taken++;\n                        }\n\n                        if (current.length || options.taken > 0) {\n                            group.currentItems = current;\n                            result.push(group);\n                        } else {\n                            group.excludeHeader = false;\n                        }\n                    }\n                } else {\n                    if (options.skipped < options.skip) {\n                        options.skipped++;\n                        continue;\n                    }\n                    result.push(group);\n                    options.taken++;\n                }\n            }\n        },\n\n        _expandedSubGroupItemsCount: function(group, end, includeCurrentItems) {\n            var that = this;\n            var result = 0;\n            var subGroup;\n            var endSpecified = typeof end === \"number\";\n            var length = endSpecified ? end : group.subgroupCount;\n            var temp;\n\n            if (!group.hasSubgroups) {\n                return result;\n            }\n\n            for (var i = 0; i < length; i++) {\n                subGroup = group.items[i];\n\n                if (!subGroup) {\n                    break;\n                }\n\n                if (subGroup.hasSubgroups && that._groupsState[group.uid]) {\n                    temp = that._expandedSubGroupItemsCount(subGroup, length, true);\n                    result += temp;\n\n                    if (endSpecified) {\n                        length -= temp;\n                    }\n                } else if (!subGroup.hasSubgroups && that._groupsState[subGroup.uid]) {\n                    temp = subGroup.items ? subGroup.items.length : 0;\n                    result += temp;\n                    if (endSpecified) {\n                        length -= temp;\n                    }\n                }\n\n                if (includeCurrentItems) {\n                    result += 1;\n                    if (endSpecified) {\n                        length -= 1;\n                    }\n                }\n\n                if (endSpecified && result > length) {\n                    return result;\n                }\n            }\n\n            return result;\n        },\n\n        _fetchGroupItems: function(group, options, parents, callback) {\n            var that = this;\n            var groupItemsSkip;\n            var firstItem;\n            var lastItem;\n            var groupItemCount = group.hasSubgroups ? group.subgroupCount : group.itemCount;\n            var take = options.take;\n            var skipped = options.skipped;\n            var pageSize = that.take();\n            var expandedSubGroupItemsCount;\n\n            if (options.includeParents) {\n                if (skipped < options.skip) {\n                    skipped += 1;\n                } else {\n                    take -= 1;\n                }\n            }\n\n            if (!group.items || (group.items && !group.items.length)) {\n                that.getGroupItems(group, options, parents, callback, 0);\n                return true;\n            } else {\n                expandedSubGroupItemsCount = this._expandedSubGroupItemsCount(group, options.skip - skipped);\n                groupItemsSkip = Math.max(options.skip - (skipped + expandedSubGroupItemsCount), 0);\n\n                if (groupItemsSkip >= groupItemCount) {\n                    return false;\n                }\n\n                firstItem = group.items[groupItemsSkip];\n                lastItem = group.items[Math.min(groupItemsSkip + take, groupItemCount - 1)];\n\n                if (firstItem.notFetched) {\n                    that.getGroupItems(group, options, parents, callback, math.max(math.floor(groupItemsSkip / pageSize), 0) * pageSize, math.round((groupItemsSkip + pageSize) / pageSize));\n                    return true;\n                }\n\n                if (lastItem.notFetched) {\n                    that.getGroupItems(group, options, parents, callback, math.max(math.floor((groupItemsSkip + pageSize) / pageSize), 0) * pageSize, math.round((groupItemsSkip + pageSize) / pageSize));\n                    return true;\n                }\n            }\n        },\n\n        getGroupItems: function(group, options, parents, callback, groupItemsSkip, page) {\n            var that = this;\n            var take;\n            var filter;\n            var data;\n            var subgroups;\n\n            if (!group.items) {\n                group.items = [];\n            }\n\n            take = that.take();\n            filter = this._composeItemsFilter(group, parents);\n            data = {\n                page: page || 1,\n                pageSize: take,\n                skip: groupItemsSkip,\n                take: take,\n                filter: filter,\n                aggregate: that._aggregate,\n                sort: that._sort\n            };\n            subgroups = that.findSubgroups(group);\n\n            if (subgroups && subgroups.length) {\n                data.group = subgroups;\n                data.groupPaging = true;\n            }\n\n            clearTimeout(that._timeout);\n            that._timeout = setTimeout(function() {\n                that._queueRequest(data, function() {\n                    if (!that.trigger(REQUESTSTART, {\n                            type: \"read\"\n                        })) {\n                        that.transport.read({\n                            data: data,\n                            success: that._groupItemsSuccessHandler(group, options.skip, that.take(), callback, groupItemsSkip),\n                            error: function() {\n                                var args = slice.call(arguments);\n                                that.error.apply(that, args);\n                            }\n                        });\n                    } else {\n                        that._dequeueRequest();\n                    }\n                });\n            }, 100);\n        },\n\n        _groupItemsSuccessHandler: function(group, skip, take, callback, groupItemsSkip) {\n            var that = this;\n            var timestamp = that._timeStamp();\n            callback = isFunction(callback) ? callback : noop;\n            var totalField = that.options.schema && that.options.schema.total ? that.options.schema.total : \"Total\";\n\n            return function(data) {\n                var temp;\n                var model = Model.define(that.options.schema.model);\n                var totalCount;\n\n                that._dequeueRequest();\n\n                that.trigger(REQUESTEND, {\n                    response: data,\n                    type: \"read\"\n                });\n\n                if (isFunction(totalField)) {\n                    totalCount = totalField(data);\n                } else {\n                    totalCount = data[totalField];\n                }\n\n                data = that.reader.parse(data);\n\n                if (group.hasSubgroups) {\n                    temp = that.reader.groups(data);\n                    group.subgroupCount = totalCount;\n                } else {\n                    temp = that.reader.data(data);\n                    temp = temp.map(function(item) {\n                        return new model(item);\n                    });\n                }\n\n                group.items.omitChangeEvent = true;\n                for (var i = 0; i < totalCount; i++) {\n                    if (i >= groupItemsSkip && i < (groupItemsSkip + take) ) {\n                        group.items.splice(i, 1, temp[i - groupItemsSkip]);\n                    } else {\n                        if (!group.items[i]) {\n                            group.items.splice(i, 0, { notFetched: true });\n                        }\n                    }\n                }\n                group.items.omitChangeEvent = false;\n\n                that._updateRangePristineData(group);\n                that._fetchingGroupItems = false;\n\n                if (!group.countAdded) {\n                    that._serverGroupsTotal += totalCount;\n                    group.countAdded = true;\n                }\n\n                that.range(skip, take, callback, \"expandGroup\");\n\n                if (timestamp >= that._currentRequestTimeStamp || !that._skipRequestsInProgress) {\n                    that.trigger(CHANGE, {});\n                }\n            };\n        },\n\n        findSubgroups: function(group) {\n            var indexOfCurrentGroup = this._group.map(function(g) {\n                return g.field;\n            }).indexOf(group.field);\n\n            return this._group.slice(indexOfCurrentGroup + 1, this._group.length);\n        },\n\n        _composeItemsFilter: function(group, parents) {\n            var filter = {\n                logic: \"and\",\n                filters: []\n            };\n\n            if (this.filter()) {\n                filter.filters.push(this.filter());\n            }\n\n            filter = extend(true, {}, filter);\n            filter.filters.push({\n                field: group.field,\n                operator: \"eq\",\n                value: group.value\n            });\n\n            if (parents) {\n                for (var i = 0; i < parents.length; i++) {\n                    filter.filters.push({\n                        field: parents[i].field,\n                        operator: \"eq\",\n                        value: parents[i].value\n                    });\n                }\n            }\n\n            return filter;\n        },\n\n        _updateRangePristineData: function(group) {\n            var that = this;\n            var ranges = that._ranges;\n            var rangesLength = ranges.length;\n            var temp;\n            var currentGroup;\n            var range;\n            var dataLength;\n            var indexes;\n            var currIdx;\n\n            for (var i = 0; i < rangesLength; i++) {\n                range = ranges[i];\n                dataLength = range.data.length;\n                indexes = [];\n                temp = null;\n\n                for (var j = 0; j < dataLength; j++) {\n                    currentGroup = range.data[j];\n                    indexes.push(j);\n\n                    if ((currentGroup.uid === group.uid) || (currentGroup.hasSubgroups && currentGroup.items.length && that._containsSubGroup(currentGroup, group, indexes))) {\n                        break;\n                    }\n                    indexes.pop();\n                }\n\n                if (indexes.length) {\n                    temp = ranges[i].pristineData;\n\n                    while (indexes.length > 1) {\n                        currIdx = indexes.splice(0, 1)[0];\n                        temp = temp[currIdx].items;\n                    }\n                    temp[indexes[0]] = that._cloneGroup(group);\n                    break;\n                }\n            }\n        },\n\n        _containsSubGroup: function(group, subgroup, indexes) {\n            var that = this;\n            var length = group.items.length;\n            var currentSubGroup;\n\n            if (group.hasSubgroups && length) {\n                for (var i = 0; i < length; i++) {\n                    currentSubGroup = group.items[i];\n                    indexes.push(i);\n                    if (currentSubGroup.uid === subgroup.uid ||\n                            (currentSubGroup.hasSubgroups &&\n                            currentSubGroup.items.length &&\n                            that._containsSubGroup(currentSubGroup, subgroup, indexes))) {\n                        return true;\n                    }\n                    indexes.pop();\n                }\n            }\n\n        },\n\n        _cloneGroup: function(group) {\n            var that = this;\n            group = typeof group.toJSON == \"function\" ? group.toJSON() : group;\n\n            if (group.items && group.items.length) {\n                group.items = group.items.map(function(item) {\n                    return that._cloneGroup(item);\n                });\n            }\n\n            return group;\n        },\n\n        _setFilterTotal: function(filterTotal, setDefaultValue) {\n            var that = this;\n\n            if (!that.options.serverFiltering) {\n                if (filterTotal !== undefined$1) {\n                    that._total = filterTotal;\n                } else if (setDefaultValue) {\n                    that._total = that._data.length;\n                }\n            }\n        },\n\n        fetch: function(callback) {\n            var that = this;\n            var fn = function(isPrevented) {\n                if (isPrevented !== true && isFunction(callback)) {\n                    callback.call(that);\n                }\n            };\n\n            return this._query().done(fn);\n        },\n\n        _query: function(options) {\n            var that = this;\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            }, options));\n        },\n\n        next: function(options) {\n            var that = this,\n                page = that.page(),\n                total = that.total();\n\n            options = options || {};\n\n            if (!page || (total && page + 1 > that.totalPages())) {\n                return;\n            }\n\n            that._skip = that._currentRangeStart = page * that.take();\n\n            page += 1;\n            options.page = page;\n\n            that._query(options);\n\n            return page;\n        },\n\n        prev: function(options) {\n            var that = this,\n                page = that.page();\n\n            options = options || {};\n\n            if (!page || page === 1) {\n                return;\n            }\n\n            that._skip = that._currentRangeStart = that._skip - that.take();\n\n            page -= 1;\n            options.page = page;\n\n            that._query(options);\n\n            return page;\n        },\n\n        page: function(val) {\n            var that = this,\n            skip;\n\n            if (val !== undefined$1) {\n                val = math.max(math.min(math.max(val, 1), that.totalPages()), 1);\n                var take = that.take();\n\n                if (that._isGroupPaged()) {\n                    val -= 1;\n                    that.range(val * take, take, null, \"page\");\n                    return;\n                }\n                that._query(that._pageableQueryOptions({ page: val }));\n                return;\n            }\n            skip = that.skip();\n\n            return skip !== undefined$1 ? math.round((skip || 0) / (that.take() || 1)) + 1 : undefined$1;\n        },\n\n        pageSize: function(val) {\n            var that = this;\n\n            if (val !== undefined$1) {\n                that._query(that._pageableQueryOptions({ pageSize: val, page: 1 }));\n                return;\n            }\n\n            return that.take();\n        },\n\n        sort: function(val) {\n            var that = this;\n\n            if (val !== undefined$1) {\n                that.trigger(\"sort\");\n                that._query({ sort: val });\n                return;\n            }\n\n            return that._sort;\n        },\n\n        filter: function(val) {\n            var that = this;\n\n            if (val === undefined$1) {\n                return that._filter;\n            }\n\n            that.trigger(\"reset\");\n            that._query({ filter: val, page: 1 });\n        },\n\n        group: function(val) {\n            var that = this;\n            var options = { group: val };\n\n            if (that._groupPaging) {\n                // clear ranges if ungrouping is performed\n                if (val !== undefined$1 && (!val || !val.length) ) {\n                    that._ranges = [];\n                }\n                options.page = 1;\n            }\n\n            if (val !== undefined$1) {\n                that._query(options);\n                return;\n            }\n\n            return that._group;\n        },\n\n        getGroupsFlat: function(data) {\n            var idx,\n                result = [],\n                length;\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                var group = data[idx];\n                if (group.hasSubgroups) {\n                    result = result.concat(this.getGroupsFlat(group.items));\n                }\n\n                result.push(group);\n            }\n\n            return result;\n        },\n\n        total: function() {\n            return parseInt(this._total || 0, 10);\n        },\n\n        groupsTotal: function(includeExpanded) {\n            var that = this;\n\n            if (!that._group.length) {\n                return that.total();\n            }\n\n            if (that._isServerGrouped()) {\n                if (that._serverGroupsTotal) {\n                    return that._serverGroupsTotal;\n                }\n                that._serverGroupsTotal = that.total();\n\n                return that._serverGroupsTotal;\n            }\n\n            return that._calculateGroupsTotal(that._ranges.length ? that._ranges[0].data : [], includeExpanded);\n        },\n\n        _calculateGroupsTotal: function(groups, includeExpanded, itemsField, ignoreState) {\n            var that = this;\n            itemsField = itemsField || \"items\";\n            var total;\n            var length;\n\n            if (that._group.length && groups) {\n                total = 0;\n                length = groups.length;\n\n                for (var i = 0; i < length; i++) {\n                    total += that.groupCount(groups[i], includeExpanded, itemsField, ignoreState);\n                }\n                that._groupsTotal = total;\n                return total;\n            }\n\n            that._groupsTotal = that._data.length;\n            return that._groupsTotal;\n        },\n\n        groupCount: function(group, includeExpanded, itemsField, ignoreState) {\n            var that = this;\n            var total = 0;\n\n            if (group.hasSubgroups && that._groupsState[group.uid]) {\n                if (includeExpanded && !group.excludeHeader || ignoreState) {\n                    total += 1;\n                }\n\n                group[itemsField].forEach(function(subgroup) {\n                    total += that.groupCount(subgroup, includeExpanded, itemsField, ignoreState);\n                });\n            } else {\n                if (that._groupsState[group.uid]) {\n                    if (includeExpanded && !group.excludeHeader || ignoreState) {\n                        total++;\n                    }\n                    total += group[itemsField] ? group[itemsField].length : 0;\n                } else {\n                    total++;\n                }\n            }\n            return total;\n        },\n\n        countGroupRange: function(range) {\n            var total = 0;\n            var length = range.length;\n\n            for (var i = 0; i < length; i++) {\n                total += this.groupCount(range[i], true);\n            }\n\n            return total;\n        },\n\n        aggregate: function(val) {\n            var that = this;\n\n            if (val !== undefined$1) {\n                that._query({ aggregate: val });\n                return;\n            }\n\n            return that._aggregate;\n        },\n\n        aggregates: function() {\n            var result = this._aggregateResult;\n\n            if (isEmptyObject(result)) {\n                result = this._emptyAggregates(this.aggregate());\n            }\n\n            return result;\n        },\n\n        _emptyAggregates: function(aggregates) {\n            var result = {};\n\n            if (!isEmptyObject(aggregates)) {\n                var aggregate = {};\n\n                if (!isArray(aggregates)) {\n                    aggregates = [aggregates];\n                }\n\n                for (var idx = 0; idx < aggregates.length; idx++) {\n                    aggregate[aggregates[idx].aggregate] = 0;\n                    result[aggregates[idx].field] = aggregate;\n                }\n            }\n\n            return result;\n        },\n\n        _pageableQueryOptions: function(options) {\n            return options;\n        },\n\n        _wrapInEmptyGroup: function(model) {\n            var groups = this.group(),\n                parent,\n                group,\n                idx,\n                length;\n\n            for (idx = groups.length - 1, length = 0; idx >= length; idx--) {\n                group = groups[idx];\n                parent = {\n                    value: model.get ? model.get(group.field) : model[group.field],\n                    field: group.field,\n                    items: parent ? [parent] : [model],\n                    hasSubgroups: !!parent,\n                    aggregates: this._emptyAggregates(group.aggregates)\n                };\n            }\n\n            return parent;\n        },\n\n        totalPages: function() {\n            var that = this,\n                pageSize = that.pageSize() || that.total(),\n                total = that._isGroupPaged() ? that.groupsTotal(true) : that.total();\n\n            return math.ceil((total || 0) / pageSize);\n        },\n\n        inRange: function(skip, take) {\n            var that = this,\n                end = math.min(skip + take, that.total());\n\n            if (!that.options.serverPaging && that._data.length > 0) {\n                return true;\n            }\n\n            return that._findRange(skip, end).length > 0;\n        },\n\n        lastRange: function() {\n            var ranges = this._ranges;\n            return ranges[ranges.length - 1] || { start: 0, end: 0, data: [] };\n        },\n\n        firstItemUid: function() {\n            var ranges = this._ranges;\n            return ranges.length && ranges[0].data.length && ranges[0].data[0].uid;\n        },\n\n        enableRequestsInProgress: function() {\n            this._skipRequestsInProgress = false;\n        },\n\n        _timeStamp: function() {\n            return new Date().getTime();\n        },\n\n        range: function(skip, take, callback, action) {\n            this._currentRequestTimeStamp = this._timeStamp();\n            this._skipRequestsInProgress = true;\n            var total = this._isGroupPaged() ? this.groupsTotal(true) : this.total();\n\n            if (action === \"expandGroup\" || action === \"collapseGroup\") {\n                this._updateOuterRangesLength();\n            }\n\n            skip = math.min(skip || 0, total);\n            callback = isFunction(callback) ? callback : noop;\n\n            var that = this,\n                pageSkip = math.max(math.floor(skip / take), 0) * take,\n                size = math.min(pageSkip + take, total),\n                data;\n\n            data = that._findRange(skip, math.min(skip + take, total), callback);\n\n            if ((data.length || total === 0) && !that._fetchingGroupItems) {\n                that._processRangeData(data, skip, take, that._originalPageSkip || pageSkip, that._originalSize || size, {\n                    action: action\n                });\n                that._originalPageSkip = null;\n                that._originalSize = null;\n                callback();\n                return;\n            }\n\n            if (that._isGroupPaged()) {\n                that._originalPageSkip = pageSkip;\n                that._originalSize = size;\n\n                pageSkip = math.max(math.floor(that._adjustPageSkip(skip, take) / take), 0) * take;\n                size = math.min(pageSkip + take, total);\n            }\n\n            if (take !== undefined$1 && !that._fetchingGroupItems) {\n                if ((that._isGroupPaged() && !that._groupRangeExists(pageSkip, take)) || !that._rangeExists(pageSkip, size)) {\n                    that.prefetch(pageSkip, take, function() {\n                        if (skip > pageSkip && size < that.total() && !that._rangeExists(size, math.min(size + take, that.total()))) {\n                            that.prefetch(size, take, function() {\n                                that.range(skip, take, callback );\n                            });\n                        } else {\n                            that.range(skip, take, callback);\n                        }\n                    });\n                } else if (pageSkip < skip) {\n                    that.prefetch(size, take, function() {\n                        that.range(skip, take, callback );\n                    });\n                }\n            }\n        },\n\n        _findRange: function(start, end, callback) {\n            var that = this,\n                ranges = that._ranges,\n                range,\n                data = [],\n                skipIdx,\n                takeIdx,\n                startIndex,\n                endIndex,\n                rangeData,\n                rangeEnd,\n                processed,\n                options = that.options,\n                remote = options.serverSorting || options.serverPaging || options.serverFiltering || options.serverGrouping || options.serverAggregates,\n                flatData,\n                count,\n                length,\n                groupMapOptions = {\n                        take: end - start,\n                        skip: start,\n                        skipped: 0,\n                        taken: 0,\n                        includeParents: true\n                    },\n                prevRangeEnd,\n                isGroupPaged = that._isGroupPaged(),\n                startField = isGroupPaged ? \"outerStart\" : \"start\",\n                endField = isGroupPaged ? \"outerEnd\" : \"end\",\n                currentDataLength;\n\n            for (skipIdx = 0, length = ranges.length; skipIdx < length; skipIdx++) {\n                range = ranges[skipIdx];\n\n                if (isGroupPaged) {\n                    if (range.outerStart >= end) {\n                        return [];\n                    }\n\n                    if (start > range.outerEnd) {\n                        groupMapOptions.skipped += range.outerEnd - (prevRangeEnd || 0);\n                        prevRangeEnd = range.outerEnd;\n                        continue;\n                    }\n\n                    if (typeof prevRangeEnd !== \"undefined\" && prevRangeEnd != range.outerStart) {\n                        groupMapOptions.skipped += range.outerStart - prevRangeEnd;\n                    }\n\n                    if (groupMapOptions.skipped > groupMapOptions.skip) {\n                        return [];\n                    }\n\n                    if (typeof prevRangeEnd === \"undefined\" && start > 0 && range.start > 0) {\n                        groupMapOptions.skipped = range.outerStart;\n                    }\n\n                    takeIdx = skipIdx;\n                    while (true) {\n                        this._findGroupedRange(range.data, data, groupMapOptions, null, callback);\n                        currentDataLength = that._calculateGroupsTotal(data, true, \"currentItems\");\n\n                        if (currentDataLength >= groupMapOptions.take) {\n                            return data;\n                        }\n\n                        if (that._fetchingGroupItems) {\n                            return [];\n                        }\n                        takeIdx++;\n\n                        if (ranges[takeIdx] && ranges[takeIdx].outerStart === range.outerEnd) {\n                            range = ranges[takeIdx];\n                        } else {\n                            break;\n                        }\n                    }\n                } else if (start >= range[startField] && start <= range[endField]) {\n                    count = 0;\n\n                    for (takeIdx = skipIdx; takeIdx < length; takeIdx++) {\n                        range = ranges[takeIdx];\n                        flatData = that._flatData(range.data, true);\n\n                        if (flatData.length && start + count >= range.start) {\n                            rangeData = range.data;\n                            rangeEnd = range.end;\n\n                            if (!remote) {\n                                if (options.inPlaceSort) {\n                                    processed = that._queryProcess(range.data, { filter: that.filter() });\n                                } else {\n                                    var sort = normalizeGroupWithoutCompare(that.group() || []).concat(normalizeSort(that.sort() || []));\n                                    processed = that._queryProcess(range.data, { sort: sort, filter: that.filter() });\n                                }\n                                flatData = rangeData = processed.data;\n\n                                if (processed.total !== undefined$1) {\n                                    rangeEnd = processed.total;\n                                }\n                            }\n\n                            startIndex = 0;\n                            if (start + count > range.start) {\n                                startIndex = (start + count) - range.start;\n                            }\n                            endIndex = flatData.length;\n                            if (rangeEnd > end) {\n                                endIndex = endIndex - (rangeEnd - end);\n                            }\n                            count += endIndex - startIndex;\n                            data = that._mergeGroups(data, rangeData, startIndex, endIndex);\n\n                            if (end <= range.end && count == end - start) {\n                                return data;\n                            }\n                        }\n                    }\n                    break;\n                }\n                prevRangeEnd = range.outerEnd;\n            }\n            return [];\n        },\n\n        _getRangesMismatch: function(pageSkip) {\n            var that = this;\n            var ranges = that._ranges;\n            var mismatch = 0;\n            var i = 0;\n\n            while (true) {\n                var range = ranges[i];\n                if (!range || range.outerStart > pageSkip) {\n                    break;\n                }\n\n                if (range.outerEnd != range.end) {\n                    mismatch = range.outerEnd - range.end;\n                }\n                i++;\n            }\n\n            return mismatch;\n        },\n\n        _mergeGroups: function(data, range, skip, take) {\n            if (this._isServerGrouped()) {\n                var temp = range.toJSON(),\n                    prevGroup;\n\n                if (data.length) {\n                    prevGroup = data[data.length - 1];\n                }\n\n                mergeGroups(prevGroup, temp, skip, take);\n\n                return data.concat(temp);\n            }\n            return data.concat(range.slice(skip, take));\n        },\n\n        _processRangeData: function(data, skip, take, pageSkip, size, eventData) {\n            var that = this;\n\n            that._pending = undefined$1;\n\n            that._skip = skip > that.skip() && !that._omitPrefetch ? math.min(size, (that.totalPages() - 1) * that.take()) : pageSkip;\n\n            that._currentRangeStart = skip;\n\n            that._take = take;\n\n            var paging = that.options.serverPaging;\n            var sorting = that.options.serverSorting;\n            var filtering = that.options.serverFiltering;\n            var aggregates = that.options.serverAggregates;\n            try {\n                that.options.serverPaging = true;\n                if (!that._isServerGrouped() && !(that.group() && that.group().length)) {\n                    that.options.serverSorting = true;\n                }\n                that.options.serverFiltering = true;\n                that.options.serverPaging = true;\n                that.options.serverAggregates = true;\n\n                if (paging) {\n                    that._detachObservableParents();\n                    that._data = data = that._observe(data);\n                }\n                that._process(data, eventData);\n            } finally {\n                that.options.serverPaging = paging;\n                that.options.serverSorting = sorting;\n                that.options.serverFiltering = filtering;\n                that.options.serverAggregates = aggregates;\n            }\n        },\n\n        skip: function() {\n            var that = this;\n\n            if (that._skip === undefined$1) {\n                return (that._page !== undefined$1 ? (that._page - 1) * (that.take() || 1) : undefined$1);\n            }\n            return that._skip;\n        },\n\n        currentRangeStart: function() {\n            return this._currentRangeStart || 0;\n        },\n\n        take: function() {\n            return this._take || this._pageSize;\n        },\n\n        _prefetchSuccessHandler: function(skip, size, callback, force) {\n            var that = this;\n            var timestamp = that._timeStamp();\n\n            return function(data) {\n                var found = false,\n                    range = { start: skip, end: size, data: [], timestamp: that._timeStamp() },\n                    idx,\n                    length,\n                    temp;\n\n                that._dequeueRequest();\n\n                that.trigger(REQUESTEND, { response: data, type: \"read\" });\n\n                data = that.reader.parse(data);\n\n                temp = that._readData(data);\n\n                if (temp.length) {\n                    for (idx = 0, length = that._ranges.length; idx < length; idx++) {\n                        if (that._ranges[idx].start === skip) {\n                            found = true;\n                            range = that._ranges[idx];\n\n                            if (!that._isGroupPaged()) {\n                                range.pristineData = temp;\n                                range.data = that._observe(temp);\n                                range.end = range.start + that._flatData(range.data, true).length;\n                                that._sortRanges();\n                            }\n\n                            break;\n                        }\n                    }\n\n                    if (!found) {\n                        that._addRange(that._observe(temp), skip);\n                    }\n                }\n\n                that._total = that.reader.total(data);\n\n                if (force || (timestamp >= that._currentRequestTimeStamp || !that._skipRequestsInProgress)) {\n                    if (callback && temp.length) {\n                        callback();\n                    } else {\n                        that.trigger(CHANGE, {});\n                    }\n                }\n            };\n        },\n\n        prefetch: function(skip, take, callback) {\n            var that = this,\n                size = math.min(skip + take, that.total()),\n                options = {\n                    take: take,\n                    skip: skip,\n                    page: skip / take + 1,\n                    pageSize: take,\n                    sort: that._sort,\n                    filter: that._filter,\n                    group: that._group,\n                    aggregate: that._aggregate\n                };\n\n\n            if ((that._isGroupPaged() && !that._isServerGrouped() && that._groupRangeExists(skip, size))) {\n                if (callback) {\n                    callback();\n                }\n                return;\n            }\n\n            if ((that._isServerGroupPaged() && !that._groupRangeExists(skip, size)) || !that._rangeExists(skip, size)) {\n                clearTimeout(that._timeout);\n\n                that._timeout = setTimeout(function() {\n                    that._queueRequest(options, function() {\n                        if (!that.trigger(REQUESTSTART, { type: \"read\" })) {\n                            if (that._omitPrefetch) {\n                                that.trigger(PROGRESS);\n                            }\n                            that.transport.read({\n                                data: that._params(options),\n                                success: that._prefetchSuccessHandler(skip, size, callback),\n                                error: function() {\n                                    var args = slice.call(arguments);\n                                    that.error.apply(that, args);\n                                }\n                            });\n                        } else {\n                            that._dequeueRequest();\n                        }\n                    });\n                }, 100);\n            } else if (callback) {\n                callback();\n            }\n        },\n\n        _multiplePrefetch: function(skip, take, callback) {\n            var that = this,\n                size = math.min(skip + take, that.total()),\n                options = {\n                    take: take,\n                    skip: skip,\n                    page: skip / take + 1,\n                    pageSize: take,\n                    sort: that._sort,\n                    filter: that._filter,\n                    group: that._group,\n                    aggregate: that._aggregate\n                };\n\n            if (!that._rangeExists(skip, size)) {\n                if (!that.trigger(REQUESTSTART, { type: \"read\" })) {\n                    that.transport.read({\n                        data: that._params(options),\n                        success: that._prefetchSuccessHandler(skip, size, callback, true)\n                    });\n                }\n            } else if (callback) {\n                callback();\n            }\n        },\n\n        _adjustPageSkip: function(start, take) {\n            var that = this;\n            var prevRange = that._getPrevRange(start);\n            var result;\n            var total = that.total();\n            var mismatch;\n\n            if (prevRange) {\n                mismatch = that._getRangesMismatch(start);\n\n                if (!mismatch) {\n                    return start;\n                }\n                start -= mismatch;\n            }\n            result = math.max(math.floor(start / take), 0) * take;\n\n            if (result > total) {\n                while (true) {\n                    result -= take;\n                    if (result < total) {\n                        break;\n                    }\n                }\n            }\n            return result;\n        },\n\n        _getNextRange: function(end) {\n            var that = this,\n                ranges = that._ranges,\n                idx,\n                length;\n\n            for (idx = 0, length = ranges.length; idx < length; idx++) {\n                if (ranges[idx].start <= end && ranges[idx].end >= end) {\n                    return ranges[idx];\n                }\n            }\n        },\n\n        _getPrevRange: function(start) {\n            var that = this,\n                ranges = that._ranges,\n                idx,\n                range,\n                length = ranges.length;\n\n            for (idx = length - 1; idx >= 0; idx--) {\n                if (ranges[idx].outerStart <= start) {\n                    range = ranges[idx];\n                    break;\n                }\n\n            }\n\n            return range;\n        },\n\n        _rangeExists: function(start, end) {\n            var that = this,\n                ranges = that._ranges,\n                idx,\n                length;\n\n            for (idx = 0, length = ranges.length; idx < length; idx++) {\n                if (ranges[idx].start <= start && ranges[idx].end >= end) {\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        _groupRangeExists: function(start, end) {\n            var that = this,\n                ranges = that._ranges,\n                idx,\n                length,\n                availableItemsCount = 0,\n                total = that.groupsTotal(true);\n\n            if (end > total && !that._isServerGrouped()) {\n                end = total;\n            }\n\n            for (idx = 0, length = ranges.length; idx < length; idx++) {\n                var range = ranges[idx];\n                if (range.outerStart <= start && range.outerEnd >= start) {\n                    availableItemsCount += range.outerEnd - start;\n                } else if (range.outerStart <= end && range.outerEnd >= end) {\n                    availableItemsCount += end - range.outerStart;\n                }\n            }\n\n            return availableItemsCount >= end - start;\n        },\n\n        _getCurrentRangeSpan: function() {\n            var that = this;\n            var ranges = that._ranges;\n            var start = that.currentRangeStart();\n            var end = start + (that.take() || 0);\n            var rangeSpan = [];\n            var range;\n            var idx;\n            var length = ranges.length;\n\n            for (idx = 0; idx < length; idx++) {\n                range = ranges[idx];\n\n                if ((range.start <= start && range.end >= start) || (range.start >= start && range.start <= end)) {\n                    rangeSpan.push(range);\n                }\n            }\n\n            return rangeSpan;\n        },\n\n        _removeModelFromRanges: function(model) {\n            var that = this;\n            var range;\n\n            for (var idx = 0, length = this._ranges.length; idx < length; idx++) {\n                range = this._ranges[idx];\n\n                that._removeModelFromRange(range, model);\n            }\n\n            that._updateRangesLength();\n        },\n\n        _removeModelFromRange: function(range, model) {\n            this._eachItem(range.data, function(data) {\n                if (!data) {\n                    return;\n                }\n                for (var idx = 0; idx < data.length; idx++) {\n                    var dataItem = data[idx];\n\n                    if (dataItem.uid && dataItem.uid == model.uid) {\n                        [].splice.call(data, idx, 1);\n                        break;\n                    }\n                }\n            });\n        },\n\n        _insertModelInRange: function(index, model) {\n            var that = this;\n            var ranges = that._ranges || [];\n            var rangesLength = ranges.length;\n            var range;\n            var i;\n\n            for (i = 0; i < rangesLength; i++) {\n                range = ranges[i];\n\n                if (range.start <= index && range.end >= index) {\n                    if (!that._getByUid(model.uid, range.data)) {\n                        if (that._isServerGrouped()) {\n                            range.data.splice(index, 0, that._wrapInEmptyGroup(model));\n                        } else {\n                            range.data.splice(index, 0, model);\n                        }\n                    }\n\n                    break;\n                }\n            }\n\n            that._updateRangesLength();\n        },\n\n        _updateRangesLength: function() {\n            var that = this;\n            var ranges = that._ranges || [];\n            var rangesLength = ranges.length;\n            var mismatchFound = false;\n            var mismatchLength = 0;\n            var lengthDifference = 0;\n            var rangeLength;\n            var range;\n            var i;\n\n            for (i = 0; i < rangesLength; i++) {\n                range = ranges[i];\n                rangeLength = that._isGroupPaged() ? range.data.length : that._flatData(range.data, true).length;\n                lengthDifference = rangeLength - math.abs(range.end - range.start);\n\n                if (!mismatchFound && lengthDifference !== 0) {\n                    mismatchFound = true;\n                    mismatchLength = lengthDifference;\n                    range.end += mismatchLength;\n                    continue;\n                }\n\n                if (mismatchFound) {\n                    range.start += mismatchLength;\n                    range.end += mismatchLength;\n                }\n            }\n        },\n\n        _updateOuterRangesLength: function() {\n            var that = this;\n            var ranges = that._ranges || [];\n            var rangesLength = ranges.length;\n            var mismatchLength = 0;\n            var range;\n            var i;\n            var prevRange;\n            var rangeLength;\n\n            for (i = 0; i < rangesLength; i++) {\n                range = ranges[i];\n                rangeLength = that._isGroupPaged() ? that._calculateGroupsTotal(range.data, true, \"items\", true) : that._flatData(range.data, true).length;\n\n                if (prevRange) {\n                    if (prevRange.end != range.start) {\n                        mismatchLength = range.start - prevRange.end;\n                    }\n                    range.outerStart = prevRange.outerEnd + mismatchLength;\n                    mismatchLength = 0;\n                } else {\n                    range.outerStart = range.start;\n                }\n\n                range.outerEnd = range.outerStart + rangeLength;\n                prevRange = range;\n            }\n        }\n    });\n\n    var Transport = {};\n\n    Transport.create = function(options, data, dataSource) {\n        var transport,\n            transportOptions = options.transport ? $.extend({}, options.transport) : null;\n\n        if (transportOptions) {\n            transportOptions.read = typeof transportOptions.read === STRING ? { url: transportOptions.read } : transportOptions.read;\n\n            if (options.type === \"jsdo\") {\n                transportOptions.dataSource = dataSource;\n            }\n\n            if (options.type) {\n                kendo.data.transports = kendo.data.transports || {};\n                kendo.data.schemas = kendo.data.schemas || {};\n\n                if (!kendo.data.transports[options.type]) {\n                    kendo.logToConsole(\"Unknown DataSource transport type '\" + options.type + \"'.\\nVerify that registration scripts for this type are included after Kendo UI on the page.\", \"warn\");\n                } else if (!isPlainObject(kendo.data.transports[options.type])) {\n                    transport = new kendo.data.transports[options.type](extend(transportOptions, { data: data }));\n                } else {\n                    transportOptions = extend(true, {}, kendo.data.transports[options.type], transportOptions);\n                }\n\n                options.schema = extend(true, {}, kendo.data.schemas[options.type], options.schema);\n            }\n\n            if (!transport) {\n                transport = isFunction(transportOptions.read) ? transportOptions : new RemoteTransport(transportOptions);\n            }\n        } else {\n            transport = new LocalTransport({ data: options.data || [] });\n        }\n        return transport;\n    };\n\n    DataSource.create = function(options) {\n        if (isArray(options) || options instanceof ObservableArray) {\n           options = { data: options };\n        }\n\n        var dataSource = options || {},\n            data = dataSource.data,\n            fields = dataSource.fields,\n            table = dataSource.table,\n            select = dataSource.select,\n            idx,\n            length,\n            model = {},\n            field;\n\n        if (!data && fields && !dataSource.transport) {\n            if (table) {\n                data = inferTable(table, fields);\n            } else if (select) {\n                data = inferSelect(select, fields);\n\n                if (dataSource.group === undefined$1 && data[0] && data[0].optgroup !== undefined$1) {\n                    dataSource.group = \"optgroup\";\n                }\n            }\n        }\n\n        if (kendo.data.Model && fields && (!dataSource.schema || !dataSource.schema.model)) {\n            for (idx = 0, length = fields.length; idx < length; idx++) {\n                field = fields[idx];\n                if (field.type) {\n                    model[field.field] = field;\n                }\n            }\n\n            if (!isEmptyObject(model)) {\n                dataSource.schema = extend(true, dataSource.schema, { model: { fields: model } });\n            }\n        }\n\n        dataSource.data = data;\n\n        select = null;\n        dataSource.select = null;\n        table = null;\n        dataSource.table = null;\n\n        return dataSource instanceof DataSource ? dataSource : new DataSource(dataSource);\n    };\n\n    function inferSelect(select, fields) {\n        select = $(select)[0];\n        var options = select.options;\n        var firstField = fields[0];\n        var secondField = fields[1];\n\n        var data = [];\n        var idx, length;\n        var optgroup;\n        var option;\n        var record;\n        var value;\n\n        for (idx = 0, length = options.length; idx < length; idx++) {\n            record = {};\n            option = options[idx];\n            optgroup = option.parentNode;\n\n            if (optgroup === select) {\n                optgroup = null;\n            }\n\n            if (option.disabled || (optgroup && optgroup.disabled)) {\n                continue;\n            }\n\n            if (optgroup) {\n                record.optgroup = optgroup.label;\n            }\n\n            record[firstField.field] = option.text;\n\n            value = option.attributes.value;\n\n            if (value && value.specified) {\n                value = option.value;\n            } else {\n                value = option.text;\n            }\n\n            record[secondField.field] = value;\n\n            data.push(record);\n        }\n\n        return data;\n    }\n\n    function inferTable(table, fields) {\n        var tbody = $(table)[0].tBodies[0],\n        rows = tbody ? tbody.rows : [],\n        idx,\n        length,\n        fieldIndex,\n        fieldCount = fields.length,\n        data = [],\n        cells,\n        record,\n        cell,\n        empty;\n\n        for (idx = 0, length = rows.length; idx < length; idx++) {\n            record = {};\n            empty = true;\n            cells = rows[idx].cells;\n\n            for (fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++) {\n                cell = cells[fieldIndex];\n                if (cell.nodeName.toLowerCase() !== \"th\") {\n                    empty = false;\n                    record[fields[fieldIndex].field] = cell.innerHTML;\n                }\n            }\n            if (!empty) {\n                data.push(record);\n            }\n        }\n\n        return data;\n    }\n\n    var Node = Model.define({\n        idField: \"id\",\n\n        init: function(value) {\n            var that = this,\n                hasChildren = that.hasChildren || value && value.hasChildren,\n                childrenField = \"items\",\n                childrenOptions = {};\n\n            kendo.data.Model.fn.init.call(that, value);\n\n            if (typeof that.children === STRING) {\n                childrenField = that.children;\n            }\n\n            childrenOptions = {\n                schema: {\n                    data: childrenField,\n                    model: {\n                        hasChildren: hasChildren,\n                        id: that.idField,\n                        fields: that.fields\n                    }\n                }\n            };\n\n            if (typeof that.children !== STRING) {\n                extend(childrenOptions, that.children);\n            }\n\n            childrenOptions.data = value;\n\n            if (!hasChildren) {\n                hasChildren = childrenOptions.schema.data;\n            }\n\n            if (typeof hasChildren === STRING) {\n                hasChildren = kendo.getter(hasChildren);\n            }\n\n            if (isFunction(hasChildren)) {\n                var hasChildrenObject = hasChildren.call(that, that);\n\n                if (hasChildrenObject && hasChildrenObject.length === 0) {\n                    that.hasChildren = false;\n                } else {\n                    that.hasChildren = !!hasChildrenObject;\n                }\n            }\n\n            that._childrenOptions = childrenOptions;\n\n            if (that.hasChildren) {\n                that._initChildren();\n            }\n\n            that._loaded = !!(value && value._loaded);\n        },\n\n        _initChildren: function() {\n            var that = this;\n            var children, transport, parameterMap;\n\n            if (!(that.children instanceof HierarchicalDataSource)) {\n                children = that.children = new HierarchicalDataSource(that._childrenOptions);\n\n                transport = children.transport;\n                parameterMap = transport.parameterMap;\n\n                transport.parameterMap = function(data, type) {\n                    data[that.idField || \"id\"] = that.id;\n\n                    if (parameterMap) {\n                        data = parameterMap.call(that, data, type);\n                    }\n\n                    return data;\n                };\n\n                children.parent = function() {\n                    return that;\n                };\n\n                children.bind(CHANGE, function(e) {\n                    e.node = e.node || that;\n                    that.trigger(CHANGE, e);\n                });\n\n                children.bind(ERROR, function(e) {\n                    var collection = that.parent();\n\n                    if (collection) {\n                        e.node = e.node || that;\n                        collection.trigger(ERROR, e);\n                    }\n                });\n\n                children.bind(ITEMSLOADED, function(e) {\n                    var collection = that.parent();\n\n                    if (collection) {\n                        collection.trigger(ITEMSLOADED, e);\n                    }\n                });\n\n                that._updateChildrenField();\n            }\n        },\n\n        append: function(model) {\n            this._initChildren();\n            this.loaded(true);\n            this.children.add(model);\n        },\n\n        hasChildren: false,\n\n        level: function() {\n            var parentNode = this.parentNode(),\n                level = 0;\n\n            while (parentNode && parentNode.parentNode) {\n                level++;\n                parentNode = parentNode.parentNode ? parentNode.parentNode() : null;\n            }\n\n            return level;\n        },\n\n        _updateChildrenField: function() {\n            var fieldName = this._childrenOptions.schema.data;\n\n            this[fieldName || \"items\"] = this.children.data();\n        },\n\n        _childrenLoaded: function() {\n            this._loaded = true;\n\n            this._updateChildrenField();\n        },\n\n        load: function() {\n            var options = {};\n            var method = \"_query\";\n            var children, promise;\n\n            if (this.hasChildren) {\n                this._initChildren();\n\n                children = this.children;\n\n                options[this.idField || \"id\"] = this.id;\n\n                if (!this._loaded) {\n                    children._data = undefined$1;\n                    method = \"read\";\n                }\n\n                children.one(CHANGE, this._childrenLoaded.bind(this));\n\n                if (this._matchFilter) {\n                    options.filter = { field: '_matchFilter', operator: 'eq', value: true };\n                }\n\n                promise = children[method](options);\n                if (!this._loaded) {\n                    this.trigger(ITEMLOAD, { promise: promise, node: this });\n                }\n            } else {\n                this.loaded(true);\n            }\n\n            return promise || $.Deferred().resolve().promise();\n        },\n\n        parentNode: function() {\n            var array = this.parent();\n\n            return array.parent();\n        },\n\n        loaded: function(value) {\n            if (value !== undefined$1) {\n                this._loaded = value;\n            } else {\n                return this._loaded;\n            }\n        },\n\n        shouldSerialize: function(field) {\n            return Model.fn.shouldSerialize.call(this, field) &&\n                    field !== \"children\" &&\n                    field !== \"_loaded\" &&\n                    field !== \"hasChildren\" &&\n                    field !== \"_childrenOptions\";\n        }\n    });\n\n    function dataMethod(name) {\n        return function() {\n            var data = this._data,\n                result = DataSource.fn[name].apply(this, slice.call(arguments));\n\n            if (this._data != data) {\n                this._attachBubbleHandlers();\n            }\n\n            return result;\n        };\n    }\n\n    var HierarchicalDataSource = DataSource.extend({\n        init: function(options) {\n            var node = Node.define({\n                children: options\n            });\n\n            if (options.filter && !options.serverFiltering) {\n                this._hierarchicalFilter = options.filter;\n                options.filter = null;\n            }\n\n            DataSource.fn.init.call(this, extend(true, {}, { schema: { modelBase: node, model: node } }, options));\n\n            this._attachBubbleHandlers();\n        },\n\n        _attachBubbleHandlers: function() {\n            var that = this;\n\n            that._data.bind(ERROR, function(e) {\n                that.trigger(ERROR, e);\n            });\n\n            that._data.bind(ITEMSLOADED, function(e) {\n                that.trigger(ITEMSLOADED, e);\n            });\n        },\n\n        loading: function() {\n            if (this._data) {\n                return this._data.loading() || this._childrenLoading();\n            }\n            return false;\n        },\n\n        _childrenLoading: function() {\n            var isLoading = false;\n            this._data.forEach(function(node) {\n                if (node.hasChildren && node.children.loading()) {\n                    isLoading = true;\n                }\n            });\n            return isLoading;\n        },\n\n        read: function(data) {\n            var result = DataSource.fn.read.call(this, data);\n\n            if (this._hierarchicalFilter) {\n                if (this._data && this._data.length > 0) {\n                    this.filter(this._hierarchicalFilter);\n                } else {\n                    this.options.filter = this._hierarchicalFilter;\n                    this._filter = normalizeFilter(this.options.filter);\n                    this._hierarchicalFilter = null;\n                }\n            }\n\n            return result;\n        },\n\n        remove: function(node) {\n            var parentNode = node.parentNode(),\n                dataSource = this,\n                result;\n\n            if (parentNode && parentNode._initChildren) {\n                dataSource = parentNode.children;\n            }\n\n            result = DataSource.fn.remove.call(dataSource, node);\n\n            if (parentNode && !dataSource.data().length) {\n                parentNode.hasChildren = false;\n            }\n\n            return result;\n        },\n\n        success: dataMethod(\"success\"),\n\n        data: dataMethod(\"data\"),\n\n        insert: function(index, model) {\n            var parentNode = this.parent();\n\n            if (parentNode && parentNode._initChildren) {\n                parentNode.hasChildren = true;\n                parentNode._initChildren();\n            }\n\n            return DataSource.fn.insert.call(this, index, model);\n        },\n\n        filter: function(val) {\n            if (val === undefined$1) {\n                 return this._filter;\n            }\n\n            if (!this.options.serverFiltering && this._markHierarchicalQuery(val)) {\n                val = { logic: \"or\", filters: [val, { field: '_matchFilter', operator: 'equals', value: true }] };\n            }\n\n            this.trigger(\"reset\");\n            this._query({ filter: val, page: 1 });\n        },\n\n        _markHierarchicalQuery: function(expressions) {\n            var compiled;\n            var accentFoldingFiltering = this.options.accentFoldingFiltering;\n\n            expressions = accentFoldingFiltering ? $.extend({}, normalizeFilter(expressions), { accentFoldingFiltering: accentFoldingFiltering }) : normalizeFilter(expressions);\n\n            if (!expressions || expressions.filters.length === 0) {\n                this._updateHierarchicalFilter(function() {return true;});\n                return false;\n            }\n\n            compiled = Query.filterExpr(expressions, { noEval: true });\n\n            this._updateHierarchicalFilter(compiled);\n            return true;\n        },\n\n         _updateHierarchicalFilter: function(filter) {\n            var current;\n            var data = this._data;\n            var result = false;\n\n            for (var idx = 0; idx < data.length; idx++) {\n                 current = data[idx];\n\n                 if (current.hasChildren) {\n                     current._matchFilter = current.children._updateHierarchicalFilter(filter);\n                    if (!current._matchFilter) {\n                        current._matchFilter = filter(current);\n                    }\n                } else {\n                    current._matchFilter = filter(current);\n                }\n\n                if (current._matchFilter) {\n                    result = true;\n                }\n            }\n            return result;\n        },\n\n        _find: function(method, value) {\n            var idx, length, node, children;\n            var data = this._data;\n\n            if (!data) {\n                return;\n            }\n\n            node = DataSource.fn[method].call(this, value);\n\n            if (node) {\n                return node;\n            }\n\n            data = this._flatData(this._data);\n\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                children = data[idx].children;\n\n                if (!(children instanceof HierarchicalDataSource)) {\n                    continue;\n                }\n\n                node = children[method](value);\n\n                if (node) {\n                    return node;\n                }\n            }\n        },\n\n        get: function(id) {\n            return this._find(\"get\", id);\n        },\n\n        getByUid: function(uid) {\n            return this._find(\"getByUid\", uid);\n        }\n    });\n\n    function inferList(list, fields) {\n        var items = $(list).children(),\n            idx,\n            length,\n            data = [],\n            record,\n            textField = fields[0].field,\n            urlField = fields[1] && fields[1].field,\n            spriteCssClassField = fields[2] && fields[2].field,\n            imageUrlField = fields[3] && fields[3].field,\n            item,\n            id,\n            textChild,\n            className,\n            children;\n\n        function elements(collection, tagName) {\n            return collection.filter(tagName).add(collection.find(tagName));\n        }\n\n        for (idx = 0, length = items.length; idx < length; idx++) {\n            record = { _loaded: true };\n            item = items.eq(idx);\n\n            textChild = item[0].firstChild;\n            children = item.children();\n            list = children.filter(\"ul\");\n            children = children.filter(\":not(ul)\");\n\n            id = item.attr(\"data-id\");\n\n            if (id) {\n                record.id = id;\n            }\n\n            if (textChild) {\n                record[textField] = textChild.nodeType == 3 ? textChild.nodeValue : children.text();\n            }\n\n            if (urlField) {\n                record[urlField] = elements(children, \"a\").attr(\"href\");\n            }\n\n            if (imageUrlField) {\n                record[imageUrlField] = elements(children, \"img\").attr(\"src\");\n            }\n\n            if (spriteCssClassField) {\n                className = elements(children, \".k-sprite\").prop(\"className\");\n                record[spriteCssClassField] = className && kendo.trim(className.replace(\"k-sprite\", \"\"));\n            }\n\n            if (list.length) {\n                record.items = inferList(list.eq(0), fields);\n            }\n\n            if (item.attr(\"data-hasChildren\") == \"true\") {\n                record.hasChildren = true;\n            }\n\n            data.push(record);\n        }\n\n        return data;\n    }\n\n    HierarchicalDataSource.create = function(options) {\n        options = options && options.push ? { data: options } : options;\n\n        var dataSource = options || {},\n            data = dataSource.data,\n            fields = dataSource.fields,\n            list = dataSource.list;\n\n        if (data && data._dataSource) {\n            return data._dataSource;\n        }\n\n        if (!data && fields && !dataSource.transport) {\n            if (list) {\n                data = inferList(list, fields);\n            }\n        }\n\n        dataSource.data = data;\n\n        return dataSource instanceof HierarchicalDataSource ? dataSource : new HierarchicalDataSource(dataSource);\n    };\n\n    var Buffer = kendo.Observable.extend({\n        init: function(dataSource, viewSize, disablePrefetch) {\n            kendo.Observable.fn.init.call(this);\n\n            this._prefetching = false;\n            this.dataSource = dataSource;\n            this.prefetch = !disablePrefetch;\n\n            var buffer = this;\n\n            dataSource.bind(\"change\", function() {\n                buffer._change();\n            });\n\n            dataSource.bind(\"reset\", function() {\n                buffer._reset();\n            });\n\n            this._syncWithDataSource();\n\n            this.setViewSize(viewSize);\n        },\n\n        setViewSize: function(viewSize) {\n            this.viewSize = viewSize;\n            this._recalculate();\n        },\n\n        at: function(index) {\n            var pageSize = this.pageSize,\n                itemPresent = true;\n\n            if (index >= this.total()) {\n                this.trigger(\"endreached\", { index: index });\n                return null;\n            }\n\n            if (!this.useRanges) {\n               return this.dataSource.view()[index];\n            }\n            if (this.useRanges) {\n                // out of range request\n                if (index < this.dataOffset || index >= this.skip + pageSize) {\n                    itemPresent = this.range(Math.floor(index / pageSize) * pageSize);\n                }\n\n                // prefetch\n                if (index === this.prefetchThreshold) {\n                    this._prefetch();\n                }\n\n                // mid-range jump - prefetchThreshold and nextPageThreshold may be equal, do not change to else if\n                if (index === this.midPageThreshold) {\n                    this.range(this.nextMidRange, true);\n                }\n                // next range jump\n                else if (index === this.nextPageThreshold) {\n                    this.range(this.nextFullRange);\n                }\n                // pull-back\n                else if (index === this.pullBackThreshold) {\n                    if (this.offset === this.skip) { // from full range to mid range\n                        this.range(this.previousMidRange);\n                    } else { // from mid range to full range\n                        this.range(this.previousFullRange);\n                    }\n                }\n\n                if (itemPresent) {\n                    return this.dataSource.at(index - this.dataOffset);\n                } else {\n                    this.trigger(\"endreached\", { index: index });\n                    return null;\n                }\n            }\n        },\n\n        indexOf: function(item) {\n            return this.dataSource.data().indexOf(item) + this.dataOffset;\n        },\n\n        total: function() {\n            return parseInt(this.dataSource.total(), 10);\n        },\n\n        next: function() {\n            var buffer = this,\n                pageSize = buffer.pageSize,\n                offset = buffer.skip - buffer.viewSize + pageSize,\n                pageSkip = math.max(math.floor(offset / pageSize), 0) * pageSize;\n\n            this.offset = offset;\n            this.dataSource.prefetch(pageSkip, pageSize, function() {\n                buffer._goToRange(offset, true);\n            });\n        },\n\n        range: function(offset, nextRange) {\n            if (this.offset === offset) {\n                return true;\n            }\n\n            var buffer = this,\n                pageSize = this.pageSize,\n                pageSkip = math.max(math.floor(offset / pageSize), 0) * pageSize,\n                dataSource = this.dataSource;\n\n            if (nextRange) {\n                pageSkip += pageSize;\n            }\n\n            if (dataSource.inRange(offset, pageSize)) {\n                this.offset = offset;\n                this._recalculate();\n                this._goToRange(offset);\n                return true;\n            } else if (this.prefetch) {\n                dataSource.prefetch(pageSkip, pageSize, function() {\n                    buffer.offset = offset;\n                    buffer._recalculate();\n                    buffer._goToRange(offset, true);\n                });\n                return false;\n            }\n\n            return true;\n        },\n\n        syncDataSource: function() {\n            var offset = this.offset;\n            this.offset = null;\n            this.range(offset);\n        },\n\n        destroy: function() {\n            this.unbind();\n        },\n\n        _prefetch: function() {\n            var buffer = this,\n                pageSize = this.pageSize,\n                prefetchOffset = this.skip + pageSize,\n                dataSource = this.dataSource;\n\n            if (!dataSource.inRange(prefetchOffset, pageSize) && !this._prefetching && this.prefetch) {\n                this._prefetching = true;\n                this.trigger(\"prefetching\", { skip: prefetchOffset, take: pageSize });\n\n                dataSource.prefetch(prefetchOffset, pageSize, function() {\n                    buffer._prefetching = false;\n                    buffer.trigger(\"prefetched\", { skip: prefetchOffset, take: pageSize });\n                });\n            }\n        },\n\n        _goToRange: function(offset, expanding) {\n            if (this.offset !== offset) {\n                return;\n            }\n\n            this.dataOffset = offset;\n            this._expanding = expanding;\n            this.dataSource.range(offset, this.pageSize);\n            this.dataSource.enableRequestsInProgress();\n        },\n\n        _reset: function() {\n            this._syncPending = true;\n        },\n\n        _change: function() {\n            var dataSource = this.dataSource;\n\n            this.length = this.useRanges ? dataSource.lastRange().end : dataSource.view().length;\n\n            if (this._syncPending) {\n                this._syncWithDataSource();\n                this._recalculate();\n                this._syncPending = false;\n                this.trigger(\"reset\", { offset: this.offset });\n            }\n\n            this.trigger(\"resize\");\n\n            if (this._expanding) {\n                this.trigger(\"expand\");\n            }\n\n            delete this._expanding;\n        },\n\n        _syncWithDataSource: function() {\n            var dataSource = this.dataSource;\n\n            this._firstItemUid = dataSource.firstItemUid();\n            this.dataOffset = this.offset = dataSource.skip() || 0;\n            this.pageSize = dataSource.pageSize();\n            this.useRanges = dataSource.options.serverPaging;\n        },\n\n        _recalculate: function() {\n            var pageSize = this.pageSize,\n                offset = this.offset,\n                viewSize = this.viewSize,\n                skip = Math.ceil(offset / pageSize) * pageSize;\n\n            this.skip = skip;\n            this.midPageThreshold = skip + pageSize - 1;\n            this.nextPageThreshold = skip + viewSize - 1;\n            this.prefetchThreshold = skip + Math.floor(pageSize / 3 * 2);\n            this.pullBackThreshold = this.offset - 1;\n\n            this.nextMidRange = skip + pageSize - viewSize;\n            this.nextFullRange = skip;\n            this.previousMidRange = offset - viewSize;\n            this.previousFullRange = skip - pageSize;\n        }\n    });\n\n    var BatchBuffer = kendo.Observable.extend({\n        init: function(dataSource, batchSize) {\n            var batchBuffer = this;\n\n            kendo.Observable.fn.init.call(batchBuffer);\n\n            this.dataSource = dataSource;\n            this.batchSize = batchSize;\n            this._total = 0;\n\n            this.buffer = new Buffer(dataSource, batchSize * 3);\n\n            this.buffer.bind({\n                \"endreached\": function(e) {\n                    batchBuffer.trigger(\"endreached\", { index: e.index });\n                },\n                \"prefetching\": function(e) {\n                    batchBuffer.trigger(\"prefetching\", { skip: e.skip, take: e.take });\n                },\n                \"prefetched\": function(e) {\n                    batchBuffer.trigger(\"prefetched\", { skip: e.skip, take: e.take });\n                },\n                \"reset\": function() {\n                    batchBuffer._total = 0;\n                    batchBuffer.trigger(\"reset\");\n                },\n                \"resize\": function() {\n                    batchBuffer._total = Math.ceil(this.length / batchBuffer.batchSize);\n                    batchBuffer.trigger(\"resize\", { total: batchBuffer.total(), offset: this.offset });\n                }\n            });\n        },\n\n        syncDataSource: function() {\n            this.buffer.syncDataSource();\n        },\n\n        at: function(index) {\n            var buffer = this.buffer,\n                skip = index * this.batchSize,\n                take = this.batchSize,\n                view = [],\n                item;\n\n            if (buffer.offset > skip) {\n                buffer.at(buffer.offset - 1);\n            }\n\n            for (var i = 0; i < take; i++) {\n                item = buffer.at(skip + i);\n\n                if (item === null) {\n                    break;\n                }\n\n                view.push(item);\n            }\n\n            return view;\n        },\n\n        total: function() {\n            return this._total;\n        },\n\n        destroy: function() {\n            this.buffer.destroy();\n            this.unbind();\n        }\n    });\n\n    extend(true, kendo.data, {\n        readers: {\n            json: DataReader\n        },\n        Query: Query,\n        DataSource: DataSource,\n        HierarchicalDataSource: HierarchicalDataSource,\n        Node: Node,\n        Comparer: Comparer,\n        ObservableObject: ObservableObject,\n        ObservableArray: ObservableArray,\n        LazyObservableArray: LazyObservableArray,\n        LocalTransport: LocalTransport,\n        RemoteTransport: RemoteTransport,\n        Cache: Cache,\n        DataReader: DataReader,\n        Model: Model,\n        Buffer: Buffer,\n        BatchBuffer: BatchBuffer\n    });\n})(window.kendo.jQuery);\nvar kendo$1 = kendo;\n\nexport { kendo$1 as default };\n"]}