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