{"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","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","changedItems","_accept","models","_syncEnd","_change","cancelChanges","_cancelModel","_changesCanceled","_markOfflineUpdatesAsDirty","__state__","hasChanges","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","isExcelExportRequest","_requestInProgress","_pending","_shouldWrap","_updateTotalForAction","parseInt","_operationsForUpdatedFields","updatedFields","_updatedFields","operations","stringified","u","partialUpdate","_preventPartialUpdate","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   const logic = {\n       \"or\": {\n           concat: (acc, fn) => a => acc(a) || fn(a),\n           identity: () => false\n       },\n       \"and\": {\n           concat: (acc, fn) => a => acc(a) && fn(a),\n           identity: () => true\n       }\n   };\n\n   const operatorsMap = {\n       isnullorempty: (a) => kendo.isBlank(a) || a === '',\n       isnotnullorempty: (a) => kendo.isPresent(a) && a !== '',\n       contains: (a, b) => (a + '').indexOf(b) >= 0,\n       doesnotcontain: (a, b) => (a + '').indexOf(b) === -1,\n       doesnotendwith: (a, b) => (a + '').indexOf(b, (a || \"\").length - (b || \"\").length) < 0,\n       doesnotstartwith: (a, b) => (a + '').lastIndexOf(b, 0) === -1,\n       endswith: (a, b) => (a + '').indexOf(b, (a || \"\").length - (b || \"\").length) >= 0,\n       eq: (a, b) => a === b,\n       gt: (a, b) => a > b,\n       gte: (a, b) => a >= b,\n       isempty: (a) => a === '',\n       isnotempty: (a) => a !== '',\n       isnotnull: (a) => kendo.isPresent(a),\n       isnull: (a) => kendo.isBlank(a),\n       lt: (a, b) => a < b,\n       lte: (a, b) => a <= b,\n       neq: (a, b) => a != b,\n       startswith: (a, b) => (a + '').lastIndexOf(b, 0) === 0\n   };\n\n   const dateRegExp = /^\\/Date\\((.*?)\\)\\/$/;\n\n   const convertValue = (value, ignoreCase, accentFoldingFiltering) => {\n       if (value != null && kendo.isString(value)) {\n           const 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   const typedGetter = (prop, value, ignoreCase, accentFoldingFiltering) => {\n       if (!kendo.isPresent(value)) {\n           return prop;\n       }\n\n       let acc = prop;\n\n       if (kendo.isString(value)) {\n           const date = dateRegExp.exec(value);\n           if (date) {\n               value = new Date(+date[1]);\n           } else {\n               acc = a => {\n                   const 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 a => {\n               const x = acc(a);\n               return kendo.isDate(x) ? x.getTime() : x;\n           };\n       }\n       return acc;\n   };\n\n   const transformFilter = ({ field, ignoreCase, value, operator = 'eq', accentFoldingFiltering }) => {\n       field = !kendo.isPresent(field) ? a => a : field;\n\n       ignoreCase = kendo.isPresent(ignoreCase) ? ignoreCase : true;\n\n       const 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       const op = kendo.isFunction(operator) ? operator : operatorsMap[operator];\n\n       return a => op(itemProp(a), value, ignoreCase);\n   };\n\n   const isCompositeFilterDescriptor = (source) => kendo.isPresent(source.filters);\n\n   const transformCompositeFilter = (filter) => {\n       const accentFoldingFiltering = filter.accentFoldingFiltering;\n       const combiner = logic[filter.logic || 'and'];\n       return filter.filters\n           .filter(kendo.isPresent)\n           .map(x => (isCompositeFilterDescriptor(x) ? transformCompositeFilter(extendAccentFolding(x, accentFoldingFiltering)) : transformFilter(extendAccentFolding(x, accentFoldingFiltering))))\n           .reduce(combiner.concat, combiner.identity);\n   };\n\n   const extendAccentFolding = (filter, accentFoldingFiltering) => (kendo.isPresent(accentFoldingFiltering) ? Object.assign(filter, { accentFoldingFiltering }) : filter);\n\n   const 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(f => 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 || field.defaultValue) {\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 = { noEval: false }) {\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 = (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 idx, length, changedItems = [];\n\n                       for (idx = 0, length = arguments.length; idx < length; idx++) {\n                           if (arguments[idx]) {\n                               that._accept(arguments[idx]);\n                               changedItems = arguments[idx].models;\n                           }\n                       }\n\n                       that._storeData(true);\n\n                       that._syncEnd();\n\n                       that._change({ action: \"sync\", changedItems: changedItems });\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                       isExcelExportRequest: that.options.isExcelExportRequest\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               if (!that.options.isExcelExportRequest) {\n                   delete options.isExcelExportRequest;\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           _operationsForUpdatedFields: function() {\n               const that = this,\n                   updatedFields = that._updatedFields || [],\n                   operations = {};\n\n               let found = false,\n                   stringified;\n\n               operations.sort = that._sort;\n               operations.filter = that._filter;\n               operations.group = that._group;\n               operations.aggregate = that._aggregate;\n\n               stringified = stringify(operations);\n               found = updatedFields.some(u => stringified.indexOf((`\"field\":\"${u}\"`)) > -1);\n\n               return !found;\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               let that = this, idx, items, 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 (e) {\n                   items = e.items || [];\n                   e.partialUpdate = that._operationsForUpdatedFields() && !that._preventPartialUpdate;\n\n                   if (e.action === \"itemchange\" && items.some(i => i.dirtyFields)) {\n                       that._updatedFields = Object.keys(e.items[0].dirtyFields);\n                   }\n               }\n\n               if (that.options.autoSync && (action === \"add\" || action === \"remove\" || action === \"itemchange\")) {\n                   if (action === \"add\") {\n                       that._preventPartialUpdate = true;\n                   }\n\n                   var handler = function(args) {\n                       if (args.action === \"sync\") {\n                           that._preventPartialUpdate = false;\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"]}