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