{"version":3,"file":"kendo.data.min.js","names":["factory","define","amd","$","undefined$1","map","extend","isPlainObject","isEmptyObject","isArray","Array","grep","ajax","each","noop","kendo","window","isFunction","Observable","Class","STRING","FUNCTION","CREATE","READ","UPDATE","DESTROY","CHANGE","SYNC","GET","ERROR","REQUESTSTART","PROGRESS","REQUESTEND","ITEMSLOADED","ITEMLOAD","crud","identity","o","getter","stringify","math","Math","push","join","pop","splice","shift","slice","unshift","toString","stableSort","support","dateRegExp","objectKeys","ObservableArray","init","array","type","that","this","ObservableObject","fn","call","length","wrapAll","_loadPromises","_loadedNodes","at","index","toJSON","serializeFunctions","idx","value","json","parent","source","target","wrap","object","Model","bind","e","isGroup","hasOwnProperty","trigger","field","node","items","action","promise","_loading","done","indexOf","collection","nodes","loading","result","arguments","apply","omitChangeEvent","sort","howMany","item","i","len","concat","children","unbind","forEach","callback","thisArg","context","reduce","reduceRight","filter","find","every","some","remove","empty","Symbol","iterator","prototype","LazyObservableArray","data","events","_events","_parent","eventHandler","prefix","key","event","_notifyChange","ownKeys","ignoreObjectKeys","keys","filteredObjectKeys","props","protoKeys","Object","getPrototypeOf","Date","isPrimitiveType","getOwnPropertyNames","prop","member","_handlers","getTime","charAt","uid","guid","shouldSerialize","f","get","_set","composite","paths","split","path","obj","set","setter","isSetPrevented","current","change","isObservableArray","isDataSource","DataSource","equal","x","y","xtype","parsers","number","toLowerCase","parseFloat","date","parseDate","boolean","string","default","defaultValues","defaults","_initializers","name","dirty","dirtyFields","idField","id","_defaultId","_parse","parse","fieldName","fields","getFieldByName","editable","accept","isNew","base","options","model","originalName","proto","functionFields","nullable","defaultValue","Comparer","selector","compare","a","b","localeCompare","create","dir","combine","comparers","StableComparer","asc","valueA","valueB","__position","desc","operators","quote","str","replace","JSON","textOp","impl","ignore","accentFoldingFiltering","toLocaleLowerCase","operator","op","exec","getMatchRegexp","pattern","rx","esc","ch","eq","neq","gt","gte","lt","lte","startswith","doesnotstartwith","endswith","doesnotendwith","contains","doesnotcontain","matches","substring","doesnotmatch","isempty","isnotempty","isnull","isnotnull","isnullorempty","isnotnullorempty","Query","normalizeSort","descriptor","descriptors","d","sortFields","sorts","sortObject","filterExpr","expression","expr","expressions","fieldFunctions","operatorFunctions","filters","match","ignoreCase","and","or","logic","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","predicate","Function","group","allData","groupPaging","groupAllData","hasSubgroups","itemCount","subgroupCount","groupBy","currentValue","sorted","_sortForGrouping","groupValue","_sortGroups","groups","sum","isNumber","average","max","isDate","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","removePristine","shouldRemovePristine","destroyed","found","_eachItem","_removePristineForModel","pushMove","_moveItems","moved","dataItem","hasGroups","_pushInDestroyed","removeModel","_removeModelFromRanges","created","updated","promises","_sendSubmit","_send","when","then","arguments$1","_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","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","notFetched","floor","round","subgroups","_composeItemsFilter","findSubgroups","clearTimeout","_timeout","setTimeout","_groupItemsSuccessHandler","totalField","totalCount","_updateRangePristineData","countAdded","_currentRequestTimeStamp","_skipRequestsInProgress","indexOfCurrentGroup","g","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"],"sources":["kendo.data.js"],"mappings":"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","sourcesContent":["(function (factory) {\n    typeof define === 'function' && define.amd ? define(['kendo.core', 'kendo.data.odata', 'kendo.data.xml'], factory) :\n    factory();\n})((function () {\n    var __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: result\n                        });\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));\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        Query.filterExpr = function(expression) {\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 idx,\n                current,\n                length,\n                compiled,\n                predicate,\n                data = this.data,\n                fields,\n                operators,\n                result = [],\n                filter;\n\n                expressions = normalizeFilter(expressions);\n\n                if (!expressions || expressions.filters.length === 0) {\n                    return this;\n                }\n\n                compiled = Query.filterExpr(expressions);\n                fields = compiled.fields;\n                operators = compiled.operators;\n\n                predicate = filter = new Function(\"d, __f, __o\", \"return \" + compiled.expression);\n\n                if (fields.length || operators.length) {\n                    filter = function(d) {\n                        return predicate(d, fields, operators);\n                    };\n                }\n\n\n                for (idx = 0, length = data.length; idx < length; idx++) {\n                    current = data[idx];\n\n                    if (filter(current)) {\n                        result.push(current);\n                    }\n                }\n\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                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 data = new Query(allData).filter([{\n                                field: group.field,\n                                operator: \"eq\",\n                                value: group.value,\n                                ignoreCase: false\n                            }]);\n                            var items = descriptors.length > 1 ? new Query(group.items).group(descriptors.slice(1), data.toArray(), options).toArray() : group.items;\n                            return {\n                                field: group.field,\n                                value: group.value,\n                                hasSubgroups: descriptors.length > 1,\n                                items: items,\n                                aggregates: data.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 data = new Query(allData).filter([ { field: group.field, operator: \"eq\", value: group.value, ignoreCase: false } ]);\n                            return {\n                                field: group.field,\n                                value: group.value,\n                                items: descriptors.length > 1 ? new Query(group.items).group(descriptors.slice(1), data.toArray()).toArray() : group.items,\n                                hasSubgroups: descriptors.length > 1,\n                                aggregates: data.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(items, removePristine) {\n                if (!isArray(items)) {\n                    items = [items];\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 < items.length; idx ++) {\n                        var item = items[idx];\n                        var model = this._createNewModel(item);\n                        var found = false;\n\n                        this._eachItem(this._data, function(items) {\n                            for (var idx = 0; idx < items.length; idx++) {\n                                var item = items.at(idx);\n                                if (item.id === model.id) {\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()) {\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 arguments$1 = arguments;\n\n                        var idx, length;\n\n                        for (idx = 0, length = arguments.length; idx < length; idx++) {\n                            if (arguments$1[idx]) {\n                                that._accept(arguments$1[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                    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 = this.filter() || {\n                    logic: \"and\",\n                    filters: []\n                };\n\n                filter.logic = 'and';\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 predicate;\n                var fields;\n                var operators;\n                var filter;\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);\n                fields = compiled.fields;\n                operators = compiled.operators;\n\n                predicate = filter = new Function(\"d, __f, __o\", \"return \" + compiled.expression);\n\n                if (fields.length || operators.length) {\n                    filter = function(d) {\n                        return predicate(d, fields, operators);\n                    };\n                }\n\n                this._updateHierarchicalFilter(filter);\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);\n\n}));\n"]}