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