{"version":3,"file":"kendo.data.min.js","names":["factory","define","amd","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","this","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","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","member","_handlers","charAt","uid","guid","shouldSerialize","f","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","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","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 (factory) {\n   typeof define === 'function' && define.amd ? define(['kendo.core', 'kendo.data.odata', 'kendo.data.xml'], factory) :\n   factory();\n})((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: result\n                       });\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));\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(items, removePristine) {\n               if (!isArray(items)) {\n                   items = [items];\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 < items.length; idx ++) {\n                       var item = items[idx];\n                       var model = this._createNewModel(item);\n                       var found = false;\n\n                       this._eachItem(this._data, function(items) {\n                           for (var idx = 0; idx < items.length; idx++) {\n                               var item = items.at(idx);\n                               if (item.id === model.id) {\n                                   destroyed.push(item);\n                                   items.splice(idx, 1);\n                                   found = true;\n                                   break;\n                               }\n                           }\n                       });\n\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                   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 = this.filter() || {\n                   logic: \"and\",\n                   filters: []\n               };\n\n               filter.logic = 'and';\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\n}));\n"]}