{"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","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","_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","destroyed","found","_eachItem","_removePristineForModel","hasGroups","_removeModelFromRanges","created","updated","promises","_sendSubmit","_send","when","then","_accept","_change","cancelChanges","_cancelModel","_markOfflineUpdatesAsDirty","__state__","hasChanges","models","response","serverGroup","_handleCustomErrors","values","_executeOnPristineForModel","deepExtend","_eachPristineItem","_pristineForModel","_submit","status","reject","deferred","_promise","method","converted","params","_params","_queueRequest","isPrevented","_dequeueRequest","args","_readAggregates","itemIds","_aggregateResult","endless","_changeHandler","updatePristine","start","_skip","end","timestamp","_timeStamp","_sortRanges","xhr","errorThrown","_requestInProgress","_pending","_shouldWrap","arrayType","_updateTotalForAction","parseInt","handler","first","_calculateAggregates","_take","_queryProcess","_mergeState","_currentRangeStart","moreItemsCount","remote","fetch","_query","next","totalPages","prev","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","currentRangeStart","_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) {\n                Observable.fn.init.call(this);\n                this.type = type || ObservableObject;\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 + ' || \\'\\').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.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;\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                            getters[field] = getter(fromName || fieldName);\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);\n                    }\n                }\n            }\n        }\n        function eachGroupItems(data, func) {\n            for (var idx = 0, length = data.length; idx < 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) {\n                if (!isArray(items)) {\n                    items = [items];\n                }\n                var destroyed = [];\n                var autoSync = this.options.autoSync;\n                this.options.autoSync = false;\n                try {\n                    for (var idx = 0; idx < items.length; idx++) {\n                        var item = items[idx];\n                        var model = this._createNewModel(item);\n                        var found = false;\n                        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) {\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._change({ action: 'sync' });\n                        that.trigger(SYNC);\n                    });\n                } else {\n                    that._storeData(true);\n                    that._change({ action: 'sync' });\n                }\n                return promise;\n            },\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._change();\n                    that._markOfflineUpdatesAsDirty();\n                }\n            },\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                            items.splice(idx, 1);\n                            that._removeModelFromRanges(model);\n                        }\n                    }\n                });\n            },\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;\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                    var 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                that._pristineData = data.slice(0);\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                    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._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                }\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                    that._aggregateResult = that._calculateAggregates(data, options);\n                }\n                result = that._queryProcess(data, options);\n                that.view(result.data);\n                if (result.total !== undefined && !that.options.serverFiltering) {\n                    that._total = result.total;\n                }\n                e = e || {};\n                e.items = e.items || that._view;\n                that.trigger(CHANGE, e);\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                    if (!this.options.serverFiltering) {\n                        if (result.total !== undefined) {\n                            this._total = result.total;\n                        } else {\n                            this._total = this._data.length;\n                        }\n                    }\n                    this._aggregateResult = this._calculateAggregates(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            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({ 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({\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            _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}));"]}