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