{"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","toString","call","ObservableArray","mergeGroups","target","dest","skip","take","group","concat","splice","flattenGroups","itemIndex","at","push","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","apply","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","i","unbind","forEach","callback","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","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","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","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","setup","error","parameters","operation","_store","clear","store","inmemory","schema","dataFunction","groupsFunction","serializeFunction","serializeGetters","modelBase","_dataAccessFunction","groups","serialize","fromName","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","clone","online","sync","Deferred","resolve","promise","offlineData","_isServerGrouped","_push","_readData","_flatData","getByUid","_storeData","_addRange","_process","_observeView","flatView","insert","_createNewModel","_wrapInEmptyGroup","pushInsert","pushed","autoSync","pristine","_updatePristineForModel","_removeItems","destroyed","found","_eachItem","_removePristineForModel","hasGroups","_removeModelFromRanges","_updateRangesLength","created","updated","promises","submit","_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","updatePristine","start","_skip","end","timestamp","xhr","errorThrown","_requestInProgress","_pending","_shouldWrap","arrayType","_changeHandler","_updateTotalForAction","parseInt","handler","first","_calculateAggregates","_take","_queryProcess","_mergeState","_currentRangeStart","remote","fetch","_query","next","totalPages","prev","round","_emptyAggregates","ceil","inRange","_findRange","lastRange","firstItemUid","enableRequestsInProgress","_skipRequestsInProgress","_timeStamp","pageSkip","size","paging","sorting","filtering","_currentRequestTimeStamp","floor","_rangeExists","prefetch","skipIdx","takeIdx","startIndex","endIndex","rangeData","rangeEnd","processed","flatData","_mergeGroups","prevGroup","temp","currentRangeStart","_prefetchSuccessHandler","force","clearTimeout","_timeout","setTimeout","_multiplePrefetch","rangeLength","startOffset","dataSource","transportOptions","transports","schemas","logToConsole","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","useRanges","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) {\n                var idx = 0, length = this.length;\n                for (; idx < length; idx++) {\n                    callback(this[idx], idx, this);\n                }\n            },\n            map: function (callback) {\n                var idx = 0, result = [], length = this.length;\n                for (; idx < length; idx++) {\n                    result[idx] = callback(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) {\n                var idx = 0, result = [], item, length = this.length;\n                for (; idx < length; idx++) {\n                    item = this[idx];\n                    if (callback(item, idx, this)) {\n                        result[result.length] = item;\n                    }\n                }\n                return result;\n            },\n            find: function (callback) {\n                var idx = 0, item, length = this.length;\n                for (; idx < length; idx++) {\n                    item = this[idx];\n                    if (callback(item, idx, this)) {\n                        return item;\n                    }\n                }\n            },\n            every: function (callback) {\n                var idx = 0, item, length = this.length;\n                for (; idx < length; idx++) {\n                    item = this[idx];\n                    if (!callback(item, idx, this)) {\n                        return false;\n                    }\n                }\n                return true;\n            },\n            some: function (callback) {\n                var idx = 0, item, length = this.length;\n                for (; idx < length; idx++) {\n                    item = this[idx];\n                    if (callback(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                return kendo.parseFloat(value);\n            },\n            'date': function (value) {\n                return kendo.parseDate(value);\n            },\n            'boolean': function (value) {\n                if (typeof value === STRING) {\n                    return value.toLowerCase() === 'true';\n                }\n                return value != null ? !!value : value;\n            },\n            'string': function (value) {\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                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 !== '_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                }\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                        if (ObservableObject.fn.set.call(that, field, value, initiator) && !dirty) {\n                            that.dirty = dirty;\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            },\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            };\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) {\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                return new Query(this.data.slice(0).sort(Comparer.create(sort)));\n            },\n            orderBy: function (selector) {\n                return this.order(selector, 'asc');\n            },\n            orderByDescending: function (selector) {\n                return this.order(selector, 'desc');\n            },\n            sort: function (field, dir, comparer) {\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) });\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) {\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 (filter) {\n                query = query.filter(filter);\n                if (filterCallback) {\n                    query = filterCallback(query);\n                }\n                total = query.toArray().length;\n            }\n            if (sort) {\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 (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                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.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 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 idx, length;\n            for (idx = 0, length = data.length; idx < length; idx++) {\n                var dataItem = data.at(idx);\n                if (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            },\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);\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                var idx, length, data = this._flatData(this._data);\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                return model;\n            },\n            pushInsert: function (index, items) {\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                        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                this._updateRangesLength();\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);\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);\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);\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);\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                this._eachItem(this._pristineData, callback);\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 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                        }\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._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                that._data = that._observe(data);\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._readData(state);\n                    }\n                }\n            },\n            _addRange: function (data) {\n                var that = this, start = that._skip || 0, end = start + that._flatData(data, true).length;\n                that._ranges.push({\n                    start: start,\n                    end: end,\n                    data: data,\n                    timestamp: new Date().getTime()\n                });\n                that._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                return Query.process(data, options);\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                    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) {\n                this._currentRequestTimeStamp = this._timeStamp();\n                this._skipRequestsInProgress = true;\n                skip = math.min(skip || 0, this.total());\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) {\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                    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);\n                                });\n                            } else {\n                                that.range(skip, take);\n                            }\n                        });\n                    } else if (pageSkip < skip) {\n                        that.prefetch(size, take, function () {\n                            that.range(skip, take);\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                                    var sort = normalizeGroup(that.group() || []).concat(normalizeSort(that.sort() || []));\n                                    processed = that._queryProcess(range.data, {\n                                        sort: sort,\n                                        filter: that.filter()\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            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                                break;\n                            }\n                        }\n                        if (!found) {\n                            that._ranges.push(range);\n                        }\n                    }\n                    range.data = that._observe(temp);\n                    range.end = range.start + that._flatData(range.data, true).length;\n                    that._ranges.sort(function (x, y) {\n                        return x.start - y.start;\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            _removeModelFromRanges: function (model) {\n                var result, found, 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                        if (result) {\n                            found = true;\n                        }\n                    });\n                    if (found) {\n                        break;\n                    }\n                }\n            },\n            _updateRangesLength: function () {\n                var startOffset = 0, range, rangeLength;\n                for (var idx = 0, length = this._ranges.length; idx < length; idx++) {\n                    range = this._ranges[idx];\n                    range.start = range.start - startOffset;\n                    rangeLength = this._flatData(range.data, true).length;\n                    startOffset = range.end - rangeLength;\n                    range.end = range.start + rangeLength;\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                    that.hasChildren = !!hasChildren.call(that, that);\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) {\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                    this.filter(this._hierarchicalFilter);\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) {\n                    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                    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                this._updateHierarchicalFilter(filter);\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}));"]}