{"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","normalizeOperator","expression","idx","length","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","map","aggregates","groupValueComparer","calculateAggregate","accumulator","item","index","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","hasSubgroups","items","wrapDataAccess","originalFunction","model","converter","wrapDataAccessBase","toString","call","ObservableArray","fillLastGroup","originalGroup","newGroup","currOriginal","currentNew","i","push","apply","mergeGroups","target","dest","skip","take","group","concat","splice","flattenGroups","itemIndex","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","isFunction","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","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","json","parent","source","wrap","object","bind","node","action","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","initiator","accept","isNew","base","proto","functionFields","nullable","defaultValue","selector","compare","localeCompare","create","combine","comparers","asc","valueA","valueB","__position","desc","quote","str","JSON","textOp","impl","ignore","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","groupBy","currentValue","sorted","_sortForGrouping","groupValue","sum","average","max","min","process","total","query","filterCallback","read","success","update","destroy","parameterMap","url","cache","submit","setup","error","parameters","operation","_store","clear","store","inmemory","schema","dataFunction","groupsFunction","serializeFunction","serializeGetters","modelBase","_dataAccessFunction","groups","serialize","fromName","_wrapDataAccessBase","errors","_map","_prefetch","_pristineData","_ranges","_view","_pristineTotal","_destroyed","_pageSize","pageSize","_page","page","_sort","_filter","_group","_aggregate","_total","_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","_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","_aggregateResult","_skip","endless","_changeHandler","updatePristine","start","end","timestamp","_timeStamp","_sortRanges","xhr","errorThrown","_requestInProgress","_pending","_shouldWrap","arrayType","_updateTotalForAction","parseInt","handler","first","_calculateAggregates","_take","currentRangeStart","_clearEmptyGroups","_queryProcess","dataToAggregate","_setFilterTotal","_mergeState","_currentRangeStart","moreItemsCount","remote","filterTotal","setDefaultValue","fetch","_query","next","totalPages","prev","_pageableQueryOptions","round","_emptyAggregates","ceil","inRange","_findRange","lastRange","firstItemUid","enableRequestsInProgress","_skipRequestsInProgress","_currentRequestTimeStamp","pageSkip","floor","size","_processRangeData","_rangeExists","prefetch","skipIdx","takeIdx","startIndex","endIndex","rangeData","rangeEnd","processed","flatData","_mergeGroups","prevGroup","temp","paging","sorting","filtering","_prefetchSuccessHandler","force","clearTimeout","_timeout","setTimeout","_multiplePrefetch","_updateRangesLength","rangesLength","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', 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 () {\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();\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                this.trigger(CHANGE, {\n                    action: 'add',\n                    index: index,\n                    items: items\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) {\n                return this.hasOwnProperty(field) && field !== '_handlers' && field !== '_events' && 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 () {\n                var result = {}, value, field;\n                for (field in this) {\n                    if (this.shouldSerialize(field)) {\n                        value = this[field];\n                        if (value instanceof ObservableObject || value instanceof ObservableArray) {\n                            value = value.toJSON();\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, initiator) {\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, initiator) && !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) {\n                    b += '';\n                    if (ignore) {\n                        a = '(' + a + ' || \\'\\').toString().toLowerCase()';\n                        b = b.toLowerCase();\n                    }\n                    return impl(a, quote(b), ignore);\n                };\n            }\n            function operator(op, a, b, ignore) {\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(b.toLowerCase());\n                            a = '((' + a + ' || \\'\\')+\\'\\').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) {\n                    return operator('==', a, b, ignore);\n                },\n                neq: function (a, b, ignore) {\n                    return operator('!=', a, b, ignore);\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);\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        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) {\n            var descriptor = typeof field === STRING ? {\n                    field: field,\n                    dir: dir\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                };\n            });\n        }\n        Query.prototype = {\n            toArray: function () {\n                return this.data;\n            },\n            range: function (index, count) {\n                return new Query(this.data.slice(index, index + count));\n            },\n            skip: function (count) {\n                return new Query(this.data.slice(count));\n            },\n            take: function (count) {\n                return new Query(this.data.slice(0, count));\n            },\n            select: function (selector) {\n                return new Query(map(this.data, selector));\n            },\n            order: function (selector, dir, inPlace) {\n                var sort = { dir: dir };\n                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) {\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                    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                return result;\n            },\n            groupBy: function (descriptor) {\n                if (isEmptyObject(descriptor) || !this.data.length) {\n                    return new Query([]);\n                }\n                var field = descriptor.field, sorted = 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                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            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 query = new Query(data), group = options.group, sort = normalizeGroup(group || []).concat(normalizeSort(options.sort || [])), 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 && !inPlace) {\n                query = query.sort(sort);\n                if (group) {\n                    data = query.toArray();\n                }\n            }\n            if (skip !== undefined && take !== undefined) {\n                query = query.range(skip, take);\n            }\n            if (group) {\n                query = query.group(group, data);\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.hasSubgroups) {\n                    convertGroup(record.items, getters, modelInstance, originalFieldNames, fieldNames);\n                } else {\n                    convertRecords(record.items, getters, modelInstance, originalFieldNames, fieldNames);\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 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.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            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.hasSubgroups) {\n                        wrapGroupItems(group.items, model);\n                    } else {\n                        group.items = new LazyObservableArray(group.items, model, group.items._events);\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            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            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._filter = normalizeFilter(options.filter);\n                that._group = normalizeGroup(options.group);\n                that._aggregate = options.aggregate;\n                that._total = options.total;\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            _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                    });\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                }\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]) : 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._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 = start + that._flatData(data, true).length;\n                that._ranges.push({\n                    start: start,\n                    end: end,\n                    data: data,\n                    pristineData: data.toJSON(),\n                    timestamp: that._timeStamp()\n                });\n                that._sortRanges();\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                    }, 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                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) {\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                result = that._queryProcess(data, options);\n                if (that.options.serverAggregates !== true) {\n                    that._aggregateResult = that._calculateAggregates(result.dataToAggregate || data, options);\n                }\n                that.view(result.data);\n                that._setFilterTotal(result.total, false);\n                e = e || {};\n                e.items = e.items || that._view;\n                that.trigger(CHANGE, e);\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                    }\n                    if (options.filter) {\n                        that._filter = options.filter = 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                    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.view(result.data);\n                    this.trigger(REQUESTEND, { type: 'read' });\n                    this.trigger(CHANGE, { items: result.data });\n                }\n                return $.Deferred().resolve(isPrevented).promise();\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().then(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                    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._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                if (val !== undefined) {\n                    that._query({ group: val });\n                    return;\n                }\n                return that._group;\n            },\n            total: function () {\n                return parseInt(this._total || 0, 10);\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(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();\n                return math.ceil((that.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) {\n                this._currentRequestTimeStamp = this._timeStamp();\n                this._skipRequestsInProgress = true;\n                skip = math.min(skip || 0, this.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, that.total()), data;\n                data = that._findRange(skip, math.min(skip + take, that.total()));\n                if (data.length || that.total() === 0) {\n                    that._processRangeData(data, skip, take, pageSkip, size);\n                    callback();\n                    return;\n                }\n                if (take !== undefined) {\n                    if (!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) {\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;\n                for (skipIdx = 0, length = ranges.length; skipIdx < length; skipIdx++) {\n                    range = ranges[skipIdx];\n                    if (start >= range.start && start <= range.end) {\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 = normalizeGroup(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                }\n                return [];\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) {\n                var that = this;\n                that._pending = undefined;\n                that._skip = skip > that.skip() ? 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);\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                                range.pristineData = temp;\n                                range.data = that._observe(temp);\n                                range.end = range.start + that._flatData(range.data, true).length;\n                                that._sortRanges();\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._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                                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            _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            _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 result, range;\n                for (var idx = 0, length = this._ranges.length; idx < length; idx++) {\n                    range = this._ranges[idx];\n                    this._eachItem(range.data, function (items) {\n                        result = removeModel(items, model);\n                    });\n                    if (result) {\n                        break;\n                    }\n                }\n                that._updateRangesLength();\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 range;\n                var i;\n                for (i = 0; i < rangesLength; i++) {\n                    range = ranges[i];\n                    lengthDifference = that._flatData(range.data, true).length - 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        });\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(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                expressions = 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 && $.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            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}));"]}