{"version":3,"sources":["kendo.data.js"],"names":["f","define","$","undefined","eventHandler","context","type","field","prefix","e","key","event","CHANGE","_notifyChange","trigger","equal","x","y","xtype","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","filter","operator","filters","operatorMap","toLowerCase","normalizeFilter","isEmptyObject","logic","compareDescriptor","f1","f2","value","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","kendo","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","push","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","indexOf","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","prop","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","forEach","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","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","hasNotRequestedItems","groupCount","itemsToSkip","taken","getGroupSubGroupCount","_fetchingGroupItems","skipped","getGroupItems","includeParents","excludeHeader","currentItems","subgroups","_composeItemsFilter","floor","findSubgroups","clearTimeout","_timeout","setTimeout","_groupItemsSuccessHandler","g","includeSubGroupCount","_subGroupCountSuccessHandler","totalField","temp","_updateRangePristineData","_currentRequestTimeStamp","_skipRequestsInProgress","indexOfCurrentGroup","currentGroup","dataLength","indexes","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\\((.*?)\\)\\/$/;\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                    this.trigger(CHANGE, {\n                        action: 'remove',\n                        index: index,\n                        items: result\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                    this.trigger(CHANGE, {\n                        action: 'add',\n                        index: index,\n                        items: items\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        var ObservableObject = Observable.extend({\n            init: function (value) {\n                var that = this, member, field, parent = function () {\n                        return that;\n                    };\n                Observable.fn.init.call(this);\n                this._handlers = {};\n                for (field in value) {\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 = $.type(x), ytype = $.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);\n                if (skip !== undefined && take !== undefined) {\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);\n                }\n            } else {\n                if (skip !== undefined && take !== undefined) {\n                    query = query.range(skip, take);\n                }\n                if (group) {\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[i];\n                    currentNew = newGroup.items[i];\n                    if (currOriginal && currentNew) {\n                        if (currOriginal.hasSubgroups) {\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            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 hasNotRequestedItems;\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 (group.hasSubgroups && !group.subgroupCount) {\n                                that.getGroupSubGroupCount(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                            hasNotRequestedItems = !group.items || group.items.length - itemsToSkip < options.take - options.taken;\n                            if (!that._hasExpandedSubGroups(group) && itemsToSkip > groupCount) {\n                                options.skipped += groupCount;\n                                continue;\n                            }\n                            if (group.hasSubgroups && (!group.items || hasNotRequestedItems && group.items.length < group.subgroupCount) || !group.hasSubgroups && (!group.items || hasNotRequestedItems && group.items.length < group.itemCount)) {\n                                that.getGroupItems(group, options, parents, callback);\n                                that._fetchingGroupItems = true;\n                                return;\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                        }\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            getGroupItems: function (group, options, parents, callback) {\n                var that = this;\n                var skip;\n                var take;\n                var filter;\n                var data;\n                var subgroups;\n                if (!group.items) {\n                    group.items = [];\n                }\n                skip = group.items.length;\n                take = that.take();\n                filter = this._composeItemsFilter(group, parents);\n                data = {\n                    page: math.floor((skip || 0) / (take || 1)) || 1,\n                    pageSize: take,\n                    skip: skip,\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),\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            getGroupSubGroupCount: function (group, options, parents, callback) {\n                var that = this;\n                var filter;\n                var groupIndex;\n                var data;\n                if (!group.items) {\n                    group.items = [];\n                }\n                filter = this._composeItemsFilter(group, parents);\n                groupIndex = this._group.map(function (g) {\n                    return g.field;\n                }).indexOf(group.field);\n                data = {\n                    filter: filter,\n                    group: [that._group[groupIndex + 1]],\n                    groupPaging: true,\n                    includeSubGroupCount: 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._subGroupCountSuccessHandler(group, options.skip, that.take(), 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            },\n            _subGroupCountSuccessHandler: function (group, skip, take, callback) {\n                var that = this;\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                    that._dequeueRequest();\n                    that.trigger(REQUESTEND, {\n                        response: data,\n                        type: 'read'\n                    });\n                    that._fetchingGroupItems = false;\n                    if (isFunction(totalField)) {\n                        group.subgroupCount = totalField(data);\n                    } else {\n                        group.subgroupCount = data[totalField];\n                    }\n                    that.range(skip, take, callback, 'expandGroup');\n                };\n            },\n            _groupItemsSuccessHandler: function (group, skip, take, callback) {\n                var that = this;\n                var timestamp = that._timeStamp();\n                callback = isFunction(callback) ? callback : noop;\n                return function (data) {\n                    var temp;\n                    var model = Model.define(that.options.schema.model);\n                    that._dequeueRequest();\n                    that.trigger(REQUESTEND, {\n                        response: data,\n                        type: 'read'\n                    });\n                    data = that.reader.parse(data);\n                    if (group.hasSubgroups) {\n                        temp = that.reader.groups(data);\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 < temp.length; i++) {\n                        group.items.push(temp[i]);\n                    }\n                    group.items.omitChangeEvent = false;\n                    that._updateRangePristineData(group);\n                    that._fetchingGroupItems = false;\n                    that._serverGroupsTotal += temp.length;\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                for (var i = 0; i < rangesLength; i++) {\n                    range = ranges[i];\n                    dataLength = range.data.length;\n                    indexes = [];\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                            temp = temp[indexes.splice(0, 1)[0]].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                    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}));"]}