{"version":3,"sources":["odatajs-4.0.4.js"],"names":["init","exports","module","require","version","major","minor","build","deferred","utils","xml","oData","store","cache","datas","appendPage","operation","page","intersection","intersectRanges","start","end","i","c","getJsonValueArraryLength","d","concatJsonValueArray","sliceJsonValueArray","x","y","result","xLast","yLast","resultIndex","resultLast","checkZeroGreater","val","name","undefined","message","isNaN","isFinite","checkUndefinedGreaterThanZero","checkUndefinedOrNumber","removeFromArray","arr","item","len","length","splice","estimateSize","object","size","type","snapToPageBoundaries","lowIndex","highIndex","pageSize","Math","floor","ceil","DataCacheOperation","stateMachine","promise","isCancelable","index","count","data","pending","stateData","cacheState","that","this","p","s","OPERATION_STATE_START","canceled","oncomplete","cancel","state","OPERATION_STATE_ERROR","OPERATION_STATE_END","OPERATION_STATE_CANCEL","transition","complete","djsassert","error","err","run","wait","OPERATION_STATE_WAIT","operationStateMachine","opTargetState","CACHE_STATE_INIT","fireCanceled","fireRejected","fireResolved","handled","DataCache","options","cacheFailure","stats","counts","netReads","prefetches","cacheReads","clearOperations","readOperations","prefetchOperations","actualCacheSize","allDataLocal","cacheSize","undefinedDefault","collectionCount","highestSavedPage","highestSavedPageSize","overflowed","prefetchSize","pendingOperations","source","cacheSource","ODataCacheSource","storeReq","createStore","mechanism","onidle","idle","createDeferred","delay","resolve","request","reject","extend","abort","clear","op","destroyStateMachine","queueAndStart","filterForward","predicate","filter","filterBack","readRange","readStateMachine","ToObservable","toObservable","inBrowser","window","Rx","Observable","obs","disposed","errorCallback","onError","successCallback","value","onNext","onCompleted","then","Dispose","dispose","cacheFailureCallback","changeState","newState","operations","concat","clearStore","CACHE_STATE_DESTROY","DjsDeferred","close","dequeueOperation","removed","CACHE_STATE_IDLE","fetchPage","read","backwards","parseInt10","max","returnData","pendingReadRange","readMore","readIndex","readCount","dataIndex","element","unshift","push","nextIndex","initialPage","initialIndex","initialCount","fireOnIdle","prefetch","CACHE_STATE_READ","prefetchStateMachine","queue","readPage","key","storeFailureCallback","contains","contained","_","savePage","pageBytes","addOrUpdate","updateSettings","saveSettings","success","settings","sourceId","identifier","pageCount","pageIndex","cancelStateMachine","DESTROY_STATE_CLEAR","CACHE_STATE_PREFETCH","READ_STATE_LOCAL","READ_STATE_DONE","min","readSaveStateMachine","CACHE_STATE_WRITE","range","isPrefetch","found","READ_STATE_SOURCE","READ_STATE_SAVE","saved","assigned","settingsVersion","indexOf","createDataCache","isArray","normalizeURI","prototype","reason","appendQueryOption","uri","queryOption","appendSegment","segment","queryPortion","substr","buildODataRequest","method","requestUri","user","password","enableJsonpCallback","callbackParameterName","formatQueryString","queryForData","queryForDataInternal","currentRequest","odataRequest","newData","nextLink","substring","property","httpClient","metadata","normalizeURICase","encodeURI","decodeURI","toString","forwardCall","thisValue","returnValue","apply","arguments","_arguments","_done","_fail","_resolved","_rejected","jQuery","Deferred","fulfilledHandler","errorHandler","odata","dispatchHandler","handlerMethod","requestOrResponse","context","handlers","odataUtils","odataHandler","handler","odataMetadata","odataNet","net","odataJson","json","batch","throwErrorCallback","defined","MAX_DATA_SERVICE_VERSION","invokeRequest","metadataParser","prepareRequest","jsonHandler","textHandler","defaultSuccess","alert","JSON","stringify","defaultError","defaultHandler","response","body","headers","write","maxDataServiceVersion","accept","defaultMetadata","urlOrRequest","String","defaultHttpClient","recognizeDates","bIsSuccessHandlerError","parseMetadata","csdlMetadataDocument","batchHandler","partHandler","metadataHandler","hex16","random","createBoundary","prefix","currentBoundary","boundaries","batchParser","text","__batchResponses","readBatch","contentType","properties","handlerContext","batchSerializer","batchMediaType","mediaType","writeBatch","delimiter","readTo","readLine","responses","partEnd","position","changeResponses","partHeaders","readHeaders","partContentType","boundary","e","readResponse","__changeResponses","pop","statusCode","parts","line","pos","responseHeaderRegex","exec","normalizeHeaders","statusText","match","responseStatusRegex","str","isBatch","batchBoundary","batchParts","__batchRequests","writeBatchPartDelimiter","writeBatchPart","part","nested","changeSet","__changeRequests","changeSetBoundary","partContext","writeRequest","trimString","contentTypeParts","split","contentTypeParams","contentTypeToString","createReadWriteContext","dataServiceVersion","rwContext","fixRequestHeader","fixDataServiceVersionHeader","dsv","maxVersion","getRequestOrResponseHeader","getContentType","getDataServiceVersion","matches","versionRE","handlerAccepts","cType","handlerRead","parseCallback","readContext","handlerWrite","serializeCallback","writeContext","textParse","textSerialize","oDataUtils","jsonParser","metadataContentType","model","parse","payloadFormat","getFormatKind","addMinimalMetadataToJsonPayload","addFullMetadataToJsonPayload","jsonSerializer","jsonContentType","newdata","formatJsonRequestPayload","jsonReplacer","isPrimitive","newArrayData","isJsonSerializableProperty","attribute","jsonSerializableMetadata","jsonMakePayloadInfo","kind","isObject","hasOwnProperty","isGeographyEdmType","isGeometryEdmType","convertDatesNoEdm","typeFromObject","addType","checkProperties","objectInfoType","baseURI","curType","propertyValue","lookupProperty","baseType","lookupEntityType","isCollectionType","addTypeColNoEdm","addTypeNoEdm","addMetadataToJsonMinimalPayloadComplex","convertDates","contextUrlAnnotation","payloadInfo","createPayloadInfo","detectedPayloadKind","PAYLOADTYPE_VALUE","addMetadataToJsonMinimalPayloadEntity","typeName","PAYLOADTYPE_FEED","addMetadataToJsonMinimalPayloadFeed","PAYLOADTYPE_ENTRY","PAYLOADTYPE_COLLECTION","addMetadataToJsonMinimalPayloadCollection","PAYLOADTYPE_PROPERTY","PAYLOADTYPE_SVCDOC","PAYLOADTYPE_LINKS","feedInfo","entry","entries","items","contentTypeOdata","objectInfo","keyType","lastIdSegment","jsonGetEntryKey","lastIndexOf","propertyType","lookupComplexType","collectionInfo","fullName","propertyName","parseDate","parseDateTimeOffset","parseDuration","parseTime","formatLiteral","formatRawLiteral","encodeURIComponent","replace","convertByteArrayToHexString","minutesToOffset","minutes","sign","hours","formatNumberWidth","parseJsonDateString","jsonDateRE","Date","mins","current","getUTCMinutes","setUTCMinutes","__edmType","__offset","valueOf","parseContextUriFragment","fragments","ret","isNullProperty","PAYLOADTYPE_ENTITY_REF_LINKS","PAYLOADTYPE_ENTITY_REF_LINK","fragmentParts","fragment","rCount","charAt","inPharenthesis","startsWith","projection","jsonIsPrimitiveType","container","lookupDefaultEntityContainer","entitySet","lookupEntitySet","entityType","singleton","lookupSingleton","endsWith","tmp12","deltaKind","DELTATYPE_FEED","DELTATYPE_DELETED_ENTRY","DELTATYPE_LINK","DELTATYPE_DELETED_LINK","metadataUri","fragmentStart","entityModel","entityInstanceKey","entityKeys","propertyRef","first","isPrimitiveEdmType","oDataHandler","odataNs","odataAnnotationPrefix","formatDuration","formatDateTimeOffset","getCanonicalTimezone","isComplex","jsonMediaType","schemaElement","attributes","elements","ns","scriptCase","firstTwo","toUpperCase","toLowerCase","getChildSchema","parentSchema","candidateName","elementName","multipleElements","isEdmNamespace","nsURI","edmNs1","parseConceptualModelElement","localName","xmlLocalName","xmlNamespaceURI","elementSchema","schema","xmlAttributes","xmlnsNS","schemaName","odataMetaXmlNs","xmlChildElements","child","childSchema","xmlInnerText","doc","xmlParse","xmlFirstChildElement","oDSxml","xmlNS","ado","http","adoDs","edmxNs","Action","ActionImport","Annotation","AnnotationPath","Annotations","Apply","And","Or","Not","Eq","Ne","Gt","Ge","Lt","Le","Binary","Bool","Cast","Collection","ComplexType","DateTimeOffset","Decimal","Duration","EntityContainer","EntitySet","EntityType","EnumMember","EnumType","Float","Function","FunctionImport","Guid","If","Int","IsOf","Key","LabeledElement","LabeledElementReference","Member","NavigationProperty","NavigationPropertyBinding","NavigationPropertyPath","Null","OnDelete","Path","Parameter","Property","PropertyPath","PropertyRef","PropertyValue","Record","ReferentialConstraint","ReturnType","Schema","Singleton","Term","TimeOfDay","TypeDefinition","UrlRef","Edmx","DataServices","Reference","Include","IncludeAnnotations","canUseJSONP","createIFrame","url","iframe","document","createElement","style","display","attributeEncodedUrl","html","getElementsByTagName","appendChild","writeHtmlToIFrame","createXmlHttpRequest","XMLHttpRequest","exception","ActiveXObject","isAbsoluteUrl","isLocalUrl","location","locationDomain","protocol","host","removeCallback","tick","ticks","removeIFrame","parentNode","removeChild","readResponseHeaders","xhr","responseHeaders","getAllResponseHeaders","header","frameDocument","contentWindow","contentDocument","open","done","handleTimeout","onreadystatechange","readyState","status","responseText","setRequestHeader","withCredentials","timeoutMS","timeout","ontimeout","send","timeoutId","tickText","succeeded","clearTimeout","Content-Type","OData-Version","setTimeout","queryStringParams","qIndex","odatautils","forEachSchema","callback","dataServices","formatMilliseconds","ms","formatDateTimeOffsetJSON","getTime","hasOffset","isDateTimeOffset","offset","timezone","parseTimezone","getUTCHours","h","m","setUTCHours","year","getUTCFullYear","month","getUTCMonth","getUTCMilliseconds","__ns","getUTCDate","getUTCSeconds","days","seconds","width","append","getCollectionType","isCollection","colData","results","collectionTypeRE","test","isDate","isDeferred","__metadata","__deferred","isEntry","isFeed","feedData","geographyEdmTypes","geographyTypes","geometryEdmTypes","geometryTypes","isNamedStream","mediaResource","__mediaresource","media_src","primitiveEdmTypes","navigationPropertyKind","propertyModel","relationship","find","lookupInMetadata","lookupInSchema","entitySets","singletons","entityContainer","lookupEntityContainer","lookupFunctionImport","functionImports","functionImport","lookupNavigationPropertyType","navigationProperty","rel","association","nameOnly","removeNamespace","namespace","associations","role","toRole","lookupNavigationPropertyEntitySet","sourceEntitySetName","associationSet","containers","associationSets","j","getEntitySetInfo","entitySetName","containerName","left","right","leftParts","rightParts","leftVersion","rightVersion","lowerName","normalName","normalHeaders","parseBool","parseDateTimeMaybeOffset","withOffset","nullOnError","parseDateTimeRE","direction","setUTCFullYear","parseTimeOfDay","parseTimeOfDayRE","duration","parseTimeRE","years","months","parseFloat","Accept","async","traverseInternal","owner","traverse","dataItemTypeName","EDM","EDM_BOOLEAN","EDM_BYTE","EDM_SBYTE","EDM_INT16","EDM_INT32","EDM_INT64","EDM_SINGLE","EDM_DOUBLE","EDM_DECIMAL","EDM_STRING","EDM_BINARY","EDM_DATE","EDM_DATETIMEOFFSET","EDM_DURATION","EDM_GUID","EDM_TIMEOFDAY","GEOGRAPHY","EDM_GEOGRAPHY","EDM_GEOGRAPHY_POINT","EDM_GEOGRAPHY_LINESTRING","EDM_GEOGRAPHY_POLYGON","EDM_GEOGRAPHY_COLLECTION","EDM_GEOGRAPHY_MULTIPOLYGON","EDM_GEOGRAPHY_MULTILINESTRING","EDM_GEOGRAPHY_MULTIPOINT","GEOGRAPHY_POINT","GEOGRAPHY_LINESTRING","GEOGRAPHY_POLYGON","GEOGRAPHY_COLLECTION","GEOGRAPHY_MULTIPOLYGON","GEOGRAPHY_MULTILINESTRING","GEOGRAPHY_MULTIPOINT","GEOMETRY","EDM_GEOMETRY","EDM_GEOMETRY_POINT","EDM_GEOMETRY_LINESTRING","EDM_GEOMETRY_POLYGON","EDM_GEOMETRY_COLLECTION","EDM_GEOMETRY_MULTIPOLYGON","EDM_GEOMETRY_MULTILINESTRING","EDM_GEOMETRY_MULTIPOINT","GEOMETRY_POINT","GEOMETRY_LINESTRING","GEOMETRY_POLYGON","GEOMETRY_COLLECTION","GEOMETRY_MULTIPOLYGON","GEOMETRY_MULTILINESTRING","GEOMETRY_MULTIPOINT","content-type","content-encoding","content-length","odata-version","accept-charset","if-match","if-none-match","odata-isolation","odata-maxversion","prefer","content-id","content-transfer-encoding","etag","odata-entityid","preference-applied","retry-after","GEOJSON_POINT","GEOJSON_LINESTRING","GEOJSON_POLYGON","GEOJSON_MULTIPOINT","GEOJSON_MULTILINESTRING","GEOJSON_MULTIPOLYGON","GEOJSON_GEOMETRYCOLLECTION","defaultStoreMechanism","DomStore","isSupported","factory","mechanisms","create","IndexedDBStore","MemoryStore","indexeddb","dom","memory","domStoreDateToJSON","newValue","v","t","domStoreJSONToDate","qualifyDomStoreKey","unqualifyDomStoreKey","localStorage","add","Array","fullKey","oldDateToJSON","toJSON","storedValue","setItem","code","number","removeItem","getItem","getAllKeys","remove","update","getError","errorFunc","Object","call","errName","errObj","target","ex","openStoreDb","storeName","dbName","indexedDB","onblocked","onerror","onupgradeneeded","db","objectStoreNames","createObjectStore","onsuccess","event","versionRequest","setVersion","transaction","onversionchange","openTransaction","mode","storeDb","mozIndexedDB","webkitIndexedDB","msIndexedDB","IDBKeyRange","webkitIDBKeyRange","IDBTransaction","webkitIDBTransaction","IDBT_READ_ONLY","READ_ONLY","IDBT_READ_WRITE","READ_WRITE","keys","values","onabort","objectStore","record","put","get","openCursor","cursor","only","pair","validateKeyInput","messageString","holes","getErrorCallback","a","b","args","slice","condition","parseInt","renameProperty","obj","oldName","newName","trim","defaultValue","getURIInfo","isAbsolute","uriRegEx","uriPartNames","scheme","getURIFromInfo","uriInfo","authority","path","query","uriAuthorityRegEx","pctEncodingRegEx","base","baseInfo","normInfo","mergeUriPathWithBase","removeDotsFromPath","uriPath","basePath","atob","decodeBase64","binaryStr","charCodeAt","hexValue","hexValues","binaryString","base65IndexValue","getBase64IndexValue","binaryValue","addBase64Padding","byteArray","numberOfBytes","intValue","character","asciiCode","asciiOfA","concatData","input","search","format","defaultFormatKind","formatKind","activeXObject","progId","hasLeadingOrTrailingWhitespace","isWhitespace","ws","isWhitespacePreserveContext","domElement","nodeType","xmlAttributeValue","isXmlNSDeclaration","domAttribute","nodeName","safeSetProperty","setProperty","msXmlDom3","msxml3","msXmlDom","msxml","msXmlParse","loadXML","parseError","errorCode","xmlThrowParserError","srcText","exceptionOrReason","errorXmlText","domParser","DOMParser","parseFromString","documentElement","namespaceURI","mozillaParserErroNS","srcTextElement","xmlNodeValue","xhtmlNS","xmlFirstDescendantElement","siblings","firstChild","nextSibling","shift","xmlQualifiedName","xmlAppendText","domNode","textNode","attr","xmlAttributeNode","xmlNewAttribute","ownerDocument","xmlAppendChild","onAttributeCallback","getNamedItemNS","getQualifiedItem","xmlBaseURI","onElementCallback","xmlTraverse","xmlFindElementByPath","root","xmlFindNodeByPath","lastSegmentStart","nodePath","parentPath","node","xmlFirstElementMaybeRecursive","getElementsByTagNameNS","recursive","firstElement","isExpectedNamespace","isExpectedNodeName","xmlElement","whitespacePreserveContext","whitespaceAlreadyRemoved","preserveWhiteSpace","shouldInclude","baseName","nodeValue","onChildCallback","subtrees","proceed","xmlSiblingElement","sibling","xmlDom","implementation","createDocument","xmlAppendChildren","parent","children","xmlNewText","setAttributeNodeNS","setAttributeNode","qualifiedName","createAttributeNS","createNode","xmlNewElement","createElementNS","nampespaceURI","xmlNewNSDeclaration","xmlNewFragment","tempDom","tempRoot","imported","importNode","createDocumentFragment","importedChild","createTextNode","xmlNewNodeByPath","xmlFindNode","xmlNewNode","xmlNode","childNode","xmlSerialize","xmlSerializer","XMLSerializer","serializeToString","xmlSerializeDescendants","childNodes","fragmentRoot","w3org","modules","odatajs"],"mappings":"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","file":"odatajs-4.0.4.min.js","sourcesContent":["/*\n * Licensed to the Apache Software Foundation (ASF) under one\n * or more contributor license agreements.  See the NOTICE file\n * distributed with this work for additional information\n * regarding copyright ownership.  The ASF licenses this file\n * to you under the Apache License, Version 2.0 (the\n * \"License\"); you may not use this file except in compliance\n * with the License.  You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied.  See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n(function () {\n  var init = function (exports, module, require) {\n    \n\n// version information \nexports.version = { major: 4, minor: 0, build: 2 };\n\n// core stuff, always needed\nexports.deferred = require('./lib/deferred.js');\nexports.utils = require('./lib/utils.js');\n\n// only needed for xml metadata \nexports.xml = require('./lib/xml.js');\n\n// only need in browser case\nexports.oData = require('./lib/odata.js');\nexports.store = require('./lib/store.js');\nexports.cache = require('./lib/cache.js');\n\n  };\n\n  var datas = {\"cache\" : function(exports, module, require) {\n'use strict';\n\n /** @module cache */\n\n//var odatajs = require('./odatajs/utils.js');\nvar utils =  require('./utils.js');\nvar deferred = require('./deferred.js');\nvar storeReq = require('./store.js');\nvar cacheSource = require('./cache/source.js');\n\n\nvar assigned = utils.assigned;\nvar delay = utils.delay;\nvar extend = utils.extend;\nvar djsassert = utils.djsassert;\nvar isArray = utils.isArray;\nvar normalizeURI = utils.normalizeURI;\nvar parseInt10 = utils.parseInt10;\nvar undefinedDefault = utils.undefinedDefault;\n\nvar createDeferred = deferred.createDeferred;\nvar DjsDeferred = deferred.DjsDeferred;\n\n\nvar getJsonValueArraryLength = utils.getJsonValueArraryLength;\nvar sliceJsonValueArray = utils.sliceJsonValueArray;\nvar concatJsonValueArray = utils.concatJsonValueArray;\n\n\n\n/** Appends a page's data to the operation data.\n * @param {Object} operation - Operation with  (i)ndex, (c)ount and (d)ata.\n * @param {Object} page - Page with (i)ndex, (c)ount and (d)ata.\n */\nfunction appendPage(operation, page) {\n\n    var intersection = intersectRanges(operation, page);\n    var start = 0;\n    var end = 0;\n    if (intersection) {\n        start = intersection.i - page.i;\n        end = start + (operation.c - getJsonValueArraryLength(operation.d));\n    }\n\n    operation.d = concatJsonValueArray(operation.d, sliceJsonValueArray(page.d, start, end));\n}\n\n/** Returns the {(i)ndex, (c)ount} range for the intersection of x and y.\n * @param {Object} x - Range with (i)ndex and (c)ount members.\n * @param {Object} y - Range with (i)ndex and (c)ount members.\n * @returns {Object} The intersection (i)ndex and (c)ount; undefined if there is no intersection.\n */\nfunction intersectRanges(x, y) {\n\n    var xLast = x.i + x.c;\n    var yLast = y.i + y.c;\n    var resultIndex = (x.i > y.i) ? x.i : y.i;\n    var resultLast = (xLast < yLast) ? xLast : yLast;\n    var result;\n    if (resultLast >= resultIndex) {\n        result = { i: resultIndex, c: resultLast - resultIndex };\n    }\n\n    return result;\n}\n\n/** Checks whether val is a defined number with value zero or greater.\n * @param {Number} val - Value to check.\n * @param {String} name - Parameter name to use in exception.\n * @throws Throws an exception if the check fails\n */\nfunction checkZeroGreater(val, name) {\n\n    if (val === undefined || typeof val !== \"number\") {\n        throw { message: \"'\" + name + \"' must be a number.\" };\n    }\n\n    if (isNaN(val) || val < 0 || !isFinite(val)) {\n        throw { message: \"'\" + name + \"' must be greater than or equal to zero.\" };\n    }\n}\n\n/** Checks whether val is undefined or a number with value greater than zero.\n * @param {Number} val - Value to check.\n * @param {String} name - Parameter name to use in exception.\n * @throws Throws an exception if the check fails\n */\nfunction checkUndefinedGreaterThanZero(val, name) {\n\n    if (val !== undefined) {\n        if (typeof val !== \"number\") {\n            throw { message: \"'\" + name + \"' must be a number.\" };\n        }\n\n        if (isNaN(val) || val <= 0 || !isFinite(val)) {\n            throw { message: \"'\" + name + \"' must be greater than zero.\" };\n        }\n    }\n}\n\n/** Checks whether val is undefined or a number\n * @param {Number} val - Value to check.\n * @param {String} name - Parameter name to use in exception.\n * @throws Throws an exception if the check fails\n */\nfunction checkUndefinedOrNumber(val, name) {\n    if (val !== undefined && (typeof val !== \"number\" || isNaN(val) || !isFinite(val))) {\n        throw { message: \"'\" + name + \"' must be a number.\" };\n    }\n}\n\n/** Performs a linear search on the specified array and removes the first instance of 'item'.\n * @param {Array} arr - Array to search.\n * @param {*} item - Item being sought.\n * @returns {Boolean} true if the item was removed otherwise false\n */\nfunction removeFromArray(arr, item) {\n\n    var i, len;\n    for (i = 0, len = arr.length; i < len; i++) {\n        if (arr[i] === item) {\n            arr.splice(i, 1);\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/** Estimates the size of an object in bytes.\n * Object trees are traversed recursively\n * @param {Object} object - Object to determine the size of.\n * @returns {Number} Estimated size of the object in bytes.\n */\nfunction estimateSize(object) {\n    var size = 0;\n    var type = typeof object;\n\n    if (type === \"object\" && object) {\n        for (var name in object) {\n            size += name.length * 2 + estimateSize(object[name]);\n        }\n    } else if (type === \"string\") {\n        size = object.length * 2;\n    } else {\n        size = 8;\n    }\n    return size;\n}\n\n/** Snaps low and high indices into page sizes and returns a range.\n * @param {Number} lowIndex - Low index to snap to a lower value.\n * @param {Number} highIndex - High index to snap to a higher value.\n * @param {Number} pageSize - Page size to snap to.\n * @returns {Object} A range with (i)ndex and (c)ount of elements.\n */\nfunction snapToPageBoundaries(lowIndex, highIndex, pageSize) {\n    lowIndex = Math.floor(lowIndex / pageSize) * pageSize;\n    highIndex = Math.ceil((highIndex + 1) / pageSize) * pageSize;\n    return { i: lowIndex, c: highIndex - lowIndex };\n}\n\n// The DataCache is implemented using state machines.  The following constants are used to properly\n// identify and label the states that these machines transition to.\nvar CACHE_STATE_DESTROY  = \"destroy\";\nvar CACHE_STATE_IDLE     = \"idle\";\nvar CACHE_STATE_INIT     = \"init\";\nvar CACHE_STATE_READ     = \"read\";\nvar CACHE_STATE_PREFETCH = \"prefetch\";\nvar CACHE_STATE_WRITE    = \"write\";\n\n// DataCacheOperation state machine states.\n// Transitions on operations also depend on the cache current of the cache.\nvar OPERATION_STATE_CANCEL = \"cancel\";\nvar OPERATION_STATE_END    = \"end\";\nvar OPERATION_STATE_ERROR  = \"error\";\nvar OPERATION_STATE_START  = \"start\";\nvar OPERATION_STATE_WAIT   = \"wait\";\n\n// Destroy state machine states\nvar DESTROY_STATE_CLEAR = \"clear\";\n\n// Read / Prefetch state machine states\nvar READ_STATE_DONE   = \"done\";\nvar READ_STATE_LOCAL  = \"local\";\nvar READ_STATE_SAVE   = \"save\";\nvar READ_STATE_SOURCE = \"source\";\n\n/** Creates a new operation object.\n * @class DataCacheOperation\n * @param {Function} stateMachine - State machine that describes the specific behavior of the operation.\n * @param {DjsDeferred} promise - Promise for requested values.\n * @param {Boolean} isCancelable - Whether this operation can be canceled or not.\n * @param {Number} index - Index of first item requested.\n * @param {Number} count - Count of items requested.\n * @param {Array} data - Array with the items requested by the operation.\n * @param {Number} pending - Total number of pending prefetch records.\n * @returns {DataCacheOperation} A new data cache operation instance.\n */\nfunction DataCacheOperation(stateMachine, promise, isCancelable, index, count, data, pending) {\n\n   var stateData;\n    var cacheState;\n    var that = this;\n\n    that.p = promise;\n    that.i = index;\n    that.c = count;\n    that.d = data;\n    that.s = OPERATION_STATE_START;\n\n    that.canceled = false;\n    that.pending = pending;\n    that.oncomplete = null;\n\n    /** Transitions this operation to the cancel state and sets the canceled flag to true.\n     * The function is a no-op if the operation is non-cancelable.\n     * @method DataCacheOperation#cancel\n     */\n    that.cancel = function cancel() {\n\n        if (!isCancelable) {\n            return;\n        }\n\n        var state = that.s;\n        if (state !== OPERATION_STATE_ERROR && state !== OPERATION_STATE_END && state !== OPERATION_STATE_CANCEL) {\n            that.canceled = true;\n            that.transition(OPERATION_STATE_CANCEL, stateData);\n        }\n    };\n\n    /** Transitions this operation to the end state.\n     * @method DataCacheOperation#complete\n     */\n    that.complete = function () {\n\n        djsassert(that.s !== OPERATION_STATE_END, \"DataCacheOperation.complete() - operation is in the end state\", that);\n        that.transition(OPERATION_STATE_END, stateData);\n    };\n\n    /** Transitions this operation to the error state.\n     * @method DataCacheOperation#error\n     */\n    that.error = function (err) {\n        if (!that.canceled) {\n            djsassert(that.s !== OPERATION_STATE_END, \"DataCacheOperation.error() - operation is in the end state\", that);\n            djsassert(that.s !== OPERATION_STATE_ERROR, \"DataCacheOperation.error() - operation is in the error state\", that);\n            that.transition(OPERATION_STATE_ERROR, err);\n        }\n    };\n\n    /** Executes the operation's current state in the context of a new cache state.\n     * @method DataCacheOperation#run\n     * @param {Object} state - New cache state.\n     */\n    that.run = function (state) {\n\n        cacheState = state;\n        that.transition(that.s, stateData);\n    };\n\n    /** Transitions this operation to the wait state.\n     * @method DataCacheOperation#wait\n     */\n    that.wait = function (data) {\n\n        djsassert(that.s !== OPERATION_STATE_END, \"DataCacheOperation.wait() - operation is in the end state\", that);\n        that.transition(OPERATION_STATE_WAIT, data);\n    };\n\n    /** State machine that describes all operations common behavior.\n     * @method DataCacheOperation#operationStateMachine\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n     * @param {Object} [data] - Additional data passed to the state.\n     */\n    var operationStateMachine = function (opTargetState, cacheState, data) {\n\n        switch (opTargetState) {\n            case OPERATION_STATE_START:\n                // Initial state of the operation. The operation will remain in this state until the cache has been fully initialized.\n                if (cacheState !== CACHE_STATE_INIT) {\n                    stateMachine(that, opTargetState, cacheState, data);\n                }\n                break;\n\n            case OPERATION_STATE_WAIT:\n                // Wait state indicating that the operation is active but waiting for an asynchronous operation to complete.\n                stateMachine(that, opTargetState, cacheState, data);\n                break;\n\n            case OPERATION_STATE_CANCEL:\n                // Cancel state.\n                stateMachine(that, opTargetState, cacheState, data);\n                that.fireCanceled();\n                that.transition(OPERATION_STATE_END);\n                break;\n\n            case OPERATION_STATE_ERROR:\n                // Error state. Data is expected to be an object detailing the error condition.\n                stateMachine(that, opTargetState, cacheState, data);\n                that.canceled = true;\n                that.fireRejected(data);\n                that.transition(OPERATION_STATE_END);\n                break;\n\n            case OPERATION_STATE_END:\n                // Final state of the operation.\n                if (that.oncomplete) {\n                    that.oncomplete(that);\n                }\n                if (!that.canceled) {\n                    that.fireResolved();\n                }\n                stateMachine(that, opTargetState, cacheState, data);\n                break;\n\n            default:\n                // Any other state is passed down to the state machine describing the operation's specific behavior.\n\n                if (true) {\n                    // Check that the state machine actually handled the sate.\n                    var handled = stateMachine(that, opTargetState, cacheState, data);\n                    djsassert(handled, \"Bad operation state: \" + opTargetState + \" cacheState: \" + cacheState, this);\n                } else {\n\n                    stateMachine(that, opTargetState, cacheState, data);\n\n                }\n\n                break;\n        }\n    };\n\n\n\n    /** Transitions this operation to a new state.\n     * @method DataCacheOperation#transition\n     * @param {Object} state - State to transition the operation to.\n     * @param {Object} [data] - \n     */\n    that.transition = function (state, data) {\n        that.s = state;\n        stateData = data;\n        operationStateMachine(state, cacheState, data);\n    };\n    \n    return that;\n}\n\n/** Fires a resolved notification as necessary.\n * @method DataCacheOperation#fireResolved\n */\nDataCacheOperation.prototype.fireResolved = function () {\n\n    // Fire the resolve just once.\n    var p = this.p;\n    if (p) {\n        this.p = null;\n        p.resolve(this.d);\n    }\n};\n\n/** Fires a rejected notification as necessary.\n * @method DataCacheOperation#fireRejected\n */\nDataCacheOperation.prototype.fireRejected = function (reason) {\n\n    // Fire the rejection just once.\n    var p = this.p;\n    if (p) {\n        this.p = null;\n        p.reject(reason);\n    }\n};\n\n/** Fires a canceled notification as necessary.\n * @method DataCacheOperation#fireCanceled\n */\nDataCacheOperation.prototype.fireCanceled = function () {\n\n    this.fireRejected({ canceled: true, message: \"Operation canceled\" });\n};\n\n\n/** Creates a data cache for a collection that is efficiently loaded on-demand.\n * @class DataCache\n * @param options - Options for the data cache, including name, source, pageSize,\n * prefetchSize, cacheSize, storage mechanism, and initial prefetch and local-data handler.\n * @returns {DataCache} A new data cache instance.\n */\nfunction DataCache(options) {\n\n    var state = CACHE_STATE_INIT;\n    var stats = { counts: 0, netReads: 0, prefetches: 0, cacheReads: 0 };\n\n    var clearOperations = [];\n    var readOperations = [];\n    var prefetchOperations = [];\n\n    var actualCacheSize = 0;                                             // Actual cache size in bytes.\n    var allDataLocal = false;                                            // Whether all data is local.\n    var cacheSize = undefinedDefault(options.cacheSize, 1048576);        // Requested cache size in bytes, default 1 MB.\n    var collectionCount = 0;                                             // Number of elements in the server collection.\n    var highestSavedPage = 0;                                            // Highest index of all the saved pages.\n    var highestSavedPageSize = 0;                                        // Item count of the saved page with the highest index.\n    var overflowed = cacheSize === 0;                                    // If the cache has overflowed (actualCacheSize > cacheSize or cacheSize == 0);\n    var pageSize = undefinedDefault(options.pageSize, 50);               // Number of elements to store per page.\n    var prefetchSize = undefinedDefault(options.prefetchSize, pageSize); // Number of elements to prefetch from the source when the cache is idling.\n    var version = \"1.0\";\n    var cacheFailure;\n\n    var pendingOperations = 0;\n\n    var source = options.source;\n    if (typeof source === \"string\") {\n        // Create a new cache source.\n        source = new cacheSource.ODataCacheSource(options);\n    }\n    source.options = options;\n\n    // Create a cache local store.\n    var store = storeReq.createStore(options.name, options.mechanism);\n\n    var that = this;\n\n    that.onidle = options.idle;\n    that.stats = stats;\n\n    /** Counts the number of items in the collection.\n     * @method DataCache#count\n     * @returns {Object} A promise with the number of items.\n     */\n    that.count = function () {\n\n        if (cacheFailure) {\n            throw cacheFailure;\n        }\n\n        var deferred = createDeferred();\n        var canceled = false;\n\n        if (allDataLocal) {\n            delay(function () {\n                deferred.resolve(collectionCount);\n            });\n\n            return deferred.promise();\n        }\n\n        // TODO: Consider returning the local data count instead once allDataLocal flag is set to true.\n        var request = source.count(function (count) {\n            request = null;\n            stats.counts++;\n            deferred.resolve(count);\n        }, function (err) {\n            request = null;\n            deferred.reject(extend(err, { canceled: canceled }));\n        });\n\n        return extend(deferred.promise(), {\n\n             /** Aborts the count operation (used within promise callback)\n              * @method DataCache#cancelCount\n              */\n            cancel: function () {\n               \n                if (request) {\n                    canceled = true;\n                    request.abort();\n                    request = null;\n                }\n            }\n        });\n    };\n\n    /** Cancels all running operations and clears all local data associated with this cache.\n     * New read requests made while a clear operation is in progress will not be canceled.\n     * Instead they will be queued for execution once the operation is completed.\n     * @method DataCache#clear\n     * @returns {Object} A promise that has no value and can't be canceled.\n     */\n    that.clear = function () {\n\n        if (cacheFailure) {\n            throw cacheFailure;\n        }\n\n        if (clearOperations.length === 0) {\n            var deferred = createDeferred();\n            var op = new DataCacheOperation(destroyStateMachine, deferred, false);\n            queueAndStart(op, clearOperations);\n            return deferred.promise();\n        }\n        return clearOperations[0].p;\n    };\n\n    /** Filters the cache data based a predicate.\n     * Specifying a negative count value will yield all the items in the cache that satisfy the predicate.\n     * @method DataCache#filterForward\n     * @param {Number} index - The index of the item to start filtering forward from.\n     * @param {Number} count - Maximum number of items to include in the result.\n     * @param {Function} predicate - Callback function returning a boolean that determines whether an item should be included in the result or not.\n     * @returns {DjsDeferred} A promise for an array of results.\n     */\n    that.filterForward = function (index, count, predicate) {\n        return filter(index, count, predicate, false);\n    };\n\n    /** Filters the cache data based a predicate.\n     * Specifying a negative count value will yield all the items in the cache that satisfy the predicate.\n     * @method DataCache#filterBack\n     * @param {Number} index - The index of the item to start filtering backward from.\n     * @param {Number} count - Maximum number of items to include in the result.\n     * @param {Function} predicate - Callback function returning a boolean that determines whether an item should be included in the result or not.\n     * @returns {DjsDeferred} A promise for an array of results.\n     */\n    that.filterBack = function (index, count, predicate) {\n        return filter(index, count, predicate, true);\n    };\n\n    /** Reads a range of adjacent records.\n     * New read requests made while a clear operation is in progress will not be canceled.\n     * Instead they will be queued for execution once the operation is completed.\n     * @method DataCache#readRange\n     * @param {Number} index - Zero-based index of record range to read.\n     * @param {Number} count - Number of records in the range.\n     * @returns {DjsDeferred} A promise for an array of records; less records may be returned if the\n     * end of the collection is found.\n     */\n    that.readRange = function (index, count) {\n\n        checkZeroGreater(index, \"index\");\n        checkZeroGreater(count, \"count\");\n\n        if (cacheFailure) {\n            throw cacheFailure;\n        }\n\n        var deferred = createDeferred();\n\n        // Merging read operations would be a nice optimization here.\n        var op = new DataCacheOperation(readStateMachine, deferred, true, index, count, {}, 0);\n        queueAndStart(op, readOperations);\n\n        return extend(deferred.promise(), {\n            cancel: function () {\n                /** Aborts the readRange operation  (used within promise callback)\n                 * @method DataCache#cancelReadRange\n                 */\n                op.cancel();\n            }\n        });\n    };\n\n    /** Creates an Observable object that enumerates all the cache contents.\n     * @method DataCache#toObservable\n     * @returns A new Observable object that enumerates all the cache contents.\n     */\n    that.ToObservable = that.toObservable = function () {\n        if ( !utils.inBrowser()) {\n            throw { message: \"Only in broser supported\" };\n        }\n\n        if (!window.Rx || !window.Rx.Observable) {\n            throw { message: \"Rx library not available - include rx.js\" };\n        }\n\n        if (cacheFailure) {\n            throw cacheFailure;\n        }\n\n        //return window.Rx.Observable.create(function (obs) {\n        return new window.Rx.Observable(function (obs) {\n            var disposed = false;\n            var index = 0;\n\n            var errorCallback = function (error) {\n                if (!disposed) {\n                    obs.onError(error);\n                }\n            };\n\n            var successCallback = function (data) {\n                if (!disposed) {\n                    var i, len;\n                    for (i = 0, len = data.value.length; i < len; i++) {\n                        // The wrapper automatically checks for Dispose\n                        // on the observer, so we don't need to check it here.\n                        //obs.next(data.value[i]);\n                        obs.onNext(data.value[i]);\n                    }\n\n                    if (data.value.length < pageSize) {\n                        //obs.completed();\n                        obs.onCompleted();\n                    } else {\n                        index += pageSize;\n                        that.readRange(index, pageSize).then(successCallback, errorCallback);\n                    }\n                }\n            };\n\n            that.readRange(index, pageSize).then(successCallback, errorCallback);\n\n            return { Dispose: function () { \n                obs.dispose(); // otherwise the check isStopped obs.onNext(data.value[i]);\n                disposed = true; \n                } };\n        });\n    };\n\n    /** Creates a function that handles a callback by setting the cache into failure mode.\n     * @method DataCache~cacheFailureCallback\n     * @param {String} message - Message text.\n     * @returns {Function} Function to use as error callback.\n     * This function will specifically handle problems with critical store resources\n     * during cache initialization.\n     */\n    var cacheFailureCallback = function (message) {\n        \n\n        return function (error) {\n            cacheFailure = { message: message, error: error };\n\n            // Destroy any pending clear or read operations.\n            // At this point there should be no prefetch operations.\n            // Count operations will go through but are benign because they\n            // won't interact with the store.\n            djsassert(prefetchOperations.length === 0, \"prefetchOperations.length === 0\");\n            var i, len;\n            for (i = 0, len = readOperations.length; i < len; i++) {\n                readOperations[i].fireRejected(cacheFailure);\n            }\n            for (i = 0, len = clearOperations.length; i < len; i++) {\n                clearOperations[i].fireRejected(cacheFailure);\n            }\n\n            // Null out the operation arrays.\n            readOperations = clearOperations = null;\n        };\n    };\n\n    /** Updates the cache's state and signals all pending operations of the change.\n     * @method DataCache~changeState\n     * @param {Object} newState - New cache state.\n     * This method is a no-op if the cache's current state and the new state are the same.\n     */\n    var changeState = function (newState) {\n\n        if (newState !== state) {\n            state = newState;\n            var operations = clearOperations.concat(readOperations, prefetchOperations);\n            var i, len;\n            for (i = 0, len = operations.length; i < len; i++) {\n                operations[i].run(state);\n            }\n        }\n    };\n\n    /** Removes all the data stored in the cache.\n     * @method DataCache~clearStore\n     * @returns {DjsDeferred} A promise with no value.\n     */\n    var clearStore = function () {\n        djsassert(state === CACHE_STATE_DESTROY || state === CACHE_STATE_INIT, \"DataCache.clearStore() - cache is not on the destroy or initialize state, current sate = \" + state);\n\n        var deferred = new DjsDeferred();\n        store.clear(function () {\n\n            // Reset the cache settings.\n            actualCacheSize = 0;\n            allDataLocal = false;\n            collectionCount = 0;\n            highestSavedPage = 0;\n            highestSavedPageSize = 0;\n            overflowed = cacheSize === 0;\n\n            // version is not reset, in case there is other state in eg V1.1 that is still around.\n\n            // Reset the cache stats.\n            stats = { counts: 0, netReads: 0, prefetches: 0, cacheReads: 0 };\n            that.stats = stats;\n\n            store.close();\n            deferred.resolve();\n        }, function (err) {\n            deferred.reject(err);\n        });\n        return deferred;\n    };\n\n    /** Removes an operation from the caches queues and changes the cache state to idle.\n     * @method DataCache~dequeueOperation\n     * @param {DataCacheOperation} operation - Operation to dequeue.\n     * This method is used as a handler for the operation's oncomplete event.\n    */\n    var dequeueOperation = function (operation) {\n\n        var removed = removeFromArray(clearOperations, operation);\n        if (!removed) {\n            removed = removeFromArray(readOperations, operation);\n            if (!removed) {\n                removeFromArray(prefetchOperations, operation);\n            }\n        }\n\n        pendingOperations--;\n        changeState(CACHE_STATE_IDLE);\n    };\n\n    /** Requests data from the cache source.\n     * @method DataCache~fetchPage\n     * @param {Number} start - Zero-based index of items to request.\n     * @returns {DjsDeferred} A promise for a page object with (i)ndex, (c)ount, (d)ata.\n     */\n    var fetchPage = function (start) {\n\n        djsassert(state !== CACHE_STATE_DESTROY, \"DataCache.fetchPage() - cache is on the destroy state\");\n        djsassert(state !== CACHE_STATE_IDLE, \"DataCache.fetchPage() - cache is on the idle state\");\n\n        var deferred = new DjsDeferred();\n        var canceled = false;\n\n        var request = source.read(start, pageSize, function (data) {\n            var length = getJsonValueArraryLength(data);\n            var page = { i: start, c: length, d: data };\n            deferred.resolve(page);\n        }, function (err) {\n            deferred.reject(err);\n        });\n\n        return extend(deferred, {\n            cancel: function () {\n                if (request) {\n                    request.abort();\n                    canceled = true;\n                    request = null;\n                }\n            }\n        });\n    };\n\n    /** Filters the cache data based a predicate.\n     * @method DataCache~filter\n     * @param {Number} index - The index of the item to start filtering from.\n     * @param {Number} count - Maximum number of items to include in the result.\n     * @param {Function} predicate - Callback function returning a boolean that determines whether an item should be included in the result or not.\n     * @param {Boolean} backwards - True if the filtering should move backward from the specified index, falsey otherwise.\n     * Specifying a negative count value will yield all the items in the cache that satisfy the predicate.\n     * @returns {DjsDeferred} A promise for an array of results.\n     */\n    var filter = function (index, count, predicate, backwards) {\n\n        index = parseInt10(index);\n        count = parseInt10(count);\n\n        if (isNaN(index)) {\n            throw { message: \"'index' must be a valid number.\", index: index };\n        }\n        if (isNaN(count)) {\n            throw { message: \"'count' must be a valid number.\", count: count };\n        }\n\n        if (cacheFailure) {\n            throw cacheFailure;\n        }\n\n        index = Math.max(index, 0);\n\n        var deferred = createDeferred();\n        var returnData = {};\n        returnData.value = [];\n        var canceled = false;\n        var pendingReadRange = null;\n\n        var readMore = function (readIndex, readCount) {\n            if (!canceled) {\n                if (count > 0 && returnData.value.length >= count) {\n                    deferred.resolve(returnData);\n                } else {\n                    pendingReadRange = that.readRange(readIndex, readCount).then(function (data) {\n                        if (data[\"@odata.context\"] && !returnData[\"@odata.context\"]) {\n                            returnData[\"@odata.context\"] = data[\"@odata.context\"];\n                        }\n                        \n                        for (var i = 0, length = data.value.length; i < length && (count < 0 || returnData.value.length < count); i++) {\n                            var dataIndex = backwards ? length - i - 1 : i;\n                            var item = data.value[dataIndex];\n                            if (predicate(item)) {\n                                var element = {\n                                    index: readIndex + dataIndex,\n                                    item: item\n                                };\n\n                                backwards ? returnData.value.unshift(element) : returnData.value.push(element);\n                            }\n                        }\n\n                        // Have we reached the end of the collection?\n                        if ((!backwards && data.value.length < readCount) || (backwards && readIndex <= 0)) {\n                            deferred.resolve(returnData);\n                        } else {\n                            var nextIndex = backwards ? Math.max(readIndex - pageSize, 0) : readIndex + readCount;\n                            readMore(nextIndex, pageSize);\n                        }\n                    }, function (err) {\n                        deferred.reject(err);\n                    });\n                }\n            }\n        };\n\n        // Initially, we read from the given starting index to the next/previous page boundary\n        var initialPage = snapToPageBoundaries(index, index, pageSize);\n        var initialIndex = backwards ? initialPage.i : index;\n        var initialCount = backwards ? index - initialPage.i + 1 : initialPage.i + initialPage.c - index;\n        readMore(initialIndex, initialCount);\n\n        return extend(deferred.promise(), {\n            /** Aborts the filter operation (used within promise callback)\n            * @method DataCache#cancelFilter\n             */\n            cancel: function () {\n\n                if (pendingReadRange) {\n                    pendingReadRange.cancel();\n                }\n                canceled = true;\n            }\n        });\n    };\n\n    /** Fires an onidle event if any functions are assigned.\n     * @method DataCache~fireOnIdle\n    */\n    var fireOnIdle = function () {\n\n        if (that.onidle && pendingOperations === 0) {\n            that.onidle();\n        }\n    };\n\n    /** Creates and starts a new prefetch operation.\n     * @method DataCache~prefetch\n     * @param {Number} start - Zero-based index of the items to prefetch.\n     * This method is a no-op if any of the following conditions is true:\n     *     1.- prefetchSize is 0\n     *     2.- All data has been read and stored locally in the cache.\n     *     3.- There is already an all data prefetch operation queued.\n     *     4.- The cache has run out of available space (overflowed).\n    */\n    var prefetch = function (start) {\n        \n\n        if (allDataLocal || prefetchSize === 0 || overflowed) {\n            return;\n        }\n\n        djsassert(state === CACHE_STATE_READ, \"DataCache.prefetch() - cache is not on the read state, current state: \" + state);\n\n        if (prefetchOperations.length === 0 || (prefetchOperations[0] && prefetchOperations[0].c !== -1)) {\n            // Merging prefetch operations would be a nice optimization here.\n            var op = new DataCacheOperation(prefetchStateMachine, null, true, start, prefetchSize, null, prefetchSize);\n            queueAndStart(op, prefetchOperations);\n        }\n    };\n\n    /** Queues an operation and runs it.\n     * @param {DataCacheOperation} op - Operation to queue.\n     * @param {Array} queue - Array that will store the operation.\n     */\n    var queueAndStart = function (op, queue) {\n\n        op.oncomplete = dequeueOperation;\n        queue.push(op);\n        pendingOperations++;\n        op.run(state);\n    };\n\n    /** Requests a page from the cache local store.\n     * @method DataCache~readPage    \n     * @param {Number} key - Zero-based index of the reuqested page.\n     * @returns {DjsDeferred} A promise for a found flag and page object with (i)ndex, (c)ount, (d)ata, and (t)icks.\n     */\n    var readPage = function (key) {\n\n        djsassert(state !== CACHE_STATE_DESTROY, \"DataCache.readPage() - cache is on the destroy state\");\n\n        var canceled = false;\n        var deferred = extend(new DjsDeferred(), {\n            /** Aborts the readPage operation. (used within promise callback)\n             * @method DataCache#cancelReadPage\n             */\n            cancel: function () {\n                canceled = true;\n            }\n        });\n\n        var error = storeFailureCallback(deferred, \"Read page from store failure\");\n\n        store.contains(key, function (contained) {\n            if (canceled) {\n                return;\n            }\n            if (contained) {\n                store.read(key, function (_, data) {\n                    if (!canceled) {\n                        deferred.resolve(data !== undefined, data);\n                    }\n                }, error);\n                return;\n            }\n            deferred.resolve(false);\n        }, error);\n        return deferred;\n    };\n\n    /** Saves a page to the cache local store.\n     * @method DataCache~savePage    \n     * @param {Number} key - Zero-based index of the requested page.\n     * @param {Object} page - Object with (i)ndex, (c)ount, (d)ata, and (t)icks.\n     * @returns {DjsDeferred} A promise with no value.\n     */\n    var savePage = function (key, page) {\n\n        djsassert(state !== CACHE_STATE_DESTROY, \"DataCache.savePage() - cache is on the destroy state\");\n        djsassert(state !== CACHE_STATE_IDLE, \"DataCache.savePage() - cache is on the idle state\");\n\n        var canceled = false;\n\n        var deferred = extend(new DjsDeferred(), {\n            /** Aborts the savePage operation. (used within promise callback)\n             * @method DataCache#cancelReadPage\n             */\n            cancel: function () {\n                canceled = true;\n            }\n        });\n\n        var error = storeFailureCallback(deferred, \"Save page to store failure\");\n\n        var resolve = function () {\n            deferred.resolve(true);\n        };\n\n        if (page.c > 0) {\n            var pageBytes = estimateSize(page);\n            overflowed = cacheSize >= 0 && cacheSize < actualCacheSize + pageBytes;\n\n            if (!overflowed) {\n                store.addOrUpdate(key, page, function () {\n                    updateSettings(page, pageBytes);\n                    saveSettings(resolve, error);\n                }, error);\n            } else {\n                resolve();\n            }\n        } else {\n            updateSettings(page, 0);\n            saveSettings(resolve, error);\n        }\n        return deferred;\n    };\n\n    /** Saves the cache's current settings to the local store.\n     * @method DataCache~saveSettings    \n     * @param {Function} success - Success callback.\n     * @param {Function} error - Errror callback.\n     */\n    var saveSettings = function (success, error) {\n\n        var settings = {\n            actualCacheSize: actualCacheSize,\n            allDataLocal: allDataLocal,\n            cacheSize: cacheSize,\n            collectionCount: collectionCount,\n            highestSavedPage: highestSavedPage,\n            highestSavedPageSize: highestSavedPageSize,\n            pageSize: pageSize,\n            sourceId: source.identifier,\n            version: version\n        };\n\n        store.addOrUpdate(\"__settings\", settings, success, error);\n    };\n\n    /** Creates a function that handles a store error.\n     * @method DataCache~storeFailureCallback    \n     * @param {DjsDeferred} deferred - Deferred object to resolve.\n     * @returns {Function} Function to use as error callback.\n    \n     * This function will specifically handle problems when interacting with the store.\n     */\n    var storeFailureCallback = function (deferred/*, message*/) {\n        \n\n        return function (/*error*/) {\n            // var console = windo1w.console;\n            // if (console && console.log) {\n            //    console.log(message);\n            //    console.dir(error);\n            // }\n            deferred.resolve(false);\n        };\n    };\n\n    /** Updates the cache's settings based on a page object.\n     * @method DataCache~updateSettings    \n     * @param {Object} page - Object with (i)ndex, (c)ount, (d)ata.\n     * @param {Number} pageBytes - Size of the page in bytes.\n     */\n    var updateSettings = function (page, pageBytes) {\n\n        var pageCount = page.c;\n        var pageIndex = page.i;\n\n        // Detect the collection size.\n        if (pageCount === 0) {\n            if (highestSavedPage === pageIndex - pageSize) {\n                collectionCount = highestSavedPage + highestSavedPageSize;\n            }\n        } else {\n            highestSavedPage = Math.max(highestSavedPage, pageIndex);\n            if (highestSavedPage === pageIndex) {\n                highestSavedPageSize = pageCount;\n            }\n            actualCacheSize += pageBytes;\n            if (pageCount < pageSize && !collectionCount) {\n                collectionCount = pageIndex + pageCount;\n            }\n        }\n\n        // Detect the end of the collection.\n        if (!allDataLocal && collectionCount === highestSavedPage + highestSavedPageSize) {\n            allDataLocal = true;\n        }\n    };\n\n    /** State machine describing the behavior for cancelling a read or prefetch operation.\n     * @method DataCache~cancelStateMachine    \n     * @param {DataCacheOperation} operation - Operation being run.\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n     * @param {Object} [data] - \n     * This state machine contains behavior common to read and prefetch operations.\n     */\n    var cancelStateMachine = function (operation, opTargetState, cacheState, data) {\n        \n\n        var canceled = operation.canceled && opTargetState !== OPERATION_STATE_END;\n        if (canceled) {\n            if (opTargetState === OPERATION_STATE_CANCEL) {\n                // Cancel state.\n                // Data is expected to be any pending request made to the cache.\n                if (data && data.cancel) {\n                    data.cancel();\n                }\n            }\n        }\n        return canceled;\n    };\n\n    /** State machine describing the behavior of a clear operation.\n     * @method DataCache~destroyStateMachine    \n     * @param {DataCacheOperation} operation - Operation being run.\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n    \n     * Clear operations have the highest priority and can't be interrupted by other operations; however,\n     * they will preempt any other operation currently executing.\n     */\n    var destroyStateMachine = function (operation, opTargetState, cacheState) {\n        \n\n        var transition = operation.transition;\n\n        // Signal the cache that a clear operation is running.\n        if (cacheState !== CACHE_STATE_DESTROY) {\n            changeState(CACHE_STATE_DESTROY);\n            return true;\n        }\n\n        switch (opTargetState) {\n            case OPERATION_STATE_START:\n                // Initial state of the operation.\n                transition(DESTROY_STATE_CLEAR);\n                break;\n\n            case OPERATION_STATE_END:\n                // State that signals the operation is done.\n                fireOnIdle();\n                break;\n\n            case DESTROY_STATE_CLEAR:\n                // State that clears all the local data of the cache.\n                clearStore().then(function () {\n                    // Terminate the operation once the local store has been cleared.\n                    operation.complete();\n                });\n                // Wait until the clear request completes.\n                operation.wait();\n                break;\n\n            default:\n                return false;\n        }\n        return true;\n    };\n\n    /** State machine describing the behavior of a prefetch operation.\n     * @method DataCache~prefetchStateMachine    \n     * @param {DataCacheOperation} operation - Operation being run.\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n     * @param {Object} [data] - \n    \n     *  Prefetch operations have the lowest priority and will be interrupted by operations of\n     *  other kinds. A preempted prefetch operation will resume its execution only when the state\n     *  of the cache returns to idle.\n     * \n     *  If a clear operation starts executing then all the prefetch operations are canceled,\n     *  even if they haven't started executing yet.\n     */\n    var prefetchStateMachine = function (operation, opTargetState, cacheState, data) {\n        \n\n        // Handle cancelation\n        if (!cancelStateMachine(operation, opTargetState, cacheState, data)) {\n\n            var transition = operation.transition;\n\n            // Handle preemption\n            if (cacheState !== CACHE_STATE_PREFETCH) {\n                if (cacheState === CACHE_STATE_DESTROY) {\n                    if (opTargetState !== OPERATION_STATE_CANCEL) {\n                        operation.cancel();\n                    }\n                } else if (cacheState === CACHE_STATE_IDLE) {\n                    // Signal the cache that a prefetch operation is running.\n                    changeState(CACHE_STATE_PREFETCH);\n                }\n                return true;\n            }\n\n            switch (opTargetState) {\n                case OPERATION_STATE_START:\n                    // Initial state of the operation.\n                    if (prefetchOperations[0] === operation) {\n                        transition(READ_STATE_LOCAL, operation.i);\n                    }\n                    break;\n\n                case READ_STATE_DONE:\n                    // State that determines if the operation can be resolved or has to\n                    // continue processing.\n                    // Data is expected to be the read page.\n                    var pending = operation.pending;\n\n                    if (pending > 0) {\n                        pending -= Math.min(pending, data.c);\n                    }\n\n                    // Are we done, or has all the data been stored?\n                    if (allDataLocal || pending === 0 || data.c < pageSize || overflowed) {\n                        operation.complete();\n                    } else {\n                        // Continue processing the operation.\n                        operation.pending = pending;\n                        transition(READ_STATE_LOCAL, data.i + pageSize);\n                    }\n                    break;\n\n                default:\n                    return readSaveStateMachine(operation, opTargetState, cacheState, data, true);\n            }\n        }\n        return true;\n    };\n\n    /** State machine describing the behavior of a read operation.\n     * @method DataCache~readStateMachine    \n     * @param {DataCacheOperation} operation - Operation being run.\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n     * @param {Object} [data] - \n    \n     * Read operations have a higher priority than prefetch operations, but lower than\n     * clear operations. They will preempt any prefetch operation currently running\n     * but will be interrupted by a clear operation.\n     *          \n     * If a clear operation starts executing then all the currently running\n     * read operations are canceled. Read operations that haven't started yet will\n     * wait in the start state until the destory operation finishes.\n     */\n    var readStateMachine = function (operation, opTargetState, cacheState, data) {\n        \n\n        // Handle cancelation\n        if (!cancelStateMachine(operation, opTargetState, cacheState, data)) {\n\n            var transition = operation.transition;\n\n            // Handle preemption\n            if (cacheState !== CACHE_STATE_READ && opTargetState !== OPERATION_STATE_START) {\n                if (cacheState === CACHE_STATE_DESTROY) {\n                    if (opTargetState !== OPERATION_STATE_START) {\n                        operation.cancel();\n                    }\n                } else if (cacheState !== CACHE_STATE_WRITE) {\n                    // Signal the cache that a read operation is running.\n                    djsassert(state == CACHE_STATE_IDLE || state === CACHE_STATE_PREFETCH, \"DataCache.readStateMachine() - cache is not on the read or idle state.\");\n                    changeState(CACHE_STATE_READ);\n                }\n\n                return true;\n            }\n\n            switch (opTargetState) {\n                case OPERATION_STATE_START:\n                    // Initial state of the operation.\n                    // Wait until the cache is idle or prefetching.\n                    if (cacheState === CACHE_STATE_IDLE || cacheState === CACHE_STATE_PREFETCH) {\n                        // Signal the cache that a read operation is running.\n                        changeState(CACHE_STATE_READ);\n                        if (operation.c >= 0) {\n                            // Snap the requested range to a page boundary.\n                            var range = snapToPageBoundaries(operation.i, operation.c, pageSize);\n                            transition(READ_STATE_LOCAL, range.i);\n                        } else {\n                            transition(READ_STATE_DONE, operation);\n                        }\n                    }\n                    break;\n\n                case READ_STATE_DONE:\n                    // State that determines if the operation can be resolved or has to\n                    // continue processing.\n                    // Data is expected to be the read page.\n                    appendPage(operation, data);\n                    var len = getJsonValueArraryLength(operation.d);\n                    // Are we done?\n                    if (operation.c === len || data.c < pageSize) {\n                        // Update the stats, request for a prefetch operation.\n                        stats.cacheReads++;\n                        prefetch(data.i + data.c);\n                        // Terminate the operation.\n                        operation.complete();\n                    } else {\n                        // Continue processing the operation.\n                        transition(READ_STATE_LOCAL, data.i + pageSize);\n                    }\n                    break;\n\n                default:\n                    return readSaveStateMachine(operation, opTargetState, cacheState, data, false);\n            }\n        }\n\n        return true;\n    };\n\n    /** State machine describing the behavior for reading and saving data into the cache.\n     * @method DataCache~readSaveStateMachine    \n     * @param {DataCacheOperation} operation - Operation being run.\n     * @param {Object} opTargetState - Operation state to transition to.\n     * @param {Object} cacheState - Current cache state.\n     * @param {Object} [data] - \n     * @param {Boolean} isPrefetch - Flag indicating whether a read (false) or prefetch (true) operation is running.\n     * This state machine contains behavior common to read and prefetch operations.\n    */\n    var readSaveStateMachine = function (operation, opTargetState, cacheState, data, isPrefetch) {\n\n        var error = operation.error;\n        var transition = operation.transition;\n        var wait = operation.wait;\n        var request;\n\n        switch (opTargetState) {\n            case OPERATION_STATE_END:\n                // State that signals the operation is done.\n                fireOnIdle();\n                break;\n\n            case READ_STATE_LOCAL:\n                // State that requests for a page from the local store.\n                // Data is expected to be the index of the page to request.\n                request = readPage(data).then(function (found, page) {\n                    // Signal the cache that a read operation is running.\n                    if (!operation.canceled) {\n                        if (found) {\n                            // The page is in the local store, check if the operation can be resolved.\n                            transition(READ_STATE_DONE, page);\n                        } else {\n                            // The page is not in the local store, request it from the source.\n                            transition(READ_STATE_SOURCE, data);\n                        }\n                    }\n                });\n                break;\n\n            case READ_STATE_SOURCE:\n                // State that requests for a page from the cache source.\n                // Data is expected to be the index of the page to request.\n                request = fetchPage(data).then(function (page) {\n                    // Signal the cache that a read operation is running.\n                    if (!operation.canceled) {\n                        // Update the stats and save the page to the local store.\n                        if (isPrefetch) {\n                            stats.prefetches++;\n                        } else {\n                            stats.netReads++;\n                        }\n                        transition(READ_STATE_SAVE, page);\n                    }\n                }, error);\n                break;\n\n            case READ_STATE_SAVE:\n                // State that saves a  page to the local store.\n                // Data is expected to be the page to save.\n                // Write access to the store is exclusive.\n                if (cacheState !== CACHE_STATE_WRITE) {\n                    changeState(CACHE_STATE_WRITE);\n                    request = savePage(data.i, data).then(function (saved) {\n                        if (!operation.canceled) {\n                            if (!saved && isPrefetch) {\n                                operation.pending = 0;\n                            }\n                            // Check if the operation can be resolved.\n                            transition(READ_STATE_DONE, data);\n                        }\n                        changeState(CACHE_STATE_IDLE);\n                    });\n                }\n                break;\n\n            default:\n                // Unknown state that can't be handled by this state machine.\n                return false;\n        }\n\n        if (request) {\n            // The operation might have been canceled between stack frames do to the async calls.\n            if (operation.canceled) {\n                request.cancel();\n            } else if (operation.s === opTargetState) {\n                // Wait for the request to complete.\n                wait(request);\n            }\n        }\n\n        return true;\n    };\n\n    // Initialize the cache.\n    store.read(\"__settings\", function (_, settings) {\n        if (assigned(settings)) {\n            var settingsVersion = settings.version;\n            if (!settingsVersion || settingsVersion.indexOf(\"1.\") !== 0) {\n                cacheFailureCallback(\"Unsupported cache store version \" + settingsVersion)();\n                return;\n            }\n\n            if (pageSize !== settings.pageSize || source.identifier !== settings.sourceId) {\n                // The shape or the source of the data was changed so invalidate the store.\n                clearStore().then(function () {\n                    // Signal the cache is fully initialized.\n                    changeState(CACHE_STATE_IDLE);\n                }, cacheFailureCallback(\"Unable to clear store during initialization\"));\n            } else {\n                // Restore the saved settings.\n                actualCacheSize = settings.actualCacheSize;\n                allDataLocal = settings.allDataLocal;\n                cacheSize = settings.cacheSize;\n                collectionCount = settings.collectionCount;\n                highestSavedPage = settings.highestSavedPage;\n                highestSavedPageSize = settings.highestSavedPageSize;\n                version = settingsVersion;\n\n                // Signal the cache is fully initialized.\n                changeState(CACHE_STATE_IDLE);\n            }\n        } else {\n            // This is a brand new cache.\n            saveSettings(function () {\n                // Signal the cache is fully initialized.\n                changeState(CACHE_STATE_IDLE);\n            }, cacheFailureCallback(\"Unable to write settings during initialization.\"));\n        }\n    }, cacheFailureCallback(\"Unable to read settings from store.\"));\n\n    return that;\n}\n\n/** Creates a data cache for a collection that is efficiently loaded on-demand.\n * @param options \n * Options for the data cache, including name, source, pageSize, TODO check doku\n * prefetchSize, cacheSize, storage mechanism, and initial prefetch and local-data handler.\n * @returns {DataCache} A new data cache instance.\n */\nfunction createDataCache (options) {\n    checkUndefinedGreaterThanZero(options.pageSize, \"pageSize\");\n    checkUndefinedOrNumber(options.cacheSize, \"cacheSize\");\n    checkUndefinedOrNumber(options.prefetchSize, \"prefetchSize\");\n\n    if (!assigned(options.name)) {\n        throw { message: \"Undefined or null name\", options: options };\n    }\n\n    if (!assigned(options.source)) {\n        throw { message: \"Undefined source\", options: options };\n    }\n\n    return new DataCache(options);\n}\n\n\n/** estimateSize (see {@link estimateSize}) */\nexports.estimateSize = estimateSize;\n\n/** createDataCache */  \nexports.createDataCache = createDataCache;\n\n\n\n}, \"source\" : function(exports, module, require) {\n'use strict';\n\n /** @module cache/source */\n \nvar utils = require(\"./../utils.js\");\nvar odataRequest = require(\"./../odata.js\");\n\nvar parseInt10 = utils.parseInt10;\nvar normalizeURICase = utils.normalizeURICase;\n\n\n\n\n/** Appends the specified escaped query option to the specified URI.\n * @param {String} uri - URI to append option to.\n * @param {String} queryOption - Escaped query option to append.\n */\nfunction appendQueryOption(uri, queryOption) {\n    var separator = (uri.indexOf(\"?\") >= 0) ? \"&\" : \"?\";\n    return uri + separator + queryOption;\n}\n\n/** Appends the specified segment to the given URI.\n * @param {String} uri - URI to append a segment to.\n * @param {String} segment - Segment to append.\n * @returns {String} The original URI with a new segment appended.\n */\nfunction appendSegment(uri, segment) {\n    var index = uri.indexOf(\"?\");\n    var queryPortion = \"\";\n    if (index >= 0) {\n        queryPortion = uri.substr(index);\n        uri = uri.substr(0, index);\n    }\n\n    if (uri[uri.length - 1] !== \"/\") {\n        uri += \"/\";\n    }\n    return uri + segment + queryPortion;\n}\n\n/** Builds a request object to GET the specified URI.\n * @param {String} uri - URI for request.\n * @param {Object} options - Additional options.\n */\nfunction buildODataRequest(uri, options) {\n    return {\n        method: \"GET\",\n        requestUri: uri,\n        user: options.user,\n        password: options.password,\n        enableJsonpCallback: options.enableJsonpCallback,\n        callbackParameterName: options.callbackParameterName,\n        formatQueryString: options.formatQueryString\n    };\n}\n\n/** Finds the index where the value of a query option starts.\n * @param {String} uri - URI to search in.\n * @param {String} name - Name to look for.\n * @returns {Number} The index where the query option starts.\n */\nfunction findQueryOptionStart(uri, name) {\n    var result = -1;\n    var queryIndex = uri.indexOf(\"?\");\n    if (queryIndex !== -1) {\n        var start = uri.indexOf(\"?\" + name + \"=\", queryIndex);\n        if (start === -1) {\n            start = uri.indexOf(\"&\" + name + \"=\", queryIndex);\n        }\n        if (start !== -1) {\n            result = start + name.length + 2;\n        }\n    }\n    return result;\n}\n\n/** Gets data from an OData service.\n * @param {String} uri - URI to the OData service.\n * @param {Object} options - Object with additional well-known request options.\n * @param {Function} success - Success callback.\n * @param {Function} error - Error callback.\n * @returns {Object} Object with an abort method.\n */\nfunction queryForData (uri, options, success, error) {\n    return queryForDataInternal(uri, options, {}, success, error);\n}\n\n/** Gets data from an OData service taking into consideration server side paging.\n * @param {String} uri - URI to the OData service.\n * @param {Object} options - Object with additional well-known request options.\n * @param {Array} data - Array that stores the data provided by the OData service.\n * @param {Function} success - Success callback.\n * @param {Function} error - Error callback.\n * @returns {Object} Object with an abort method.\n */\nfunction queryForDataInternal(uri, options, data, success, error) {\n\n    var request = buildODataRequest(uri, options);\n    var currentRequest = odataRequest.request(request, function (newData) {\n        var nextLink = newData[\"@odata.nextLink\"];\n        if (nextLink) {\n            var index = uri.indexOf(\".svc/\", 0);\n            if (index != -1) {\n                nextLink = uri.substring(0, index + 5) + nextLink;\n            }\n        }\n\n        if (data.value && newData.value) {\n            data.value = data.value.concat(newData.value);\n        }\n        else {\n            for (var property in newData) {\n                if (property != \"@odata.nextLink\") {\n                    data[property] = newData[property];\n                }\n            }\n        }\n\n        if (nextLink) {\n            currentRequest = queryForDataInternal(nextLink, options, data, success, error);\n        }\n        else {\n            success(data);\n        }\n    }, error, undefined, options.httpClient, options.metadata);\n\n    return {\n        abort: function () {\n            currentRequest.abort();\n        }\n    };\n}\n\n/** Creates a data cache source object for requesting data from an OData service.\n * @class ODataCacheSource\n * @param options - Options for the cache data source.\n * @returns {ODataCacheSource} A new data cache source instance.\n */\nfunction ODataCacheSource (options) {\n    var that = this;\n    var uri = options.source;\n    \n    that.identifier = normalizeURICase(encodeURI(decodeURI(uri)));\n    that.options = options;\n\n    /** Gets the number of items in the collection.\n     * @method ODataCacheSource#count\n     * @param {Function} success - Success callback with the item count.\n     * @param {Function} error - Error callback.\n     * @returns {Object} Request object with an abort method.\n     */\n    that.count = function (success, error) {\n        var options = that.options;\n        return odataRequest.request(\n            buildODataRequest(appendSegment(uri, \"$count\"), options),\n            function (data) {\n                var count = parseInt10(data.toString());\n                if (isNaN(count)) {\n                    error({ message: \"Count is NaN\", count: count });\n                } else {\n                    success(count);\n                }\n            }, error, undefined, options.httpClient, options.metadata\n        );\n    };\n    \n    /** Gets a number of consecutive items from the collection.\n     * @method ODataCacheSource#read\n     * @param {Number} index - Zero-based index of the items to retrieve.\n     * @param {Number} count - Number of items to retrieve.\n     * @param {Function} success - Success callback with the requested items.\n     * @param {Function} error - Error callback.\n     * @returns {Object} Request object with an abort method.\n    */\n    that.read = function (index, count, success, error) {\n\n        var queryOptions = \"$skip=\" + index + \"&$top=\" + count;\n        return queryForData(appendQueryOption(uri, queryOptions), that.options, success, error);\n    };\n\n    return that;\n}\n\n\n\n/** ODataCacheSource (see {@link ODataCacheSource}) */\nexports.ODataCacheSource = ODataCacheSource;}, \"deferred\" : function(exports, module, require) {\n'use strict';\n\n/** @module odatajs/deferred */\n\n\n\n/** Creates a new function to forward a call.\n * @param {Object} thisValue - Value to use as the 'this' object.\n * @param {String} name - Name of function to forward to.\n * @param {Object} returnValue - Return value for the forward call (helps keep identity when chaining calls).\n * @returns {Function} A new function that will forward a call.\n */\nfunction forwardCall(thisValue, name, returnValue) {\n    return function () {\n        thisValue[name].apply(thisValue, arguments);\n        return returnValue;\n    };\n}\n\n/** Initializes a new DjsDeferred object.\n * <ul>\n * <li> Compability Note A - Ordering of callbacks through chained 'then' invocations <br>\n *\n * The Wiki entry at http://wiki.commonjs.org/wiki/Promises/A\n * implies that .then() returns a distinct object.\n *\n * For compatibility with http://api.jquery.com/category/deferred-object/\n * we return this same object. This affects ordering, as\n * the jQuery version will fire callbacks in registration\n * order regardless of whether they occur on the result\n * or the original object.\n * </li>\n * <li>Compability Note B - Fulfillment value <br>\n *\n * The Wiki entry at http://wiki.commonjs.org/wiki/Promises/A\n * implies that the result of a success callback is the\n * fulfillment value of the object and is received by\n * other success callbacks that are chained.\n *\n * For compatibility with http://api.jquery.com/category/deferred-object/\n * we disregard this value instead.\n * </li></ul>\n * @class DjsDeferred \n */\n function DjsDeferred() {\n    this._arguments = undefined;\n    this._done = undefined;\n    this._fail = undefined;\n    this._resolved = false;\n    this._rejected = false;\n}\n\n\nDjsDeferred.prototype = {\n\n    /** Adds success and error callbacks for this deferred object.\n     * See Compatibility Note A.\n     * @method DjsDeferred#then\n     * @param {function} [fulfilledHandler] - Success callback ( may be null)\n     * @param {function} [errorHandler] - Error callback ( may be null)\n     */\n    then: function (fulfilledHandler, errorHandler) {\n\n        if (fulfilledHandler) {\n            if (!this._done) {\n                this._done = [fulfilledHandler];\n            } else {\n                this._done.push(fulfilledHandler);\n            }\n        }\n\n        if (errorHandler) {\n            if (!this._fail) {\n                this._fail = [errorHandler];\n            } else {\n                this._fail.push(errorHandler);\n            }\n        }\n\n        //// See Compatibility Note A in the DjsDeferred constructor.\n        //// if (!this._next) {\n        ////    this._next = createDeferred();\n        //// }\n        //// return this._next.promise();\n\n        if (this._resolved) {\n            this.resolve.apply(this, this._arguments);\n        } else if (this._rejected) {\n            this.reject.apply(this, this._arguments);\n        }\n\n        return this;\n    },\n\n    /** Invokes success callbacks for this deferred object.\n     * All arguments are forwarded to success callbacks.\n     * @method DjsDeferred#resolve\n     */\n    resolve: function (/* args */) {\n        if (this._done) {\n            var i, len;\n            for (i = 0, len = this._done.length; i < len; i++) {\n                //// See Compability Note B - Fulfillment value.\n                //// var nextValue =\n                this._done[i].apply(null, arguments);\n            }\n\n            //// See Compatibility Note A in the DjsDeferred constructor.\n            //// this._next.resolve(nextValue);\n            //// delete this._next;\n\n            this._done = undefined;\n            this._resolved = false;\n            this._arguments = undefined;\n        } else {\n            this._resolved = true;\n            this._arguments = arguments;\n        }\n    },\n\n    /** Invokes error callbacks for this deferred object.\n     * All arguments are forwarded to error callbacks.\n     * @method DjsDeferred#reject\n     */\n    reject: function (/* args */) {\n        \n        if (this._fail) {\n            var i, len;\n            for (i = 0, len = this._fail.length; i < len; i++) {\n                this._fail[i].apply(null, arguments);\n            }\n\n            this._fail = undefined;\n            this._rejected = false;\n            this._arguments = undefined;\n        } else {\n            this._rejected = true;\n            this._arguments = arguments;\n        }\n    },\n\n    /** Returns a version of this object that has only the read-only methods available.\n     * @method DjsDeferred#promise\n     * @returns An object with only the promise object.\n     */\n\n    promise: function () {\n        var result = {};\n        result.then = forwardCall(this, \"then\", result);\n        return result;\n    }\n};\n\n/** Creates a deferred object.\n * @returns {DjsDeferred} A new deferred object. If jQuery is installed, then a jQueryDeferred object is returned, which provides a superset of features.\n*/\nfunction createDeferred() {\n    if (window.jQuery && window.jQuery.Deferred) {\n        return new window.jQuery.Deferred();\n    } else {\n        return new DjsDeferred();\n    }\n}\n\n\n\n\n/** createDeferred (see {@link module:datajs/deferred~createDeferred}) */\nexports.createDeferred = createDeferred;\n\n/** DjsDeferred (see {@link DjsDeferred}) */\nexports.DjsDeferred = DjsDeferred;}, \"odata\" : function(exports, module, require) {\n'use strict';\n\n /** @module odata */\n\n// Imports\nvar odataUtils    = exports.utils     = require('./odata/odatautils.js');\nvar odataHandler  = exports.handler   = require('./odata/handler.js');\nvar odataMetadata = exports.metadata  = require('./odata/metadata.js');\nvar odataNet      = exports.net       = require('./odata/net.js');\nvar odataJson     = exports.json      = require('./odata/json.js');\n                    exports.batch     = require('./odata/batch.js');\n                    \n\n\nvar utils = require('./utils.js');\nvar assigned = utils.assigned;\n\nvar defined = utils.defined;\nvar throwErrorCallback = utils.throwErrorCallback;\n\nvar invokeRequest = odataUtils.invokeRequest;\nvar MAX_DATA_SERVICE_VERSION = odataHandler.MAX_DATA_SERVICE_VERSION;\nvar prepareRequest = odataUtils.prepareRequest;\nvar metadataParser = odataMetadata.metadataParser;\n\n// CONTENT START\n\nvar handlers = [odataJson.jsonHandler, odataHandler.textHandler];\n\n/** Dispatches an operation to handlers.\n * @param {String} handlerMethod - Name of handler method to invoke.\n * @param {Object} requestOrResponse - request/response argument for delegated call.\n * @param {Object} context - context argument for delegated call.\n */\nfunction dispatchHandler(handlerMethod, requestOrResponse, context) {\n\n    var i, len;\n    for (i = 0, len = handlers.length; i < len && !handlers[i][handlerMethod](requestOrResponse, context); i++) {\n    }\n\n    if (i === len) {\n        throw { message: \"no handler for data\" };\n    }\n}\n\n/** Default success handler for OData.\n * @param data - Data to process.\n */\nexports.defaultSuccess = function (data) {\n\n    window.alert(window.JSON.stringify(data));\n};\n\nexports.defaultError = throwErrorCallback;\n\nexports.defaultHandler = {\n\n        /** Reads the body of the specified response by delegating to JSON handlers.\n        * @param response - Response object.\n        * @param context - Operation context.\n        */\n        read: function (response, context) {\n\n            if (response && assigned(response.body) && response.headers[\"Content-Type\"]) {\n                dispatchHandler(\"read\", response, context);\n            }\n        },\n\n        /** Write the body of the specified request by delegating to JSON handlers.\n        * @param request - Reques tobject.\n        * @param context - Operation context.\n        */\n        write: function (request, context) {\n\n            dispatchHandler(\"write\", request, context);\n        },\n\n        maxDataServiceVersion: MAX_DATA_SERVICE_VERSION,\n        accept: \"application/json;q=0.9, */*;q=0.1\"\n    };\n\nexports.defaultMetadata = []; //TODO check why is the defaultMetadata an Array? and not an Object.\n\n/** Reads data from the specified URL.\n * @param urlOrRequest - URL to read data from.\n * @param {Function} [success] - \n * @param {Function} [error] - \n * @param {Object} [handler] - \n * @param {Object} [httpClient] - \n * @param {Object} [metadata] - \n */\nexports.read = function (urlOrRequest, success, error, handler, httpClient, metadata) {\n\n    var request;\n    if (urlOrRequest instanceof String || typeof urlOrRequest === \"string\") {\n        request = { requestUri: urlOrRequest };\n    } else {\n        request = urlOrRequest;\n    }\n\n    return exports.request(request, success, error, handler, httpClient, metadata);\n};\n\n/** Sends a request containing OData payload to a server.\n * @param {Object} request - Object that represents the request to be sent.\n * @param {Function} [success] - \n * @param {Function} [error] - \n * @param {Object} [handler] - \n * @param {Object} [httpClient] - \n * @param {Object} [metadata] - \n */\nexports.request = function (request, success, error, handler, httpClient, metadata) {\n\n    success = success || exports.defaultSuccess;\n    error = error || exports.defaultError;\n    handler = handler || exports.defaultHandler;\n    httpClient = httpClient || odataNet.defaultHttpClient;\n    metadata = metadata || exports.defaultMetadata;\n\n    // Augment the request with additional defaults.\n    request.recognizeDates = utils.defined(request.recognizeDates, odataJson.jsonHandler.recognizeDates);\n    request.callbackParameterName = utils.defined(request.callbackParameterName, httpClient.callbackParameterName, odataNet.defaultHttpClient.callbackParameterName);\n    request.formatQueryString = utils.defined(request.formatQueryString, httpClient.formatQueryString, odataNet.defaultHttpClient.formatQueryString);\n    request.enableJsonpCallback = utils.defined(request.enableJsonpCallback, httpClient.enableJsonpCallback, odataNet.defaultHttpClient.enableJsonpCallback);\n\n    // Create the base context for read/write operations, also specifying complete settings.\n    var context = {\n        metadata: metadata,\n        recognizeDates: request.recognizeDates,\n        callbackParameterName: request.callbackParameterName,\n        formatQueryString: request.formatQueryString,\n        enableJsonpCallback: request.enableJsonpCallback\n    };\n\n    try {\n        odataUtils.prepareRequest(request, handler, context);\n        return odataUtils.invokeRequest(request, success, error, handler, httpClient, context);\n    } catch (err) {\n        // errors in success handler for sync requests are catched here and result in error handler calls. \n        // So here we fix this and throw that error further.\n        if (err.bIsSuccessHandlerError) {\n            throw err;\n        } else {\n            error(err);\n        }\n    }\n\n};\n\n/** Parses the csdl metadata to ODataJS metatdata format. This method can be used when the metadata is retrieved using something other than odatajs\n * @param {string} csdlMetadataDocument - A string that represents the entire csdl metadata.\n * @returns {Object} An object that has the representation of the metadata in odatajs format.\n */\nexports.parseMetadata = function (csdlMetadataDocument) {\n\n    return metadataParser(null, csdlMetadataDocument);\n};\n\n// Configure the batch handler to use the default handler for the batch parts.\nexports.batch.batchHandler.partHandler = exports.defaultHandler;\nexports.metadataHandler =  odataMetadata.metadataHandler;\nexports.jsonHandler =  odataJson.jsonHandler;\n}, \"batch\" : function(exports, module, require) {\n'use strict';\n\n/** @module odata/batch */\n\nvar utils    = require('./../utils.js');\nvar odataUtils    = require('./odatautils.js');\nvar odataHandler = require('./handler.js');\n\nvar extend = utils.extend;\nvar isArray = utils.isArray;\nvar trimString = utils.trimString;\n\nvar contentType = odataHandler.contentType;\nvar handler = odataHandler.handler;\nvar isBatch = odataUtils.isBatch;\nvar MAX_DATA_SERVICE_VERSION = odataHandler.MAX_DATA_SERVICE_VERSION;\nvar normalizeHeaders = odataUtils.normalizeHeaders;\n//TODO var payloadTypeOf = odata.payloadTypeOf;\nvar prepareRequest = odataUtils.prepareRequest;\n\n\n// Imports\n\n// CONTENT START\nvar batchMediaType = \"multipart/mixed\";\nvar responseStatusRegex = /^HTTP\\/1\\.\\d (\\d{3}) (.*)$/i;\nvar responseHeaderRegex = /^([^()<>@,;:\\\\\"\\/[\\]?={} \\t]+)\\s?:\\s?(.*)/;\n\n/** Calculates a random 16 bit number and returns it in hexadecimal format.\n * @returns {String} A 16-bit number in hex format.\n */\nfunction hex16() {\n\n    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substr(1);\n}\n\n/** Creates a string that can be used as a multipart request boundary.\n * @param {String} [prefix] - \n * @returns {String} Boundary string of the format: <prefix><hex16>-<hex16>-<hex16>\n */\nfunction createBoundary(prefix) {\n\n    return prefix + hex16() + \"-\" + hex16() + \"-\" + hex16();\n}\n\n/** Gets the handler for data serialization of individual requests / responses in a batch.\n * @param context - Context used for data serialization.\n * @returns Handler object\n */\nfunction partHandler(context) {\n\n    return context.handler.partHandler;\n}\n\n/** Gets the current boundary used for parsing the body of a multipart response.\n * @param context - Context used for parsing a multipart response.\n * @returns {String} Boundary string.\n */\nfunction currentBoundary(context) {\n    var boundaries = context.boundaries;\n    return boundaries[boundaries.length - 1];\n}\n\n/** Parses a batch response.\n * @param handler - This handler.\n * @param {String} text - Batch text.\n * @param {Object} context - Object with parsing context.\n * @return An object representation of the batch.\n */\nfunction batchParser(handler, text, context) {\n\n    var boundary = context.contentType.properties[\"boundary\"];\n    return { __batchResponses: readBatch(text, { boundaries: [boundary], handlerContext: context }) };\n}\n\n/** Serializes a batch object representation into text.\n * @param handler - This handler.\n * @param {Object} data - Representation of a batch.\n * @param {Object} context - Object with parsing context.\n * @return An text representation of the batch object; undefined if not applicable.#\n */\nfunction batchSerializer(handler, data, context) {\n\n    var cType = context.contentType = context.contentType || contentType(batchMediaType);\n    if (cType.mediaType === batchMediaType) {\n        return writeBatch(data, context);\n    }\n}\n\n/** Parses a multipart/mixed response body from from the position defined by the context.\n * @param {String}  text - Body of the multipart/mixed response.\n * @param context - Context used for parsing.\n * @return Array of objects representing the individual responses.\n */\nfunction readBatch(text, context) {\n    var delimiter = \"--\" + currentBoundary(context);\n\n    // Move beyond the delimiter and read the complete batch\n    readTo(text, context, delimiter);\n\n    // Ignore the incoming line\n    readLine(text, context);\n\n    // Read the batch parts\n    var responses = [];\n    var partEnd = null;\n\n    while (partEnd !== \"--\" && context.position < text.length) {\n        var partHeaders = readHeaders(text, context);\n        var partContentType = contentType(partHeaders[\"Content-Type\"]);\n\n        var changeResponses;\n        if (partContentType && partContentType.mediaType === batchMediaType) {\n            context.boundaries.push(partContentType.properties.boundary);\n            try {\n                changeResponses = readBatch(text, context);\n            } catch (e) {\n                e.response = readResponse(text, context, delimiter);\n                changeResponses = [e];\n            }\n            responses.push({ __changeResponses: changeResponses });\n            context.boundaries.pop();\n            readTo(text, context, \"--\" + currentBoundary(context));\n        } else {\n            if (!partContentType || partContentType.mediaType !== \"application/http\") {\n                throw { message: \"invalid MIME part type \" };\n            }\n            // Skip empty line\n            readLine(text, context);\n            // Read the response\n            var response = readResponse(text, context, delimiter);\n            try {\n                if (response.statusCode >= 200 && response.statusCode <= 299) {\n                    partHandler(context.handlerContext).read(response, context.handlerContext);\n                } else {\n                    // Keep track of failed responses and continue processing the batch.\n                    response = { message: \"HTTP request failed\", response: response };\n                }\n            } catch (e) {\n                response = e;\n            }\n\n            responses.push(response);\n        }\n\n        partEnd = text.substr(context.position, 2);\n\n        // Ignore the incoming line.\n        readLine(text, context);\n    }\n    return responses;\n}\n\n/** Parses the http headers in the text from the position defined by the context.\n * @param {String} text - Text containing an http response's headers\n * @param context - Context used for parsing.\n * @returns Object containing the headers as key value pairs.\n * This function doesn't support split headers and it will stop reading when it hits two consecutive line breaks.\n*/\nfunction readHeaders(text, context) {\n    var headers = {};\n    var parts;\n    var line;\n    var pos;\n\n    do {\n        pos = context.position;\n        line = readLine(text, context);\n        parts = responseHeaderRegex.exec(line);\n        if (parts !== null) {\n            headers[parts[1]] = parts[2];\n        } else {\n            // Whatever was found is not a header, so reset the context position.\n            context.position = pos;\n        }\n    } while (line && parts);\n\n    normalizeHeaders(headers);\n\n    return headers;\n}\n\n/** Parses an HTTP response.\n * @param {String} text -Text representing the http response.\n * @param context optional - Context used for parsing.\n * @param {String} delimiter -String used as delimiter of the multipart response parts.\n * @return Object representing the http response.\n */\nfunction readResponse(text, context, delimiter) {\n    // Read the status line.\n    var pos = context.position;\n    var match = responseStatusRegex.exec(readLine(text, context));\n\n    var statusCode;\n    var statusText;\n    var headers;\n\n    if (match) {\n        statusCode = match[1];\n        statusText = match[2];\n        headers = readHeaders(text, context);\n        readLine(text, context);\n    } else {\n        context.position = pos;\n    }\n\n    return {\n        statusCode: statusCode,\n        statusText: statusText,\n        headers: headers,\n        body: readTo(text, context, \"\\r\\n\" + delimiter)\n    };\n}\n\n/** Returns a substring from the position defined by the context up to the next line break (CRLF).\n * @param {String} text - Input string.\n * @param context - Context used for reading the input string.\n * @returns {String} Substring to the first ocurrence of a line break or null if none can be found. \n */\nfunction readLine(text, context) {\n\n    return readTo(text, context, \"\\r\\n\");\n}\n\n/** Returns a substring from the position given by the context up to value defined by the str parameter and increments the position in the context.\n * @param {String} text - Input string.\n * @param context - Context used for reading the input string.\n * @param {String} [str] - Substring to read up to.\n * @returns {String} Substring to the first ocurrence of str or the end of the input string if str is not specified. Null if the marker is not found.\n */\nfunction readTo(text, context, str) {\n    var start = context.position || 0;\n    var end = text.length;\n    if (str) {\n        end = text.indexOf(str, start);\n        if (end === -1) {\n            return null;\n        }\n        context.position = end + str.length;\n    } else {\n        context.position = end;\n    }\n\n    return text.substring(start, end);\n}\n\n/** Serializes a batch request object to a string.\n * @param data - Batch request object in payload representation format\n * @param context - Context used for the serialization\n * @returns {String} String representing the batch request\n */\nfunction writeBatch(data, context) {\n    if (!isBatch(data)) {\n        throw { message: \"Data is not a batch object.\" };\n    }\n\n    var batchBoundary = createBoundary(\"batch_\");\n    var batchParts = data.__batchRequests;\n    var batch = \"\";\n    var i, len;\n    for (i = 0, len = batchParts.length; i < len; i++) {\n        batch += writeBatchPartDelimiter(batchBoundary, false) +\n                 writeBatchPart(batchParts[i], context);\n    }\n    batch += writeBatchPartDelimiter(batchBoundary, true);\n\n    // Register the boundary with the request content type.\n    var contentTypeProperties = context.contentType.properties;\n    contentTypeProperties.boundary = batchBoundary;\n\n    return batch;\n}\n\n/** Creates the delimiter that indicates that start or end of an individual request.\n * @param {String} boundary Boundary string used to indicate the start of the request\n * @param {Boolean} close - Flag indicating that a close delimiter string should be generated\n * @returns {String} Delimiter string\n */\nfunction writeBatchPartDelimiter(boundary, close) {\n    var result = \"\\r\\n--\" + boundary;\n    if (close) {\n        result += \"--\";\n    }\n\n    return result + \"\\r\\n\";\n}\n\n/** Serializes a part of a batch request to a string. A part can be either a GET request or\n * a change set grouping several CUD (create, update, delete) requests.\n * @param part - Request or change set object in payload representation format\n * @param context - Object containing context information used for the serialization\n * @param {boolean} [nested] - \n * @returns {String} String representing the serialized part\n * A change set is an array of request objects and they cannot be nested inside other change sets.\n */\nfunction writeBatchPart(part, context, nested) {\n    \n\n    var changeSet = part.__changeRequests;\n    var result;\n    if (isArray(changeSet)) {\n        if (nested) {\n            throw { message: \"Not Supported: change set nested in other change set\" };\n        }\n\n        var changeSetBoundary = createBoundary(\"changeset_\");\n        result = \"Content-Type: \" + batchMediaType + \"; boundary=\" + changeSetBoundary + \"\\r\\n\";\n        var i, len;\n        for (i = 0, len = changeSet.length; i < len; i++) {\n            result += writeBatchPartDelimiter(changeSetBoundary, false) +\n                 writeBatchPart(changeSet[i], context, true);\n        }\n\n        result += writeBatchPartDelimiter(changeSetBoundary, true);\n    } else {\n        result = \"Content-Type: application/http\\r\\nContent-Transfer-Encoding: binary\\r\\n\\r\\n\";\n        var partContext = extend({}, context);\n        partContext.handler = handler;\n        partContext.request = part;\n        partContext.contentType = null;\n\n        prepareRequest(part, partHandler(context), partContext);\n        result += writeRequest(part);\n    }\n\n    return result;\n}\n\n/** Serializes a request object to a string.\n * @param request - Request object to serialize\n * @returns {String} String representing the serialized request\n */\nfunction writeRequest(request) {\n    var result = (request.method ? request.method : \"GET\") + \" \" + request.requestUri + \" HTTP/1.1\\r\\n\";\n    for (var name in request.headers) {\n        if (request.headers[name]) {\n            result = result + name + \": \" + request.headers[name] + \"\\r\\n\";\n        }\n    }\n\n    result += \"\\r\\n\";\n\n    if (request.body) {\n        result += request.body;\n    }\n\n    return result;\n}\n\n\n\n/** batchHandler (see {@link module:odata/batch~batchParser}) */\nexports.batchHandler = handler(batchParser, batchSerializer, batchMediaType, MAX_DATA_SERVICE_VERSION);\n\n/** batchSerializer (see {@link module:odata/batch~batchSerializer}) */\nexports.batchSerializer = batchSerializer;\n\n/** writeRequest (see {@link module:odata/batch~writeRequest}) */\nexports.writeRequest = writeRequest;}, \"handler\" : function(exports, module, require) {\n'use strict';\n\n/** @module odata/handler */\n\n\nvar utils    = require('./../utils.js');\nvar oDataUtils    = require('./odatautils.js');\n\n// Imports.\nvar assigned = utils.assigned;\nvar extend = utils.extend;\nvar trimString = utils.trimString;\nvar maxVersion = oDataUtils.maxVersion;\nvar MAX_DATA_SERVICE_VERSION = \"4.0\";\n\n/** Parses a string into an object with media type and properties.\n * @param {String} str - String with media type to parse.\n * @return null if the string is empty; an object with 'mediaType' and a 'properties' dictionary otherwise.\n */\nfunction contentType(str) {\n\n    if (!str) {\n        return null;\n    }\n\n    var contentTypeParts = str.split(\";\");\n    var properties = {};\n\n    var i, len;\n    for (i = 1, len = contentTypeParts.length; i < len; i++) {\n        var contentTypeParams = contentTypeParts[i].split(\"=\");\n        properties[trimString(contentTypeParams[0])] = contentTypeParams[1];\n    }\n\n    return { mediaType: trimString(contentTypeParts[0]), properties: properties };\n}\n\n/** Serializes an object with media type and properties dictionary into a string.\n * @param contentType - Object with media type and properties dictionary to serialize.\n * @return String representation of the media type object; undefined if contentType is null or undefined.\n */\nfunction contentTypeToString(contentType) {\n    if (!contentType) {\n        return undefined;\n    }\n\n    var result = contentType.mediaType;\n    var property;\n    for (property in contentType.properties) {\n        result += \";\" + property + \"=\" + contentType.properties[property];\n    }\n    return result;\n}\n\n/** Creates an object that is going to be used as the context for the handler's parser and serializer.\n * @param contentType - Object with media type and properties dictionary.\n * @param {String} dataServiceVersion - String indicating the version of the protocol to use.\n * @param context - Operation context.\n * @param handler - Handler object that is processing a request or response.\n * @return Context object.\n */\nfunction createReadWriteContext(contentType, dataServiceVersion, context, handler) {\n\n    var rwContext = {};\n    extend(rwContext, context);\n    extend(rwContext, {\n        contentType: contentType,\n        dataServiceVersion: dataServiceVersion,\n        handler: handler\n    });\n\n    return rwContext;\n}\n\n/** Sets a request header's value. If the header has already a value other than undefined, null or empty string, then this method does nothing.\n * @param request - Request object on which the header will be set.\n * @param {String} name - Header name.\n * @param {String} value - Header value.\n */\nfunction fixRequestHeader(request, name, value) {\n    if (!request) {\n        return;\n    }\n\n    var headers = request.headers;\n    if (!headers[name]) {\n        headers[name] = value;\n    }\n}\n\n/** Sets the DataServiceVersion header of the request if its value is not yet defined or of a lower version.\n * @param request - Request object on which the header will be set.\n * @param {String} version - Version value.\n *  If the request has already a version value higher than the one supplied the this function does nothing.\n */\nfunction fixDataServiceVersionHeader(request, version) {   \n\n    if (request) {\n        var headers = request.headers;\n        var dsv = headers[\"OData-Version\"];\n        headers[\"OData-Version\"] = dsv ? maxVersion(dsv, version) : version;\n    }\n}\n\n/** Gets the value of a request or response header.\n * @param requestOrResponse - Object representing a request or a response.\n * @param {String} name - Name of the header to retrieve.\n * @returns {String} String value of the header; undefined if the header cannot be found.\n */\nfunction getRequestOrResponseHeader(requestOrResponse, name) {\n\n    var headers = requestOrResponse.headers;\n    return (headers && headers[name]) || undefined;\n}\n\n/** Gets the value of the Content-Type header from a request or response.\n * @param requestOrResponse - Object representing a request or a response.\n * @returns {Object} Object with 'mediaType' and a 'properties' dictionary; null in case that the header is not found or doesn't have a value.\n */\nfunction getContentType(requestOrResponse) {\n\n    return contentType(getRequestOrResponseHeader(requestOrResponse, \"Content-Type\"));\n}\n\nvar versionRE = /^\\s?(\\d+\\.\\d+);?.*$/;\n/** Gets the value of the DataServiceVersion header from a request or response.\n * @param requestOrResponse - Object representing a request or a response.\n * @returns {String} Data service version; undefined if the header cannot be found.\n */\nfunction getDataServiceVersion(requestOrResponse) {\n\n    var value = getRequestOrResponseHeader(requestOrResponse, \"OData-Version\");\n    if (value) {\n        var matches = versionRE.exec(value);\n        if (matches && matches.length) {\n            return matches[1];\n        }\n    }\n\n    // Fall through and return undefined.\n}\n\n/** Checks that a handler can process a particular mime type.\n * @param handler - Handler object that is processing a resquest or response.\n * @param cType - Object with 'mediaType' and a 'properties' dictionary.\n * @returns {Boolean} True if the handler can process the mime type; false otherwise.\n *\n * The following check isn't as strict because if cType.mediaType = application/; it will match an accept value of \"application/xml\";\n * however in practice we don't not expect to see such \"suffixed\" mimeTypes for the handlers.\n */\nfunction handlerAccepts(handler, cType) {\n    return handler.accept.indexOf(cType.mediaType) >= 0;\n}\n\n/** Invokes the parser associated with a handler for reading the payload of a HTTP response.\n * @param handler - Handler object that is processing the response.\n * @param {Function} parseCallback - Parser function that will process the response payload.\n * @param response - HTTP response whose payload is going to be processed.\n * @param context - Object used as the context for processing the response.\n * @returns {Boolean} True if the handler processed the response payload and the response.data property was set; false otherwise.\n */\nfunction handlerRead(handler, parseCallback, response, context) {\n\n    if (!response || !response.headers) {\n        return false;\n    }\n\n    var cType = getContentType(response);\n    var version = getDataServiceVersion(response) || \"\";\n    var body = response.body;\n\n    if (!assigned(body)) {\n        return false;\n    }\n\n    if (handlerAccepts(handler, cType)) {\n        var readContext = createReadWriteContext(cType, version, context, handler);\n        readContext.response = response;\n        response.data = parseCallback(handler, body, readContext);\n        return response.data !== undefined;\n    }\n\n    return false;\n}\n\n/** Invokes the serializer associated with a handler for generating the payload of a HTTP request.\n * @param handler - Handler object that is processing the request.\n * @param {Function} serializeCallback - Serializer function that will generate the request payload.\n * @param request - HTTP request whose payload is going to be generated.\n * @param context - Object used as the context for serializing the request.\n * @returns {Boolean} True if the handler serialized the request payload and the request.body property was set; false otherwise.\n */\nfunction handlerWrite(handler, serializeCallback, request, context) {\n    if (!request || !request.headers) {\n        return false;\n    }\n\n    var cType = getContentType(request);\n    var version = getDataServiceVersion(request);\n\n    if (!cType || handlerAccepts(handler, cType)) {\n        var writeContext = createReadWriteContext(cType, version, context, handler);\n        writeContext.request = request;\n\n        request.body = serializeCallback(handler, request.data, writeContext);\n\n        if (request.body !== undefined) {\n            fixDataServiceVersionHeader(request, writeContext.dataServiceVersion || \"4.0\");\n\n            fixRequestHeader(request, \"Content-Type\", contentTypeToString(writeContext.contentType));\n            fixRequestHeader(request, \"OData-MaxVersion\", handler.maxDataServiceVersion);\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/** Creates a handler object for processing HTTP requests and responses.\n * @param {Function} parseCallback - Parser function that will process the response payload.\n * @param {Function} serializeCallback - Serializer function that will generate the request payload.\n * @param {String} accept - String containing a comma separated list of the mime types that this handler can work with.\n * @param {String} maxDataServiceVersion - String indicating the highest version of the protocol that this handler can work with.\n * @returns {Object} Handler object.\n */\nfunction handler(parseCallback, serializeCallback, accept, maxDataServiceVersion) {\n\n    return {\n        accept: accept,\n        maxDataServiceVersion: maxDataServiceVersion,\n\n        read: function (response, context) {\n            return handlerRead(this, parseCallback, response, context);\n        },\n\n        write: function (request, context) {\n            return handlerWrite(this, serializeCallback, request, context);\n        }\n    };\n}\n\nfunction textParse(handler, body /*, context */) {\n    return body;\n}\n\nfunction textSerialize(handler, data /*, context */) {\n    if (assigned(data)) {\n        return data.toString();\n    } else {\n        return undefined;\n    }\n}\n\n\n\n\nexports.textHandler = handler(textParse, textSerialize, \"text/plain\", MAX_DATA_SERVICE_VERSION);\nexports.contentType = contentType;\nexports.contentTypeToString = contentTypeToString;\nexports.handler = handler;\nexports.createReadWriteContext = createReadWriteContext;\nexports.fixRequestHeader = fixRequestHeader;\nexports.getRequestOrResponseHeader = getRequestOrResponseHeader;\nexports.getContentType = getContentType;\nexports.getDataServiceVersion = getDataServiceVersion;\nexports.MAX_DATA_SERVICE_VERSION = MAX_DATA_SERVICE_VERSION;}, \"json\" : function(exports, module, require) {\n\n/** @module odata/json */\n\n\n\nvar utils        = require('./../utils.js');\nvar oDataUtils   = require('./odatautils.js');\nvar oDataHandler = require('./handler.js');\n\nvar odataNs = \"odata\";\nvar odataAnnotationPrefix = odataNs + \".\";\nvar contextUrlAnnotation = \"@\" + odataAnnotationPrefix + \"context\";\n\nvar assigned = utils.assigned;\nvar defined = utils.defined;\nvar isArray = utils.isArray;\n//var isDate = utils.isDate;\nvar isObject = utils.isObject;\n//var normalizeURI = utils.normalizeURI;\nvar parseInt10 = utils.parseInt10;\nvar getFormatKind = utils.getFormatKind;\nvar convertByteArrayToHexString = utils.convertByteArrayToHexString;\n\n\nvar formatDateTimeOffset = oDataUtils.formatDateTimeOffset;\nvar formatDuration = oDataUtils.formatDuration;\nvar formatNumberWidth = oDataUtils.formatNumberWidth;\nvar getCanonicalTimezone = oDataUtils.getCanonicalTimezone;\nvar handler = oDataUtils.handler;\nvar isComplex = oDataUtils.isComplex;\nvar isPrimitive = oDataUtils.isPrimitive;\nvar isCollectionType = oDataUtils.isCollectionType;\nvar lookupComplexType = oDataUtils.lookupComplexType;\nvar lookupEntityType = oDataUtils.lookupEntityType;\nvar lookupSingleton = oDataUtils.lookupSingleton;\nvar lookupEntitySet = oDataUtils.lookupEntitySet;\nvar lookupDefaultEntityContainer = oDataUtils.lookupDefaultEntityContainer;\nvar lookupProperty = oDataUtils.lookupProperty;\nvar MAX_DATA_SERVICE_VERSION = oDataUtils.MAX_DATA_SERVICE_VERSION;\nvar maxVersion = oDataUtils.maxVersion;\n\nvar isPrimitiveEdmType = oDataUtils.isPrimitiveEdmType;\nvar isGeographyEdmType = oDataUtils.isGeographyEdmType;\nvar isGeometryEdmType = oDataUtils.isGeometryEdmType;\n\nvar PAYLOADTYPE_FEED = \"f\";\nvar PAYLOADTYPE_ENTRY = \"e\";\nvar PAYLOADTYPE_PROPERTY = \"p\";\nvar PAYLOADTYPE_COLLECTION = \"c\";\nvar PAYLOADTYPE_ENUMERATION_PROPERTY = \"enum\";\nvar PAYLOADTYPE_SVCDOC = \"s\";\nvar PAYLOADTYPE_ENTITY_REF_LINK = \"erl\";\nvar PAYLOADTYPE_ENTITY_REF_LINKS = \"erls\";\n\nvar PAYLOADTYPE_VALUE = \"v\";\n\nvar PAYLOADTYPE_DELTA = \"d\";\nvar DELTATYPE_FEED = \"f\";\nvar DELTATYPE_DELETED_ENTRY = \"de\";\nvar DELTATYPE_LINK = \"l\";\nvar DELTATYPE_DELETED_LINK = \"dl\";\n\nvar jsonMediaType = \"application/json\";\nvar jsonContentType = oDataHandler.contentType(jsonMediaType);\n\nvar jsonSerializableMetadata = [\"@odata.id\", \"@odata.type\"];\n\n\n\n\n\n/** Extend JSON OData payload with metadata\n * @param handler - This handler.\n * @param text - Payload text (this parser also handles pre-parsed objects).\n * @param {Object} context - Object with parsing context.\n * @return An object representation of the OData payload.\n */\nfunction jsonParser(handler, text, context) {\n    var recognizeDates = defined(context.recognizeDates, handler.recognizeDates);\n    var model = context.metadata;\n    var json = (typeof text === \"string\") ? JSON.parse(text) : text;\n    var metadataContentType;\n    if (assigned(context.contentType) && assigned(context.contentType.properties)) {\n        metadataContentType = context.contentType.properties[\"odata.metadata\"]; //TODO convert to lower before comparism\n    }\n\n    var payloadFormat = getFormatKind(metadataContentType, 1); // none: 0, minimal: 1, full: 2\n\n    // No errors should be throw out if we could not parse the json payload, instead we should just return the original json object.\n    if (payloadFormat === 0) {\n        return json;\n    }\n    else if (payloadFormat === 1) {\n        return addMinimalMetadataToJsonPayload(json, model, recognizeDates);\n    }\n    else if (payloadFormat === 2) {\n        // to do: using the EDM Model to get the type of each property instead of just guessing.\n        return addFullMetadataToJsonPayload(json, model, recognizeDates);\n    }\n    else {\n        return json;\n    }\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n// The regular expression corresponds to something like this:\n// /Date(123+60)/\n//\n// This first number is date ticks, the + may be a - and is optional,\n// with the second number indicating a timezone offset in minutes.\n//\n// On the wire, the leading and trailing forward slashes are\n// escaped without being required to so the chance of collisions is reduced;\n// however, by the time we see the objects, the characters already\n// look like regular forward slashes.\nvar jsonDateRE = /^\\/Date\\((-?\\d+)(\\+|-)?(\\d+)?\\)\\/$/;\n\n\n// Some JSON implementations cannot produce the character sequence \\/\n// which is needed to format DateTime and DateTimeOffset into the\n// JSON string representation defined by the OData protocol.\n// See the history of this file for a candidate implementation of\n// a 'formatJsonDateString' function.\n\n\nvar jsonReplacer = function (_, value) {\n    /// <summary>JSON replacer function for converting a value to its JSON representation.</summary>\n    /// <param value type=\"Object\">Value to convert.</param>\n    /// <returns type=\"String\">JSON representation of the input value.</returns>\n    /// <remarks>\n    ///   This method is used during JSON serialization and invoked only by the JSON.stringify function.\n    ///   It should never be called directly.\n    /// </remarks>\n\n    if (value && value.__edmType === \"Edm.Time\") {\n        return formatDuration(value);\n    } else {\n        return value;\n    }\n};\n\n/** Serializes a ODataJs payload structure to the wire format which can be send to the server\n * @param handler - This handler.\n * @param data - Data to serialize.\n * @param {Object} context - Object with serialization context.\n * @returns {String} The string representation of data.\n */\nfunction jsonSerializer(handler, data, context) {\n\n    var dataServiceVersion = context.dataServiceVersion || \"4.0\";\n    var cType = context.contentType = context.contentType || jsonContentType;\n\n    if (cType && cType.mediaType === jsonContentType.mediaType) {\n        context.dataServiceVersion = maxVersion(dataServiceVersion, \"4.0\");\n        var newdata = formatJsonRequestPayload(data);\n        if (newdata) {\n            return JSON.stringify(newdata,jsonReplacer);\n        }\n    }\n    return undefined;\n}\n\n\n\n\n/** Convert OData objects for serialisation in to a new data structure\n * @param data - Data to serialize.\n * @returns {String} The string representation of data.\n */\nfunction formatJsonRequestPayload(data) {\n    if (!data) {\n        return data;\n    }\n\n    if (isPrimitive(data)) {\n        return data;\n    }\n\n    if (isArray(data)) {\n        var newArrayData = [];\n        var i, len;\n        for (i = 0, len = data.length; i < len; i++) {\n            newArrayData[i] = formatJsonRequestPayload(data[i]);\n        }\n\n        return newArrayData;\n    }\n\n    var newdata = {};\n    for (var property in data) {\n        if (isJsonSerializableProperty(property)) {\n            newdata[property] = formatJsonRequestPayload(data[property]);\n        }\n    }\n\n    return newdata;\n}\n\n/** Determine form the attribute name if the attribute is a serializable property\n * @param attribute\n * @returns {boolean}\n */\nfunction isJsonSerializableProperty(attribute) {\n    if (!attribute) {\n        return false;\n    }\n\n    if (attribute.indexOf(\"@odata.\") == -1) {\n        return true;\n    }\n\n    var i, len;\n    for (i = 0, len = jsonSerializableMetadata.length; i < len; i++) {\n        var name = jsonSerializableMetadata[i];\n        if (attribute.indexOf(name) != -1) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/** Creates an object containing information for the json payload.\n * @param {String} kind - JSON payload kind\n * @param {String} type - Type name of the JSON payload.\n * @returns {Object} Object with kind and type fields.\n */\nfunction jsonMakePayloadInfo(kind, type) {\n    return { kind: kind, type: type || null };\n}\n\n\n\n/** Add metadata to an JSON payload complex object containing full metadata\n * @param {Object} data - Data structure to be extended\n * @param {Object} model - Metadata model\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction addFullMetadataToJsonPayload(data, model, recognizeDates) {\n    var type;\n    if (utils.isObject(data)) {\n        for (var key in data) {\n            if (data.hasOwnProperty(key)) {\n                if (key.indexOf('@') === -1) {\n                    if (utils.isArray(data[key])) {\n                        for (var i = 0; i < data[key].length; ++i) {\n                            addFullMetadataToJsonPayload(data[key][i], model, recognizeDates);\n                        }\n                    } else if (utils.isObject(data[key])) {\n                        if (data[key] !== null) {\n                            //don't step into geo.. objects\n                            type = data[key+'@odata.type'];\n                            if (!type) {\n                                //type unknown\n                                addFullMetadataToJsonPayload(data[key], model, recognizeDates);\n                            } else {\n                                type = type.substring(1);\n                                if  (isGeographyEdmType(type) || isGeometryEdmType(type)) {\n                                    // don't add type info for geo* types\n                                } else {\n                                    addFullMetadataToJsonPayload(data[key], model, recognizeDates);\n                                }\n                            }\n                        }\n                    } else {\n                        type = data[key + '@odata.type'];\n\n                        // On .Net OData library, some basic EDM type is omitted, e.g. Edm.String, Edm.Int, and etc.\n                        // For the full metadata payload, we need to full fill the @data.type for each property if it is missing.\n                        // We do this is to help the OlingoJS consumers to easily get the type of each property.\n                        if (!assigned(type)) {\n                            // Guessing the \"type\" from the type of the value is not the right way here.\n                            // To do: we need to get the type from metadata instead of guessing.\n                            var typeFromObject = typeof data[key];\n                            if (typeFromObject === 'string') {\n                                addType(data, key, 'String');\n                            } else if (typeFromObject === 'boolean') {\n                                addType(data, key, 'Boolean');\n                            } else if (typeFromObject === 'number') {\n                                if (data[key] % 1 === 0) { // has fraction\n                                    addType(data, key, 'Int32'); // the biggst integer\n                                } else {\n                                    addType(data, key, 'Decimal'); // the biggst float single,doulbe,decimal\n                                }\n                            }\n                        }\n                        else {\n                            if (recognizeDates) {\n                                convertDatesNoEdm(data, key, type.substring(1));\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    return data;\n}\n\n/** Loop through the properties of an JSON payload object, look up the type info of the property and call\n * the appropriate add*MetadataToJsonPayloadObject function\n * @param {Object} data - Data structure to be extended\n * @param {String} objectInfoType - Information about the data (name,type,typename,...)\n * @param {String} baseURI - Base Url\n * @param {Object} model - Metadata model\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction checkProperties(data, objectInfoType, baseURI, model, recognizeDates) {\n    for (var name in data) {\n        if (name.indexOf(\"@\") === -1) {\n            var curType = objectInfoType;\n            var propertyValue = data[name];\n            var property = lookupProperty(curType.property,name); //TODO SK add check for parent type\n\n            while (( property === null) && (curType.baseType !== undefined)) {\n                curType = lookupEntityType(curType.baseType, model);\n                property = lookupProperty(curType.property,name);\n            }\n\n            if ( isArray(propertyValue)) {\n                //data[name+'@odata.type'] = '#' + property.type;\n                if (isCollectionType(property.type)) {\n                    addTypeColNoEdm(data,name,property.type.substring(11,property.type.length-1));\n                } else {\n                    addTypeNoEdm(data,name,property.type);\n                }\n\n\n                for ( var i = 0; i < propertyValue.length; i++) {\n                    addMetadataToJsonMinimalPayloadComplex(propertyValue[i], property, baseURI, model, recognizeDates);\n                }\n            } else if (isObject(propertyValue) && (propertyValue !== null)) {\n                addMetadataToJsonMinimalPayloadComplex(propertyValue, property, baseURI, model, recognizeDates);\n            } else {\n                //data[name+'@odata.type'] = '#' + property.type;\n                addTypeNoEdm(data,name,property.type);\n                if (recognizeDates) {\n                    convertDates(data, name, property.type);\n                }\n            }\n        }\n    }\n}\n\n\n\n/** Add metadata to an JSON payload object containing minimal metadata\n * @param {Object} data - Json response payload object\n * @param {Object} model - Object describing an OData conceptual schema\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n * @returns {Object} Object in the library's representation.\n */\nfunction addMinimalMetadataToJsonPayload(data, model, recognizeDates) {\n\n    if (!assigned(model) || isArray(model)) {\n        return data;\n    }\n\n    var baseURI = data[contextUrlAnnotation];\n    var payloadInfo = createPayloadInfo(data, model);\n\n    switch (payloadInfo.detectedPayloadKind) {\n\n        case PAYLOADTYPE_VALUE:\n            if (payloadInfo.type !== null) {\n                return addMetadataToJsonMinimalPayloadEntity(data, payloadInfo, baseURI, model, recognizeDates);\n            } else {\n                return addTypeNoEdm(data,'value', payloadInfo.typeName);\n            }\n\n        case PAYLOADTYPE_FEED:\n            return addMetadataToJsonMinimalPayloadFeed(data, model, payloadInfo, baseURI, recognizeDates);\n\n        case PAYLOADTYPE_ENTRY:\n            return addMetadataToJsonMinimalPayloadEntity(data, payloadInfo, baseURI, model, recognizeDates);\n\n        case PAYLOADTYPE_COLLECTION:\n            return addMetadataToJsonMinimalPayloadCollection(data, model, payloadInfo, baseURI, recognizeDates);\n\n        case PAYLOADTYPE_PROPERTY:\n            if (payloadInfo.type !== null) {\n                return addMetadataToJsonMinimalPayloadEntity(data, payloadInfo, baseURI, model, recognizeDates);\n            } else {\n                return addTypeNoEdm(data,'value', payloadInfo.typeName);\n            }\n\n        case PAYLOADTYPE_SVCDOC:\n            return data;\n\n        case PAYLOADTYPE_LINKS:\n            return data;\n    }\n\n    return data;\n}\n\n/** Add metadata to an JSON payload feed object containing minimal metadata\n * @param {Object} data - Data structure to be extended\n * @param {Object} model - Metadata model\n * @param {String} feedInfo - Information about the data (name,type,typename,...)\n * @param {String} baseURI - Base Url\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction addMetadataToJsonMinimalPayloadFeed(data, model, feedInfo, baseURI, recognizeDates) {\n    var entries = [];\n    var items = data.value;\n    var i,len;\n    var entry;\n    for (i = 0, len = items.length; i < len; i++) {\n        var item = items[i];\n        if ( defined(item['@odata.type'])) { // in case of mixed feeds\n            var typeName = item['@odata.type'].substring(1);\n            var type = lookupEntityType( typeName, model);\n            var entryInfo = {\n                contentTypeOdata : feedInfo.contentTypeOdata,\n                detectedPayloadKind : feedInfo.detectedPayloadKind,\n                name : feedInfo.name,\n                type : type,\n                typeName : typeName\n            };\n\n            entry = addMetadataToJsonMinimalPayloadEntity(item, entryInfo, baseURI, model, recognizeDates);\n        } else {\n            entry = addMetadataToJsonMinimalPayloadEntity(item, feedInfo, baseURI, model, recognizeDates);\n        }\n\n        entries.push(entry);\n    }\n    data.value = entries;\n    return data;\n}\n\n\n/** Add metadata to an JSON payload entity object containing minimal metadata\n * @param {Object} data - Data structure to be extended\n * @param {String} objectInfo - Information about the data (name,type,typename,...)\n * @param {String} baseURI - Base Url\n * @param {Object} model - Metadata model\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction addMetadataToJsonMinimalPayloadEntity(data, objectInfo, baseURI, model, recognizeDates) {\n    addType(data,'',objectInfo.typeName);\n\n    var keyType = objectInfo.type;\n    while ((defined(keyType)) && ( keyType.key === undefined) && (keyType.baseType !== undefined)) {\n        keyType = lookupEntityType(keyType.baseType, model);\n    }\n\n    if (keyType.key !== undefined) {\n        var lastIdSegment = objectInfo.name + jsonGetEntryKey(data, keyType);\n        data['@odata.id'] = baseURI.substring(0, baseURI.lastIndexOf(\"$metadata\")) + lastIdSegment;\n        data['@odata.editLink'] = lastIdSegment;\n    }\n\n    //var serviceURI = baseURI.substring(0, baseURI.lastIndexOf(\"$metadata\"));\n\n    checkProperties(data, objectInfo.type, baseURI, model, recognizeDates);\n\n    return data;\n}\n\n/** Add metadata to an JSON payload complex object containing minimal metadata\n * @param {Object} data - Data structure to be extended\n * @param {String} property - Information about the data (name,type,typename,...)\n * @param {String} baseURI - Base Url\n * @param {Object} model - Metadata model\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction addMetadataToJsonMinimalPayloadComplex(data, property, baseURI, model, recognizeDates) {\n    var type = property.type;\n    if (isCollectionType(property.type)) {\n        type =property.type.substring(11,property.type.length-1);\n    }\n\n    addType(data,'',property.type);\n\n    var propertyType = lookupComplexType(type, model);\n    if (propertyType === null)  {\n        return; //TODO check what to do if the type is not known e.g. type #GeometryCollection\n    }\n\n    checkProperties(data, propertyType, baseURI, model, recognizeDates);\n}\n\n/** Add metadata to an JSON payload collection object containing minimal metadata\n * @param {Object} data - Data structure to be extended\n * @param {Object} model - Metadata model\n * @param {String} collectionInfo - Information about the data (name,type,typename,...)\n * @param {String} baseURI - Base Url\n * @param {Boolean} recognizeDates - Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.\n */\nfunction addMetadataToJsonMinimalPayloadCollection(data, model, collectionInfo, baseURI, recognizeDates) {\n\n    addTypeColNoEdm(data,'', collectionInfo.typeName);\n\n    if (collectionInfo.type !== null) {\n        var entries = [];\n\n        var items = data.value;\n        var i,len;\n        var entry;\n        for (i = 0, len = items.length; i < len; i++) {\n            var item = items[i];\n            if ( defined(item['@odata.type'])) { // in case of mixed collections\n                var typeName = item['@odata.type'].substring(1);\n                var type = lookupEntityType( typeName, model);\n                var entryInfo = {\n                    contentTypeOdata : collectionInfo.contentTypeOdata,\n                    detectedPayloadKind : collectionInfo.detectedPayloadKind,\n                    name : collectionInfo.name,\n                    type : type,\n                    typeName : typeName\n                };\n\n                entry = addMetadataToJsonMinimalPayloadEntity(item, entryInfo, baseURI, model, recognizeDates);\n            } else {\n                entry = addMetadataToJsonMinimalPayloadEntity(item, collectionInfo, baseURI, model, recognizeDates);\n            }\n\n            entries.push(entry);\n        }\n        data.value = entries;\n    }\n    return data;\n}\n\n/** Add an OData type tag to an JSON payload object\n * @param {Object} data - Data structure to be extended\n * @param {String} name - Name of the property whose type is set\n * @param {String} value - Type name\n */\nfunction addType(data, name, value ) {\n    var fullName = name + '@odata.type';\n\n    if ( data[fullName] === undefined) {\n        data[fullName] = '#' + value;\n    }\n}\n\n/** Add an OData type tag to an JSON payload object collection (without \"Edm.\" namespace)\n * @param {Object} data - Data structure to be extended\n * @param {String} name - Name of the property whose type is set\n * @param {String} typeName - Type name\n */\nfunction addTypeColNoEdm(data, name, typeName ) {\n    var fullName = name + '@odata.type';\n\n    if ( data[fullName] === undefined) {\n        if ( typeName.substring(0,4)==='Edm.') {\n            data[fullName] = '#Collection('+typeName.substring(4)+ ')';\n        } else {\n            data[fullName] = '#Collection('+typeName+ ')';\n        }\n    }\n}\n\n\n/** Add an OData type tag to an JSON payload object (without \"Edm.\" namespace)\n * @param {Object} data - Data structure to be extended\n * @param {String} name - Name of the property whose type is set\n * @param {String} value - Type name\n */\nfunction addTypeNoEdm(data, name, value ) {\n    var fullName = name + '@odata.type';\n\n    if ( data[fullName] === undefined) {\n        if ( value.substring(0,4)==='Edm.') {\n            data[fullName] = '#' + value.substring(4);\n        } else {\n            data[fullName] = '#' + value;\n        }\n    }\n    return data;\n}\n/** Convert the date/time format of an property from the JSON payload object (without \"Edm.\" namespace)\n * @param {Object} data - Data structure to be extended\n * @param propertyName - Name of the property to be changed\n * @param type - Type\n */\nfunction convertDates(data, propertyName,type) {\n    if (type === 'Edm.Date') {\n        data[propertyName] = oDataUtils.parseDate(data[propertyName], true);\n    } else if (type === 'Edm.DateTimeOffset') {\n        data[propertyName] = oDataUtils.parseDateTimeOffset(data[propertyName], true);\n    } else if (type === 'Edm.Duration') {\n        data[propertyName] = oDataUtils.parseDuration(data[propertyName], true);\n    } else if (type === 'Edm.Time') {\n        data[propertyName] = oDataUtils.parseTime(data[propertyName], true);\n    }\n}\n\n/** Convert the date/time format of an property from the JSON payload object\n * @param {Object} data - Data structure to be extended\n * @param propertyName - Name of the property to be changed\n * @param type - Type\n */\nfunction convertDatesNoEdm(data, propertyName,type) {\n    if (type === 'Date') {\n        data[propertyName] = oDataUtils.parseDate(data[propertyName], true);\n    } else if (type === 'DateTimeOffset') {\n        data[propertyName] = oDataUtils.parseDateTimeOffset(data[propertyName], true);\n    } else if (type === 'Duration') {\n        data[propertyName] = oDataUtils.parseDuration(data[propertyName], true);\n    } else if (type === 'Time') {\n        data[propertyName] = oDataUtils.parseTime(data[propertyName], true);\n    }\n}\n\n/** Formats a value according to Uri literal format\n * @param value - Value to be formatted.\n * @param type - Edm type of the value\n * @returns {string} Value after formatting\n */\nfunction formatLiteral(value, type) {\n\n    value = \"\" + formatRawLiteral(value, type);\n    value = encodeURIComponent(value.replace(\"'\", \"''\"));\n    switch ((type)) {\n        case \"Edm.Binary\":\n            return \"X'\" + value + \"'\";\n        case \"Edm.DateTime\":\n            return \"datetime\" + \"'\" + value + \"'\";\n        case \"Edm.DateTimeOffset\":\n            return \"datetimeoffset\" + \"'\" + value + \"'\";\n        case \"Edm.Decimal\":\n            return value + \"M\";\n        case \"Edm.Guid\":\n            return \"guid\" + \"'\" + value + \"'\";\n        case \"Edm.Int64\":\n            return value + \"L\";\n        case \"Edm.Float\":\n            return value + \"f\";\n        case \"Edm.Double\":\n            return value + \"D\";\n        case \"Edm.Geography\":\n            return \"geography\" + \"'\" + value + \"'\";\n        case \"Edm.Geometry\":\n            return \"geometry\" + \"'\" + value + \"'\";\n        case \"Edm.Time\":\n            return \"time\" + \"'\" + value + \"'\";\n        case \"Edm.String\":\n            return \"'\" + value + \"'\";\n        default:\n            return value;\n    }\n}\n\n/** convert raw byteArray to hexString if the property is an binary property\n * @param value - Value to be formatted.\n * @param type - Edm type of the value\n * @returns {string} Value after formatting\n */\nfunction formatRawLiteral(value, type) {\n    switch (type) {\n        case \"Edm.Binary\":\n            return convertByteArrayToHexString(value);\n        default:\n            return value;\n    }\n}\n\n/** Formats the given minutes into (+/-)hh:mm format.\n * @param {Number} minutes - Number of minutes to format.\n * @returns {String} The minutes in (+/-)hh:mm format.\n */\nfunction minutesToOffset(minutes) {\n\n    var sign;\n    if (minutes < 0) {\n        sign = \"-\";\n        minutes = -minutes;\n    } else {\n        sign = \"+\";\n    }\n\n    var hours = Math.floor(minutes / 60);\n    minutes = minutes - (60 * hours);\n\n    return sign + formatNumberWidth(hours, 2) + \":\" + formatNumberWidth(minutes, 2);\n}\n\n/** Parses the JSON Date representation into a Date object.\n * @param {String} value - String value.\n * @returns {Date} A Date object if the value matches one; falsy otherwise.\n */\nfunction parseJsonDateString(value) {\n\n    var arr = value && jsonDateRE.exec(value);\n    if (arr) {\n        // 0 - complete results; 1 - ticks; 2 - sign; 3 - minutes\n        var result = new Date(parseInt10(arr[1]));\n        if (arr[2]) {\n            var mins = parseInt10(arr[3]);\n            if (arr[2] === \"-\") {\n                mins = -mins;\n            }\n\n            // The offset is reversed to get back the UTC date, which is\n            // what the API will eventually have.\n            var current = result.getUTCMinutes();\n            result.setUTCMinutes(current - mins);\n            result.__edmType = \"Edm.DateTimeOffset\";\n            result.__offset = minutesToOffset(mins);\n        }\n        if (!isNaN(result.valueOf())) {\n            return result;\n        }\n    }\n\n    // Allow undefined to be returned.\n}\n\n/** Creates an object containing information for the context\n * @param {String} fragments - Uri fragment\n * @param {Object} model - Object describing an OData conceptual schema\n * @returns {Object} type(optional)  object containing type information for entity- and complex-types ( null if a typeName is a primitive)\n */\nfunction parseContextUriFragment( fragments, model ) {\n    var ret = {};\n\n    if (fragments.indexOf('/') === -1 ) {\n        if (fragments.length === 0) {\n            // Capter 10.1\n            ret.detectedPayloadKind = PAYLOADTYPE_SVCDOC;\n            return ret;\n        } else if (fragments === 'Edm.Null') {\n            // Capter 10.15\n            ret.detectedPayloadKind = PAYLOADTYPE_VALUE;\n            ret.isNullProperty = true;\n            return ret;\n        } else if (fragments === 'Collection($ref)') {\n            // Capter 10.11\n            ret.detectedPayloadKind = PAYLOADTYPE_ENTITY_REF_LINKS;\n            return ret;\n        } else if (fragments === '$ref') {\n            // Capter 10.12\n            ret.detectedPayloadKind = PAYLOADTYPE_ENTITY_REF_LINK;\n            return ret;\n        } else {\n            //TODO check for navigation resource\n        }\n    }\n\n    ret.type = undefined;\n    ret.typeName = undefined;\n\n    var fragmentParts = fragments.split(\"/\");\n    var type;\n\n    for(var i = 0; i < fragmentParts.length; ++i) {\n        var fragment = fragmentParts[i];\n        if (ret.typeName === undefined) {\n            //preparation\n            if ( fragment.indexOf('(') !== -1 ) {\n                //remove the query function, cut fragment to matching '('\n                var index = fragment.length - 2 ;\n                for ( var rCount = 1; rCount > 0 && index > 0; --index) {\n                    if ( fragment.charAt(index)=='(') {\n                        rCount --;\n                    } else if ( fragment.charAt(index)==')') {\n                        rCount ++;\n                    }\n                }\n\n                if (index === 0) {\n                    //TODO throw error\n                }\n\n                //remove the projected entity from the fragment; TODO decide if we want to store the projected entity\n                var inPharenthesis = fragment.substring(index+2,fragment.length - 1);\n                fragment = fragment.substring(0,index+1);\n\n                if (utils.startsWith(fragment, 'Collection')) {\n                    ret.detectedPayloadKind = PAYLOADTYPE_COLLECTION;\n                    // Capter 10.14\n                    ret.typeName = inPharenthesis;\n\n                    type = lookupEntityType(ret.typeName, model);\n                    if ( type !== null) {\n                        ret.type = type;\n                        continue;\n                    }\n                    type = lookupComplexType(ret.typeName, model);\n                    if ( type !== null) {\n                        ret.type = type;\n                        continue;\n                    }\n\n                    ret.type = null;//in case of #Collection(Edm.String) only lastTypeName is filled\n                    continue;\n                } else {\n                    // projection: Capter 10.7, 10.8 and 10.9\n                    ret.projection = inPharenthesis;\n                }\n            }\n\n\n            if (jsonIsPrimitiveType(fragment)) {\n                ret.typeName = fragment;\n                ret.type = null;\n                ret.detectedPayloadKind = PAYLOADTYPE_VALUE;\n                continue;\n            }\n\n            var container = lookupDefaultEntityContainer(model);\n\n            //check for entity\n            var entitySet = lookupEntitySet(container.entitySet, fragment);\n            if ( entitySet !== null) {\n                ret.typeName = entitySet.entityType;\n                ret.type = lookupEntityType( ret.typeName, model);\n                ret.name = fragment;\n                ret.detectedPayloadKind = PAYLOADTYPE_FEED;\n                // Capter 10.2\n                continue;\n            }\n\n            //check for singleton\n            var singleton = lookupSingleton(container.singleton, fragment);\n            if ( singleton !== null) {\n                ret.typeName = singleton.entityType;\n                ret.type = lookupEntityType( ret.typeName, model);\n                ret.name = fragment;\n                ret.detectedPayloadKind =  PAYLOADTYPE_ENTRY;\n                // Capter 10.4\n                continue;\n            }\n\n\n\n            //TODO throw ERROR\n        } else {\n            //check for $entity\n            if (utils.endsWith(fragment, '$entity') && (ret.detectedPayloadKind === PAYLOADTYPE_FEED)) {\n                //TODO ret.name = fragment;\n                ret.detectedPayloadKind = PAYLOADTYPE_ENTRY;\n                // Capter 10.3 and 10.6\n                continue;\n            }\n\n            //check for derived types\n            if (fragment.indexOf('.') !== -1) {\n                // Capter 10.6\n                ret.typeName = fragment;\n                type = lookupEntityType(ret.typeName, model);\n                if ( type !== null) {\n                    ret.type = type;\n                    continue;\n                }\n                type = lookupComplexType(ret.typeName, model);\n                if ( type !== null) {\n                    ret.type = type;\n                    continue;\n                }\n\n                //TODO throw ERROR invalid type\n            }\n\n            //check for property value\n            if ( ret.detectedPayloadKind === PAYLOADTYPE_FEED || ret.detectedPayloadKind === PAYLOADTYPE_ENTRY) {\n                var property = lookupProperty(ret.type.property, fragment);\n                if (property !== null) {\n                    //PAYLOADTYPE_COLLECTION\n                    ret.typeName = property.type;\n\n\n                    if (utils.startsWith(property.type, 'Collection')) {\n                        ret.detectedPayloadKind = PAYLOADTYPE_COLLECTION;\n                        var tmp12 =  property.type.substring(10+1,property.type.length - 1);\n                        ret.typeName = tmp12;\n                        ret.type = lookupComplexType(tmp12, model);\n                        ret.detectedPayloadKind = PAYLOADTYPE_COLLECTION;\n                    } else {\n                        ret.type = lookupComplexType(property.type, model);\n                        ret.detectedPayloadKind = PAYLOADTYPE_PROPERTY;\n                    }\n\n                    ret.name = fragment;\n                    // Capter 10.15\n                }\n                continue;\n            }\n\n            if (fragment === '$delta') {\n                ret.deltaKind = DELTATYPE_FEED;\n                continue;\n            } else if (utils.endsWith(fragment, '/$deletedEntity')) {\n                ret.deltaKind = DELTATYPE_DELETED_ENTRY;\n                continue;\n            } else if (utils.endsWith(fragment, '/$link')) {\n                ret.deltaKind = DELTATYPE_LINK;\n                continue;\n            } else if (utils.endsWith(fragment, '/$deletedLink')) {\n                ret.deltaKind = DELTATYPE_DELETED_LINK;\n                continue;\n            }\n            //TODO throw ERROr\n        }\n    }\n\n    return ret;\n}\n\n\n/** Infers the information describing the JSON payload from its metadata annotation, structure, and data model.\n * @param {Object} data - Json response payload object.\n * @param {Object} model - Object describing an OData conceptual schema.\n * If the arguments passed to the function don't convey enough information about the payload to determine without doubt that the payload is a feed then it\n * will try to use the payload object structure instead.  If the payload looks like a feed (has value property that is an array or non-primitive values) then\n * the function will report its kind as PAYLOADTYPE_FEED unless the inferFeedAsComplexType flag is set to true. This flag comes from the user request\n * and allows the user to control how the library behaves with an ambigous JSON payload.\n * @return Object with kind and type fields. Null if there is no metadata annotation or the payload info cannot be obtained..\n */\nfunction createPayloadInfo(data, model) {\n    var metadataUri = data[contextUrlAnnotation];\n    if (!metadataUri || typeof metadataUri !== \"string\") {\n        return null;\n    }\n\n    var fragmentStart = metadataUri.lastIndexOf(\"#\");\n    if (fragmentStart === -1) {\n        return jsonMakePayloadInfo(PAYLOADTYPE_SVCDOC);\n    }\n\n    var fragment = metadataUri.substring(fragmentStart + 1);\n    return parseContextUriFragment(fragment,model);\n}\n/** Gets the key of an entry.\n * @param {Object} data - JSON entry.\n * @param {Object} data - EDM entity model for key loockup.\n * @returns {string} Entry instance key.\n */\nfunction jsonGetEntryKey(data, entityModel) {\n\n    var entityInstanceKey;\n    var entityKeys = entityModel.key.propertyRef;\n    var type;\n    entityInstanceKey = \"(\";\n    if (entityKeys.length == 1) {\n        type = lookupProperty(entityModel.property, entityKeys[0].name).type;\n        entityInstanceKey += formatLiteral(data[entityKeys[0].name], type);\n    } else {\n        var first = true;\n        for (var i = 0; i < entityKeys.length; i++) {\n            if (!first) {\n                entityInstanceKey += \",\";\n            } else {\n                first = false;\n            }\n            type = lookupProperty(entityModel.property, entityKeys[i].name).type;\n            entityInstanceKey += entityKeys[i].name + \"=\" + formatLiteral(data[entityKeys[i].name], type);\n        }\n    }\n    entityInstanceKey += \")\";\n    return entityInstanceKey;\n}\n/** Determines whether a type name is a primitive type in a JSON payload.\n * @param {String} typeName - Type name to test.\n * @returns {Boolean} True if the type name an EDM primitive type or an OData spatial type; false otherwise.\n */\nfunction jsonIsPrimitiveType(typeName) {\n    return isPrimitiveEdmType(typeName) || isGeographyEdmType(typeName) || isGeometryEdmType(typeName);\n}\n\n\nvar jsonHandler = oDataHandler.handler(jsonParser, jsonSerializer, jsonMediaType, MAX_DATA_SERVICE_VERSION);\njsonHandler.recognizeDates = false;\n\nexports.createPayloadInfo = createPayloadInfo;\nexports.jsonHandler = jsonHandler;\nexports.jsonParser = jsonParser;\nexports.jsonSerializer = jsonSerializer;\nexports.parseJsonDateString = parseJsonDateString;}, \"metadata\" : function(exports, module, require) {\n'use strict';\n\n/** @module odata/metadata */\n\nvar utils    = require('./../utils.js');\nvar oDSxml    = require('./../xml.js');\nvar odataHandler    = require('./handler.js');\n\n\n\n// imports \nvar contains = utils.contains;\nvar normalizeURI = utils.normalizeURI;\nvar xmlAttributes = oDSxml.xmlAttributes;\nvar xmlChildElements = oDSxml.xmlChildElements;\nvar xmlFirstChildElement = oDSxml.xmlFirstChildElement;\nvar xmlInnerText = oDSxml.xmlInnerText;\nvar xmlLocalName = oDSxml.xmlLocalName;\nvar xmlNamespaceURI = oDSxml.xmlNamespaceURI;\nvar xmlNS = oDSxml.xmlNS;\nvar xmlnsNS = oDSxml.xmlnsNS;\nvar xmlParse = oDSxml.xmlParse;\n\nvar ado = oDSxml.http + \"docs.oasis-open.org/odata/\";      // http://docs.oasis-open.org/odata/\nvar adoDs = ado + \"ns\";                             // http://docs.oasis-open.org/odata/ns\nvar edmxNs = adoDs + \"/edmx\";                       // http://docs.oasis-open.org/odata/ns/edmx\nvar edmNs1 = adoDs + \"/edm\";                        // http://docs.oasis-open.org/odata/ns/edm\nvar odataMetaXmlNs = adoDs + \"/metadata\";           // http://docs.oasis-open.org/odata/ns/metadata\nvar MAX_DATA_SERVICE_VERSION = odataHandler.MAX_DATA_SERVICE_VERSION;\n\nvar xmlMediaType = \"application/xml\";\n\n/** Creates an object that describes an element in an schema.\n * @param {Array} attributes - List containing the names of the attributes allowed for this element.\n * @param {Array} elements - List containing the names of the child elements allowed for this element.\n * @param {Boolean} text - Flag indicating if the element's text value is of interest or not.\n * @param {String} ns - Namespace to which the element belongs to.\n * If a child element name ends with * then it is understood by the schema that that child element can appear 0 or more times.\n * @returns {Object} Object with attributes, elements, text, and ns fields.\n */\nfunction schemaElement(attributes, elements, text, ns) {\n\n    return {\n        attributes: attributes,\n        elements: elements,\n        text: text || false,\n        ns: ns\n    };\n}\n\n// It's assumed that all elements may have Documentation children and Annotation elements.\n// See http://docs.oasis-open.org/odata/odata/v4.0/cs01/part3-csdl/odata-v4.0-cs01-part3-csdl.html for a CSDL reference.\nvar schema = {\n    elements: {\n        Action: schemaElement(\n        /*attributes*/[\"Name\", \"IsBound\", \"EntitySetPath\"],\n        /*elements*/[\"ReturnType\", \"Parameter*\", \"Annotation*\"]\n        ),\n        ActionImport: schemaElement(\n        /*attributes*/[\"Name\", \"Action\", \"EntitySet\", \"Annotation*\"]\n        ),\n        Annotation: schemaElement(\n        /*attributes*/[\"Term\", \"Qualifier\", \"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"AnnotationPath\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"UrlRef\"],\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        AnnotationPath: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Annotations: schemaElement(\n        /*attributes*/[\"Target\", \"Qualifier\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        Apply: schemaElement(\n        /*attributes*/[\"Function\"],\n        /*elements*/[\"Binary*\", \"Bool*\", \"Date*\", \"DateTimeOffset*\", \"Decimal*\", \"Duration*\", \"EnumMember*\", \"Float*\", \"Guid*\", \"Int*\", \"String*\", \"TimeOfDay*\", \"And*\", \"Or*\", \"Not*\", \"Eq*\", \"Ne*\", \"Gt*\", \"Ge*\", \"Lt*\", \"Le*\", \"AnnotationPath*\", \"Apply*\", \"Cast*\", \"Collection*\", \"If*\", \"IsOf*\", \"LabeledElement*\", \"LabeledElementReference*\", \"Null*\", \"NavigationPropertyPath*\", \"Path*\", \"PropertyPath*\", \"Record*\", \"UrlRef*\", \"Annotation*\"]\n        ),\n        And: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Or: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Not: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Eq: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Ne: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Gt: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Ge: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Lt: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Le: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Binary: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Bool: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Cast: schemaElement(\n        /*attributes*/[\"Type\"],\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Collection: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary*\", \"Bool*\", \"Date*\", \"DateTimeOffset*\", \"Decimal*\", \"Duration*\", \"EnumMember*\", \"Float*\", \"Guid*\", \"Int*\", \"String*\", \"TimeOfDay*\", \"And*\", \"Or*\", \"Not*\", \"Eq*\", \"Ne*\", \"Gt*\", \"Ge*\", \"Lt*\", \"Le*\", \"AnnotationPath*\", \"Apply*\", \"Cast*\", \"Collection*\", \"If*\", \"IsOf*\", \"LabeledElement*\", \"LabeledElementReference*\", \"Null*\", \"NavigationPropertyPath*\", \"Path*\", \"PropertyPath*\", \"Record*\", \"UrlRef*\"]\n        ),\n        ComplexType: schemaElement(\n        /*attributes*/[\"Name\", \"BaseType\", \"Abstract\", \"OpenType\"],\n        /*elements*/[\"Property*\", \"NavigationProperty*\", \"Annotation*\"]\n        ),\n        Date: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        DateTimeOffset: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Decimal: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Duration: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        EntityContainer: schemaElement(\n        /*attributes*/[\"Name\", \"Extends\"],\n        /*elements*/[\"EntitySet*\", \"Singleton*\", \"ActionImport*\", \"FunctionImport*\", \"Annotation*\"]\n        ),\n        EntitySet: schemaElement(\n        /*attributes*/[\"Name\", \"EntityType\", \"IncludeInServiceDocument\"],\n        /*elements*/[\"NavigationPropertyBinding*\", \"Annotation*\"]\n        ),\n        EntityType: schemaElement(\n        /*attributes*/[\"Name\", \"BaseType\", \"Abstract\", \"OpenType\", \"HasStream\"],\n        /*elements*/[\"Key\", \"Property*\", \"NavigationProperty*\", \"Annotation*\"]\n        ),\n        EnumMember: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        EnumType: schemaElement(\n        /*attributes*/[\"Name\", \"UnderlyingType\", \"IsFlags\"],\n        /*elements*/[\"Member*\"]\n        ),\n        Float: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Function: schemaElement(\n        /*attributes*/[\"Name\", \"IsBound\", \"IsComposable\", \"EntitySetPath\"],\n        /*elements*/[\"ReturnType\", \"Parameter*\", \"Annotation*\"]\n        ),\n        FunctionImport: schemaElement(\n        /*attributes*/[\"Name\", \"Function\", \"EntitySet\", \"IncludeInServiceDocument\", \"Annotation*\"]\n        ),\n        Guid: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        If: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary*\", \"Bool*\", \"Date*\", \"DateTimeOffset*\", \"Decimal*\", \"Duration*\", \"EnumMember*\", \"Float*\", \"Guid*\", \"Int*\", \"String*\", \"TimeOfDay*\", \"And*\", \"Or*\", \"Not*\", \"Eq*\", \"Ne*\", \"Gt*\", \"Ge*\", \"Lt*\", \"Le*\", \"AnnotationPath*\", \"Apply*\", \"Cast*\", \"Collection*\", \"If*\", \"IsOf*\", \"LabeledElement*\", \"LabeledElementReference*\", \"Null*\", \"NavigationPropertyPath*\", \"Path*\", \"PropertyPath*\", \"Record*\", \"UrlRef*\", \"Annotation*\"]\n        ),\n        Int: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        IsOf: schemaElement(\n        /*attributes*/[\"Type\", \"MaxLength\", \"Precision\", \"Scale\", \"SRID\", \"Annotation*\"],\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Key: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"PropertyRef*\"]\n        ),\n        LabeledElement: schemaElement(\n        /*attributes*/[\"Name\"],\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        LabeledElementReference: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Member: schemaElement(\n        /*attributes*/[\"Name\", \"Value\"],\n        /*element*/[\"Annotation*\"]\n        ),\n        NavigationProperty: schemaElement(\n        /*attributes*/[\"Name\", \"Type\", \"Nullable\", \"Partner\", \"ContainsTarget\"],\n        /*elements*/[\"ReferentialConstraint*\", \"OnDelete\", \"Annotation*\"]\n        ),\n        NavigationPropertyBinding: schemaElement(\n        /*attributes*/[\"Path\", \"Target\"]\n        ),\n        NavigationPropertyPath: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Null: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Annotation*\"]\n        ),\n        OnDelete: schemaElement(\n        /*attributes*/[\"Action\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        Path: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Parameter: schemaElement(\n        /*attributes*/[\"Name\", \"Type\", \"Nullable\", \"MaxLength\", \"Precision\", \"Scale\", \"SRID\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        Property: schemaElement(\n        /*attributes*/[\"Name\", \"Type\", \"Nullable\", \"MaxLength\", \"Precision\", \"Scale\", \"Unicode\", \"SRID\", \"DefaultValue\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        PropertyPath: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        PropertyRef: schemaElement(\n        /*attributes*/[\"Name\", \"Alias\"]\n        ),\n        PropertyValue: schemaElement(\n        /*attributes*/[\"Property\", \"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"AnnotationPath\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"UrlRef\"],\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n        Record: schemaElement(\n        /*attributes*/null,\n        /*Elements*/[\"PropertyValue*\", \"Annotation*\"]\n        ),\n        ReferentialConstraint: schemaElement(\n        /*attributes*/[\"Property\", \"ReferencedProperty\", \"Annotation*\"]\n        ),\n        ReturnType: schemaElement(\n        /*attributes*/[\"Type\", \"Nullable\", \"MaxLength\", \"Precision\", \"Scale\", \"SRID\"]\n        ),\n        String: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        Schema: schemaElement(\n        /*attributes*/[\"Namespace\", \"Alias\"],\n        /*elements*/[\"Action*\", \"Annotations*\", \"Annotation*\", \"ComplexType*\", \"EntityContainer\", \"EntityType*\", \"EnumType*\", \"Function*\", \"Term*\", \"TypeDefinition*\", \"Annotation*\"]\n        ),\n        Singleton: schemaElement(\n        /*attributes*/[\"Name\", \"Type\"],\n        /*elements*/[\"NavigationPropertyBinding*\", \"Annotation*\"]\n        ),\n        Term: schemaElement(\n        /*attributes*/[\"Name\", \"Type\", \"BaseTerm\", \"DefaultValue \", \"AppliesTo\", \"Nullable\", \"MaxLength\", \"Precision\", \"Scale\", \"SRID\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        TimeOfDay: schemaElement(\n        /*attributes*/null,\n        /*elements*/null,\n        /*text*/true\n        ),\n        TypeDefinition: schemaElement(\n        /*attributes*/[\"Name\", \"UnderlyingType\", \"MaxLength\", \"Unicode\", \"Precision\", \"Scale\", \"SRID\"],\n        /*elements*/[\"Annotation*\"]\n        ),\n        UrlRef: schemaElement(\n        /*attributes*/null,\n        /*elements*/[\"Binary\", \"Bool\", \"Date\", \"DateTimeOffset\", \"Decimal\", \"Duration\", \"EnumMember\", \"Float\", \"Guid\", \"Int\", \"String\", \"TimeOfDay\", \"And\", \"Or\", \"Not\", \"Eq\", \"Ne\", \"Gt\", \"Ge\", \"Lt\", \"Le\", \"AnnotationPath\", \"Apply\", \"Cast\", \"Collection\", \"If\", \"IsOf\", \"LabeledElement\", \"LabeledElementReference\", \"Null\", \"NavigationPropertyPath\", \"Path\", \"PropertyPath\", \"Record\", \"UrlRef\", \"Annotation*\"]\n        ),\n\n        // See http://msdn.microsoft.com/en-us/library/dd541238(v=prot.10) for an EDMX reference.\n        Edmx: schemaElement(\n        /*attributes*/[\"Version\"],\n        /*elements*/[\"DataServices\", \"Reference*\"],\n        /*text*/false,\n        /*ns*/edmxNs\n        ),\n        DataServices: schemaElement(\n        /*attributes*/[\"m:MaxDataServiceVersion\", \"m:DataServiceVersion\"],\n        /*elements*/[\"Schema*\"],\n        /*text*/false,\n        /*ns*/edmxNs\n        ),\n        Reference: schemaElement(\n        /*attributes*/[\"Uri\"],\n        /*elements*/[\"Include*\", \"IncludeAnnotations*\", \"Annotation*\"],\n        /*text*/false,\n        /*ns*/edmxNs\n        ),\n        Include: schemaElement(\n        /*attributes*/[\"Namespace\", \"Alias\"],\n        /*elements*/null,\n        /*text*/false,\n        /*ns*/edmxNs\n        ),\n        IncludeAnnotations: schemaElement(\n        /*attributes*/[\"TermNamespace\", \"Qualifier\", \"TargetNamespace\"],\n        /*elements*/null,\n        /*text*/false,\n        /*ns*/edmxNs\n        )\n    }\n};\n\n\n/** Converts a Pascal-case identifier into a camel-case identifier.\n * @param {String} text - Text to convert.\n * @returns {String} Converted text.\n * If the text starts with multiple uppercase characters, it is left as-is.\n */\nfunction scriptCase(text) {\n\n    if (!text) {\n        return text;\n    }\n\n    if (text.length > 1) {\n        var firstTwo = text.substr(0, 2);\n        if (firstTwo === firstTwo.toUpperCase()) {\n            return text;\n        }\n\n        return text.charAt(0).toLowerCase() + text.substr(1);\n    }\n\n    return text.charAt(0).toLowerCase();\n}\n\n/** Gets the schema node for the specified element.\n * @param {Object} parentSchema - Schema of the parent XML node of 'element'.\n * @param candidateName - XML element name to consider.\n * @returns {Object} The schema that describes the specified element; null if not found.\n */\nfunction getChildSchema(parentSchema, candidateName) {\n\n    var elements = parentSchema.elements;\n    if (!elements) {\n        return null;\n    }\n\n    var i, len;\n    for (i = 0, len = elements.length; i < len; i++) {\n        var elementName = elements[i];\n        var multipleElements = false;\n        if (elementName.charAt(elementName.length - 1) === \"*\") {\n            multipleElements = true;\n            elementName = elementName.substr(0, elementName.length - 1);\n        }\n\n        if (candidateName === elementName) {\n            var propertyName = scriptCase(elementName);\n            return { isArray: multipleElements, propertyName: propertyName };\n        }\n    }\n\n    return null;\n}\n\n/** Checks whether the specifies namespace URI is one of the known CSDL namespace URIs.\n * @param {String} nsURI - Namespace URI to check.\n * @returns {Boolean} true if nsURI is a known CSDL namespace; false otherwise.\n */\nfunction isEdmNamespace(nsURI) {\n\n    return nsURI === edmNs1;\n}\n\n/** Parses a CSDL document.\n * @param element - DOM element to parse.\n * @returns {Object} An object describing the parsed element.\n */\nfunction parseConceptualModelElement(element) {\n\n    var localName = xmlLocalName(element);\n    var nsURI = xmlNamespaceURI(element);\n    var elementSchema = schema.elements[localName];\n    if (!elementSchema) {\n        return null;\n    }\n\n    if (elementSchema.ns) {\n        if (nsURI !== elementSchema.ns) {\n            return null;\n        }\n    } else if (!isEdmNamespace(nsURI)) {\n        return null;\n    }\n\n    var item = {};\n    var attributes = elementSchema.attributes || [];\n    xmlAttributes(element, function (attribute) {\n\n        var localName = xmlLocalName(attribute);\n        var nsURI = xmlNamespaceURI(attribute);\n        var value = attribute.value;\n\n        // Don't do anything with xmlns attributes.\n        if (nsURI === xmlnsNS) {\n            return;\n        }\n\n        // Currently, only m: for metadata is supported as a prefix in the internal schema table,\n        // un-prefixed element names imply one a CSDL element.\n        var schemaName = null;\n        if (isEdmNamespace(nsURI) || nsURI === null) {\n            schemaName = \"\";\n        } else if (nsURI === odataMetaXmlNs) {\n            schemaName = \"m:\";\n        }\n\n        if (schemaName !== null) {\n            schemaName += localName;\n\n            if (contains(attributes, schemaName)) {\n                item[scriptCase(localName)] = value;\n            }\n        }\n\n    });\n\n    xmlChildElements(element, function (child) {\n        var localName = xmlLocalName(child);\n        var childSchema = getChildSchema(elementSchema, localName);\n        if (childSchema) {\n            if (childSchema.isArray) {\n                var arr = item[childSchema.propertyName];\n                if (!arr) {\n                    arr = [];\n                    item[childSchema.propertyName] = arr;\n                }\n                arr.push(parseConceptualModelElement(child));\n            } else {\n                item[childSchema.propertyName] = parseConceptualModelElement(child);\n            }\n        } \n    });\n\n    if (elementSchema.text) {\n        item.text = xmlInnerText(element);\n    }\n\n    return item;\n}\n\n/** Parses a metadata document.\n * @param handler - This handler.\n * @param {String} text - Metadata text.\n * @returns An object representation of the conceptual model.\n */\nfunction metadataParser(handler, text) {\n\n    var doc = xmlParse(text);\n    var root = xmlFirstChildElement(doc);\n    return parseConceptualModelElement(root) || undefined;\n}\n\n\n\nexports.metadataHandler = odataHandler.handler(metadataParser, null, xmlMediaType, MAX_DATA_SERVICE_VERSION);\n\nexports.schema = schema;\nexports.scriptCase = scriptCase;\nexports.getChildSchema = getChildSchema;\nexports.parseConceptualModelElement = parseConceptualModelElement;\nexports.metadataParser = metadataParser;}, \"net\" : function(exports, module, require) {\n\n/** @module odata/net */\n/*for browser*/\n\n\nvar utils = require('./../utils.js');\n// Imports.\n\nvar defined = utils.defined;\nvar delay = utils.delay;\n\nvar ticks = 0;\n\n/* Checks whether the specified request can be satisfied with a JSONP request.\n * @param request - Request object to check.\n * @returns {Boolean} true if the request can be satisfied; false otherwise.\n\n * Requests that 'degrade' without changing their meaning by going through JSONP\n * are considered usable.\n *\n * We allow data to come in a different format, as the servers SHOULD honor the Accept\n * request but may in practice return content with a different MIME type.\n */\nfunction canUseJSONP(request) {\n\n    return !(request.method && request.method !== \"GET\");\n\n\n}\n\n/** Creates an IFRAME tag for loading the JSONP script\n * @param {String} url - The source URL of the script\n * @returns {HTMLElement} The IFRAME tag\n */\nfunction createIFrame(url) {\n    var iframe = window.document.createElement(\"IFRAME\");\n    iframe.style.display = \"none\";\n\n    var attributeEncodedUrl = url.replace(/&/g, \"&amp;\").replace(/\"/g, \"&quot;\").replace(/</g, \"&lt;\");\n    var html = \"<html><head><script type=\\\"text/javascript\\\" src=\\\"\" + attributeEncodedUrl + \"\\\"><\\/script><\\/head><body><\\/body><\\/html>\";\n\n    var body = window.document.getElementsByTagName(\"BODY\")[0];\n    body.appendChild(iframe);\n\n    writeHtmlToIFrame(iframe, html);\n    return iframe;\n}\n\n/** Creates a XmlHttpRequest object.\n * @returns {XmlHttpRequest} XmlHttpRequest object.\n */\nfunction createXmlHttpRequest() {\n    if (window.XMLHttpRequest) {\n        return new window.XMLHttpRequest();\n    }\n    var exception;\n    if (window.ActiveXObject) {\n        try {\n            return new window.ActiveXObject(\"Msxml2.XMLHTTP.6.0\");\n        } catch (_) {\n            try {\n                return new window.ActiveXObject(\"Msxml2.XMLHTTP.3.0\");\n            } catch (e) {\n                exception = e;\n            }\n        }\n    } else {\n        exception = { message: \"XMLHttpRequest not supported\" };\n    }\n    throw exception;\n}\n\n/** Checks whether the specified URL is an absolute URL.\n * @param {String} url - URL to check.\n * @returns {Boolean} true if the url is an absolute URL; false otherwise.\n*/\nfunction isAbsoluteUrl(url) {\n    return url.indexOf(\"http://\") === 0 ||\n        url.indexOf(\"https://\") === 0 ||\n        url.indexOf(\"file://\") === 0;\n}\n\n/** Checks whether the specified URL is local to the current context.\n * @param {String} url - URL to check.\n * @returns {Boolean} true if the url is a local URL; false otherwise.\n */\nfunction isLocalUrl(url) {\n\n    if (!isAbsoluteUrl(url)) {\n        return true;\n    }\n\n    // URL-embedded username and password will not be recognized as same-origin URLs.\n    var location = window.location;\n    var locationDomain = location.protocol + \"//\" + location.host + \"/\";\n    return (url.indexOf(locationDomain) === 0);\n}\n\n/** Removes a callback used for a JSONP request.\n * @param {String} name - Function name to remove.\n * @param {Number} tick - Tick count used on the callback.\n */\nfunction removeCallback(name, tick) {\n    try {\n        delete window[name];\n    } catch (err) {\n        window[name] = undefined;\n        if (tick === ticks - 1) {\n            ticks -= 1;\n        }\n    }\n}\n\n/** Removes an iframe.\n * @param {Object} iframe - The iframe to remove.\n * @returns {Object} Null value to be assigned to iframe reference.\n */\nfunction removeIFrame(iframe) {\n    if (iframe) {\n        writeHtmlToIFrame(iframe, \"\");\n        iframe.parentNode.removeChild(iframe);\n    }\n\n    return null;\n}\n\n/** Reads response headers into array.\n * @param {XMLHttpRequest} xhr - HTTP request with response available.\n * @param {Array} headers - Target array to fill with name/value pairs.\n */\nfunction readResponseHeaders(xhr, headers) {\n\n    var responseHeaders = xhr.getAllResponseHeaders().split(/\\r?\\n/);\n    var i, len;\n    for (i = 0, len = responseHeaders.length; i < len; i++) {\n        if (responseHeaders[i]) {\n            var header = responseHeaders[i].split(\": \");\n            headers[header[0]] = header[1];\n        }\n    }\n}\n\n/** Writes HTML to an IFRAME document.\n * @param {HTMLElement} iframe - The IFRAME element to write to.\n * @param {String} html - The HTML to write.\n */\nfunction writeHtmlToIFrame(iframe, html) {\n    var frameDocument = (iframe.contentWindow) ? iframe.contentWindow.document : iframe.contentDocument.document;\n    frameDocument.open();\n    frameDocument.write(html);\n    frameDocument.close();\n}\n\nexports.defaultHttpClient = {\n    callbackParameterName: \"$callback\",\n\n    formatQueryString: \"$format=json\",\n\n    enableJsonpCallback: false,\n\n    /** Performs a network request.\n     * @param {Object} request - Request description\n     * @param {Function} success - Success callback with the response object.\n     * @param {Function} error - Error callback with an error object.\n     * @returns {Object} Object with an 'abort' method for the operation.\n     */\n    request: function createRequest() {\n\n        var that = this;\n\n\n        return function (request, success, error) {\n\n            var result = {};\n            var xhr = null;\n            var done = false;\n            var iframe;\n\n            result.abort = function () {\n                iframe = removeIFrame(iframe);\n                if (done) {\n                    return;\n                }\n\n                done = true;\n                if (xhr) {\n                    xhr.abort();\n                    xhr = null;\n                }\n\n                error({ message: \"Request aborted\" });\n            };\n\n            var handleTimeout = function () {\n                iframe = removeIFrame(iframe);\n                if (!done) {\n                    done = true;\n                    xhr = null;\n                    error({ message: \"Request timed out\" });\n                }\n            };\n\n            var name;\n            var url = request.requestUri;\n            var enableJsonpCallback = defined(request.enableJsonpCallback, that.enableJsonpCallback);\n            var callbackParameterName = defined(request.callbackParameterName, that.callbackParameterName);\n            var formatQueryString = defined(request.formatQueryString, that.formatQueryString);\n            if (!enableJsonpCallback || isLocalUrl(url)) {\n\n                xhr = createXmlHttpRequest();\n                xhr.onreadystatechange = function () {\n                    if (done || xhr === null || xhr.readyState !== 4) {\n                        return;\n                    }\n\n                    // Workaround for XHR behavior on IE.\n                    var statusText = xhr.statusText;\n                    var statusCode = xhr.status;\n                    if (statusCode === 1223) {\n                        statusCode = 204;\n                        statusText = \"No Content\";\n                    }\n\n                    var headers = [];\n                    readResponseHeaders(xhr, headers);\n\n                    var response = { requestUri: url, statusCode: statusCode, statusText: statusText, headers: headers, body: xhr.responseText };\n\n                    done = true;\n                    xhr = null;\n                    if (statusCode >= 200 && statusCode <= 299) {\n                        success(response);\n                    } else {\n                        error({ message: \"HTTP request failed\", request: request, response: response });\n                    }\n                };\n\n                xhr.open(request.method || \"GET\", url, true, request.user, request.password);\n\n                // Set the name/value pairs.\n                if (request.headers) {\n                    for (name in request.headers) {\n                        xhr.setRequestHeader(name, request.headers[name]);\n                    }\n                }\n\n                // Set NTLM/Kerberos auth token\n                if (request.withCredentials) {\n                    xhr.withCredentials = true;\n                }\n\n                // Set the timeout if available.\n                if (request.timeoutMS) {\n                    xhr.timeout = request.timeoutMS;\n                    xhr.ontimeout = handleTimeout;\n                }\n\n                xhr.send(request.body);\n            } else {\n                if (!canUseJSONP(request)) {\n                    throw { message: \"Request is not local and cannot be done through JSONP.\" };\n                }\n\n                var tick = ticks;\n                ticks += 1;\n                var tickText = tick.toString();\n                var succeeded = false;\n                var timeoutId;\n                name = \"handleJSONP_\" + tickText;\n                window[name] = function (data) {\n                    iframe = removeIFrame(iframe);\n                    if (!done) {\n                        succeeded = true;\n                        window.clearTimeout(timeoutId);\n                        removeCallback(name, tick);\n\n                        // Workaround for IE8 and IE10 below where trying to access data.constructor after the IFRAME has been removed\n                        // throws an \"unknown exception\"\n                        if (window.ActiveXObject) {\n                            data = window.JSON.parse(window.JSON.stringify(data));\n                        }\n\n\n                        var headers;\n                        if (!formatQueryString || formatQueryString == \"$format=json\") {\n                            headers = { \"Content-Type\": \"application/json;odata.metadata=minimal\", \"OData-Version\": \"4.0\" };\n                        } else {\n                            // the formatQueryString should be in the format of \"$format=xxx\", xxx should be one of the application/json;odata.metadata=minimal(none or full)\n                            // set the content-type with the string xxx which stars from index 8.\n                            headers = { \"Content-Type\": formatQueryString.substring(8), \"OData-Version\": \"4.0\" };\n                        }\n\n                        // Call the success callback in the context of the parent window, instead of the IFRAME\n                        delay(function () {\n                            removeIFrame(iframe);\n                            success({ body: data, statusCode: 200, headers: headers });\n                        });\n                    }\n                };\n\n                // Default to two minutes before timing out, 1000 ms * 60 * 2 = 120000.\n                var timeoutMS = (request.timeoutMS) ? request.timeoutMS : 120000;\n                timeoutId = window.setTimeout(handleTimeout, timeoutMS);\n\n                var queryStringParams = callbackParameterName + \"=parent.\" + name;\n                if (formatQueryString) {\n                    queryStringParams += \"&\" + formatQueryString;\n                }\n\n                var qIndex = url.indexOf(\"?\");\n                if (qIndex === -1) {\n                    url = url + \"?\" + queryStringParams;\n                } else if (qIndex === url.length - 1) {\n                    url = url + queryStringParams;\n                } else {\n                    url = url + \"&\" + queryStringParams;\n                }\n\n                iframe = createIFrame(url);\n            }\n\n            return result;\n        }\n    }()\n};\n\n\n\nexports.canUseJSONP = canUseJSONP;\nexports.isAbsoluteUrl = isAbsoluteUrl;\nexports.isLocalUrl = isLocalUrl;}, \"odatautils\" : function(exports, module, require) {\n'use strict';\n /** @module odata/utils */\n\nvar utils    = require('./../utils.js');\n\n// Imports\nvar assigned = utils.assigned;\nvar contains = utils.contains;\nvar find = utils.find;\nvar isArray = utils.isArray;\nvar isDate = utils.isDate;\nvar isObject = utils.isObject;\nvar parseInt10 = utils.parseInt10;\n\n\n/** Gets the type name of a data item value that belongs to a feed, an entry, a complex type property, or a collection property\n * @param {string} value - Value of the data item from which the type name is going to be retrieved.\n * @param {object} [metadata] - Object containing metadata about the data tiem.\n * @returns {string} Data item type name; null if the type name cannot be found within the value or the metadata\n * This function will first try to get the type name from the data item's value itself if it is an object with a __metadata property; otherwise\n * it will try to recover it from the metadata.  If both attempts fail, it will return null.\n */\nvar dataItemTypeName = function (value, metadata) {\n    var valueTypeName = ((value && value.__metadata) || {}).type;\n    return valueTypeName || (metadata ? metadata.type : null);\n};\n\nvar EDM = \"Edm.\";\nvar EDM_BOOLEAN = EDM + \"Boolean\";\nvar EDM_BYTE = EDM + \"Byte\";\nvar EDM_SBYTE = EDM + \"SByte\";\nvar EDM_INT16 = EDM + \"Int16\";\nvar EDM_INT32 = EDM + \"Int32\";\nvar EDM_INT64 = EDM + \"Int64\";\nvar EDM_SINGLE = EDM + \"Single\";\nvar EDM_DOUBLE = EDM + \"Double\";\nvar EDM_DECIMAL = EDM + \"Decimal\";\nvar EDM_STRING = EDM + \"String\";\n\nvar EDM_BINARY = EDM + \"Binary\";\nvar EDM_DATE = EDM + \"Date\";\nvar EDM_DATETIMEOFFSET = EDM + \"DateTimeOffset\";\nvar EDM_DURATION = EDM + \"Duration\";\nvar EDM_GUID = EDM + \"Guid\";\nvar EDM_TIMEOFDAY = EDM + \"Time\";\n\nvar GEOGRAPHY = \"Geography\";\nvar EDM_GEOGRAPHY = EDM + GEOGRAPHY;\nvar EDM_GEOGRAPHY_POINT = EDM_GEOGRAPHY + \"Point\";\nvar EDM_GEOGRAPHY_LINESTRING = EDM_GEOGRAPHY + \"LineString\";\nvar EDM_GEOGRAPHY_POLYGON = EDM_GEOGRAPHY + \"Polygon\";\nvar EDM_GEOGRAPHY_COLLECTION = EDM_GEOGRAPHY + \"Collection\";\nvar EDM_GEOGRAPHY_MULTIPOLYGON = EDM_GEOGRAPHY + \"MultiPolygon\";\nvar EDM_GEOGRAPHY_MULTILINESTRING = EDM_GEOGRAPHY + \"MultiLineString\";\nvar EDM_GEOGRAPHY_MULTIPOINT = EDM_GEOGRAPHY + \"MultiPoint\";\n\nvar GEOGRAPHY_POINT = GEOGRAPHY + \"Point\";\nvar GEOGRAPHY_LINESTRING = GEOGRAPHY + \"LineString\";\nvar GEOGRAPHY_POLYGON = GEOGRAPHY + \"Polygon\";\nvar GEOGRAPHY_COLLECTION = GEOGRAPHY + \"Collection\";\nvar GEOGRAPHY_MULTIPOLYGON = GEOGRAPHY + \"MultiPolygon\";\nvar GEOGRAPHY_MULTILINESTRING = GEOGRAPHY + \"MultiLineString\";\nvar GEOGRAPHY_MULTIPOINT = GEOGRAPHY + \"MultiPoint\";\n\nvar GEOMETRY = \"Geometry\";\nvar EDM_GEOMETRY = EDM + GEOMETRY;\nvar EDM_GEOMETRY_POINT = EDM_GEOMETRY + \"Point\";\nvar EDM_GEOMETRY_LINESTRING = EDM_GEOMETRY + \"LineString\";\nvar EDM_GEOMETRY_POLYGON = EDM_GEOMETRY + \"Polygon\";\nvar EDM_GEOMETRY_COLLECTION = EDM_GEOMETRY + \"Collection\";\nvar EDM_GEOMETRY_MULTIPOLYGON = EDM_GEOMETRY + \"MultiPolygon\";\nvar EDM_GEOMETRY_MULTILINESTRING = EDM_GEOMETRY + \"MultiLineString\";\nvar EDM_GEOMETRY_MULTIPOINT = EDM_GEOMETRY + \"MultiPoint\";\n\nvar GEOMETRY_POINT = GEOMETRY + \"Point\";\nvar GEOMETRY_LINESTRING = GEOMETRY + \"LineString\";\nvar GEOMETRY_POLYGON = GEOMETRY + \"Polygon\";\nvar GEOMETRY_COLLECTION = GEOMETRY + \"Collection\";\nvar GEOMETRY_MULTIPOLYGON = GEOMETRY + \"MultiPolygon\";\nvar GEOMETRY_MULTILINESTRING = GEOMETRY + \"MultiLineString\";\nvar GEOMETRY_MULTIPOINT = GEOMETRY + \"MultiPoint\";\n\nvar GEOJSON_POINT = \"Point\";\nvar GEOJSON_LINESTRING = \"LineString\";\nvar GEOJSON_POLYGON = \"Polygon\";\nvar GEOJSON_MULTIPOINT = \"MultiPoint\";\nvar GEOJSON_MULTILINESTRING = \"MultiLineString\";\nvar GEOJSON_MULTIPOLYGON = \"MultiPolygon\";\nvar GEOJSON_GEOMETRYCOLLECTION = \"GeometryCollection\";\n\nvar primitiveEdmTypes = [\n    EDM_STRING,\n    EDM_INT32,\n    EDM_INT64,\n    EDM_BOOLEAN,\n    EDM_DOUBLE,\n    EDM_SINGLE,\n    EDM_DATE,\n    EDM_DATETIMEOFFSET,\n    EDM_DURATION,\n    EDM_TIMEOFDAY,\n    EDM_DECIMAL,\n    EDM_GUID,\n    EDM_BYTE,\n    EDM_INT16,\n    EDM_SBYTE,\n    EDM_BINARY\n];\n\nvar geometryEdmTypes = [\n    EDM_GEOMETRY,\n    EDM_GEOMETRY_POINT,\n    EDM_GEOMETRY_LINESTRING,\n    EDM_GEOMETRY_POLYGON,\n    EDM_GEOMETRY_COLLECTION,\n    EDM_GEOMETRY_MULTIPOLYGON,\n    EDM_GEOMETRY_MULTILINESTRING,\n    EDM_GEOMETRY_MULTIPOINT\n];\n\nvar geometryTypes = [\n    GEOMETRY,\n    GEOMETRY_POINT,\n    GEOMETRY_LINESTRING,\n    GEOMETRY_POLYGON,\n    GEOMETRY_COLLECTION,\n    GEOMETRY_MULTIPOLYGON,\n    GEOMETRY_MULTILINESTRING,\n    GEOMETRY_MULTIPOINT\n];\n\nvar geographyEdmTypes = [\n    EDM_GEOGRAPHY,\n    EDM_GEOGRAPHY_POINT,\n    EDM_GEOGRAPHY_LINESTRING,\n    EDM_GEOGRAPHY_POLYGON,\n    EDM_GEOGRAPHY_COLLECTION,\n    EDM_GEOGRAPHY_MULTIPOLYGON,\n    EDM_GEOGRAPHY_MULTILINESTRING,\n    EDM_GEOGRAPHY_MULTIPOINT\n];\n\nvar geographyTypes = [\n    GEOGRAPHY,\n    GEOGRAPHY_POINT,\n    GEOGRAPHY_LINESTRING,\n    GEOGRAPHY_POLYGON,\n    GEOGRAPHY_COLLECTION,\n    GEOGRAPHY_MULTIPOLYGON,\n    GEOGRAPHY_MULTILINESTRING,\n    GEOGRAPHY_MULTIPOINT\n];\n\n/** Invokes a function once per schema in metadata.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @param {Function} callback - Callback function to invoke once per schema.\n * @returns The first truthy value to be returned from the callback; null or the last falsy value otherwise.\n */\nfunction forEachSchema(metadata, callback) {\n    \n\n    if (!metadata) {\n        return null;\n    }\n\n    if (isArray(metadata)) {\n        var i, len, result;\n        for (i = 0, len = metadata.length; i < len; i++) {\n            result = forEachSchema(metadata[i], callback);\n            if (result) {\n                return result;\n            }\n        }\n\n        return null;\n    } else {\n        if (metadata.dataServices) {\n            return forEachSchema(metadata.dataServices.schema, callback);\n        }\n\n        return callback(metadata);\n    }\n}\n\n/** Formats a millisecond and a nanosecond value into a single string.\n * @param {Number} ms - Number of milliseconds to format.\n * @param {Number} ns - Number of nanoseconds to format.\n * @returns {String} Formatted text.\n * If the value is already as string it's returned as-is.\n */\nfunction formatMilliseconds(ms, ns) {\n\n    // Avoid generating milliseconds if not necessary.\n    if (ms === 0) {\n        ms = \"\";\n    } else {\n        ms = \".\" + formatNumberWidth(ms.toString(), 3);\n    }\n    if (ns > 0) {\n        if (ms === \"\") {\n            ms = \".000\";\n        }\n        ms += formatNumberWidth(ns.toString(), 4);\n    }\n    return ms;\n}\n\nfunction formatDateTimeOffsetJSON(value) {\n    return \"\\/Date(\" + value.getTime() + \")\\/\";\n}\n\n/** Formats a DateTime or DateTimeOffset value a string.\n * @param {Date} value - Value to format\n * @returns {String} Formatted text.\n * If the value is already as string it's returned as-is\n´*/\nfunction formatDateTimeOffset(value) {\n\n    if (typeof value === \"string\") {\n        return value;\n    }\n\n    var hasOffset = isDateTimeOffset(value);\n    var offset = getCanonicalTimezone(value.__offset);\n    if (hasOffset && offset !== \"Z\") {\n        // We're about to change the value, so make a copy.\n        value = new Date(value.valueOf());\n\n        var timezone = parseTimezone(offset);\n        var hours = value.getUTCHours() + (timezone.d * timezone.h);\n        var minutes = value.getUTCMinutes() + (timezone.d * timezone.m);\n\n        value.setUTCHours(hours, minutes);\n    } else if (!hasOffset) {\n        // Don't suffix a 'Z' for Edm.DateTime values.\n        offset = \"\";\n    }\n\n    var year = value.getUTCFullYear();\n    var month = value.getUTCMonth() + 1;\n    var sign = \"\";\n    if (year <= 0) {\n        year = -(year - 1);\n        sign = \"-\";\n    }\n\n    var ms = formatMilliseconds(value.getUTCMilliseconds(), value.__ns);\n\n    return sign +\n        formatNumberWidth(year, 4) + \"-\" +\n        formatNumberWidth(month, 2) + \"-\" +\n        formatNumberWidth(value.getUTCDate(), 2) + \"T\" +\n        formatNumberWidth(value.getUTCHours(), 2) + \":\" +\n        formatNumberWidth(value.getUTCMinutes(), 2) + \":\" +\n        formatNumberWidth(value.getUTCSeconds(), 2) +\n        ms + offset;\n}\n\n/** Converts a duration to a string in xsd:duration format.\n * @param {Object} value - Object with ms and __edmType properties.\n * @returns {String} String representation of the time object in xsd:duration format.\n */\nfunction formatDuration(value) {\n\n    var ms = value.ms;\n\n    var sign = \"\";\n    if (ms < 0) {\n        sign = \"-\";\n        ms = -ms;\n    }\n\n    var days = Math.floor(ms / 86400000);\n    ms -= 86400000 * days;\n    var hours = Math.floor(ms / 3600000);\n    ms -= 3600000 * hours;\n    var minutes = Math.floor(ms / 60000);\n    ms -= 60000 * minutes;\n    var seconds = Math.floor(ms / 1000);\n    ms -= seconds * 1000;\n\n    return sign + \"P\" +\n           formatNumberWidth(days, 2) + \"DT\" +\n           formatNumberWidth(hours, 2) + \"H\" +\n           formatNumberWidth(minutes, 2) + \"M\" +\n           formatNumberWidth(seconds, 2) +\n           formatMilliseconds(ms, value.ns) + \"S\";\n}\n\n/** Formats the specified value to the given width.\n * @param {Number} value - Number to format (non-negative).\n * @param {Number} width - Minimum width for number.\n * @param {Boolean} append - Flag indicating if the value is padded at the beginning (false) or at the end (true).\n * @returns {String} Text representation.\n */\nfunction formatNumberWidth(value, width, append) {\n    var result = value.toString(10);\n    while (result.length < width) {\n        if (append) {\n            result += \"0\";\n        } else {\n            result = \"0\" + result;\n        }\n    }\n\n    return result;\n}\n\n/** Gets the canonical timezone representation.\n * @param {String} timezone - Timezone representation.\n * @returns {String} An 'Z' string if the timezone is absent or 0; the timezone otherwise.\n */\nfunction getCanonicalTimezone(timezone) {\n\n    return (!timezone || timezone === \"Z\" || timezone === \"+00:00\" || timezone === \"-00:00\") ? \"Z\" : timezone;\n}\n\n/** Gets the type of a collection type name.\n * @param {String} typeName - Type name of the collection.\n * @returns {String} Type of the collection; null if the type name is not a collection type.\n */\nfunction getCollectionType(typeName) {\n\n    if (typeof typeName === \"string\") {\n        var end = typeName.indexOf(\")\", 10);\n        if (typeName.indexOf(\"Collection(\") === 0 && end > 0) {\n            return typeName.substring(11, end);\n        }\n    }\n    return null;\n}\n\n/** Sends a request containing OData payload to a server.\n* @param request - Object that represents the request to be sent..\n* @param success - Callback for a successful read operation.\n* @param error - Callback for handling errors.\n* @param handler - Handler for data serialization.\n* @param httpClient - HTTP client layer.\n* @param context - Context used for processing the request\n*/\nfunction invokeRequest(request, success, error, handler, httpClient, context) {\n\n    return httpClient.request(request, function (response) {\n        try {\n            if (response.headers) {\n                normalizeHeaders(response.headers);\n            }\n\n            if (response.data === undefined && response.statusCode !== 204) {\n                handler.read(response, context);\n            }\n        } catch (err) {\n            if (err.request === undefined) {\n                err.request = request;\n            }\n            if (err.response === undefined) {\n                err.response = response;\n            }\n            error(err);\n            return;\n        }\n        // errors in success handler for sync requests result in error handler calls. So here we fix this. \n        try {\n            success(response.data, response);\n        } catch (err) {\n            err.bIsSuccessHandlerError = true;\n            throw err;\n        }\n    }, error);\n}\n\n/** Tests whether a value is a batch object in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is a batch object; false otherwise.\n */\nfunction isBatch(value) {\n\n    return isComplex(value) && isArray(value.__batchRequests);\n}\n\n// Regular expression used for testing and parsing for a collection type.\nvar collectionTypeRE = /Collection\\((.*)\\)/;\n\n/** Tests whether a value is a collection value in the library's internal representation.\n * @param value - Value to test.\n * @param {String} typeName - Type name of the value. This is used to disambiguate from a collection property value.\n * @returns {Boolean} True is the value is a feed value; false otherwise.\n */\nfunction isCollection(value, typeName) {\n\n    var colData = value && value.results || value;\n    return !!colData &&\n        (isCollectionType(typeName)) ||\n        (!typeName && isArray(colData) && !isComplex(colData[0]));\n}\n\n/** Checks whether the specified type name is a collection type.\n * @param {String} typeName - Name of type to check.\n * @returns {Boolean} True if the type is the name of a collection type; false otherwise.\n */\nfunction isCollectionType(typeName) {\n    return collectionTypeRE.test(typeName);\n}\n\n/** Tests whether a value is a complex type value in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is a complex type value; false otherwise.\n */\nfunction isComplex(value) {\n\n    return !!value &&\n        isObject(value) &&\n        !isArray(value) &&\n        !isDate(value);\n}\n\n/** Checks whether a Date object is DateTimeOffset value\n * @param {Date} value - Value to check\n * @returns {Boolean} true if the value is a DateTimeOffset, false otherwise.\n */\nfunction isDateTimeOffset(value) {\n    return (value.__edmType === \"Edm.DateTimeOffset\" || (!value.__edmType && value.__offset));\n}\n\n/** Tests whether a value is a deferred navigation property in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is a deferred navigation property; false otherwise.\n */\nfunction isDeferred(value) {\n\n    if (!value && !isComplex(value)) {\n        return false;\n    }\n    var metadata = value.__metadata || {};\n    var deferred = value.__deferred || {};\n    return !metadata.type && !!deferred.uri;\n}\n\n/** Tests whether a value is an entry object in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is an entry object; false otherwise.\n */\nfunction isEntry(value) {\n\n    return isComplex(value) && value.__metadata && \"uri\" in value.__metadata;\n}\n\n/** Tests whether a value is a feed value in the library's internal representation.\n * @param value - Value to test.\n * @param {String} typeName - Type name of the value. This is used to disambiguate from a collection property value.\n * @returns {Boolean} True is the value is a feed value; false otherwise.\n */\nfunction isFeed(value, typeName) {\n\n    var feedData = value && value.results || value;\n    return isArray(feedData) && (\n        (!isCollectionType(typeName)) &&\n        (isComplex(feedData[0]))\n    );\n}\n\n/** Checks whether the specified type name is a geography EDM type.\n * @param {String} typeName - Name of type to check.\n * @returns {Boolean} True if the type is a geography EDM type; false otherwise.\n */\nfunction isGeographyEdmType(typeName) {\n    //check with edm\n    return contains(geographyEdmTypes, typeName) ||\n        (typeName.indexOf('.') === -1 && contains(geographyTypes, typeName));\n        \n}\n\n/** Checks whether the specified type name is a geometry EDM type.\n * @param {String} typeName - Name of type to check.\n * @returns {Boolean} True if the type is a geometry EDM type; false otherwise.\n */\nfunction isGeometryEdmType(typeName) {\n    return contains(geometryEdmTypes, typeName) ||\n        (typeName.indexOf('.') === -1 && contains(geometryTypes, typeName));\n}\n\n\n\n/** Tests whether a value is a named stream value in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is a named stream; false otherwise.\n */\nfunction isNamedStream(value) {\n\n    if (!value && !isComplex(value)) {\n        return false;\n    }\n    var metadata = value.__metadata;\n    var mediaResource = value.__mediaresource;\n    return !metadata && !!mediaResource && !!mediaResource.media_src;\n}\n\n/** Tests whether a value is a primitive type value in the library's internal representation.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is a primitive type value.\n * Date objects are considered primitive types by the library.\n */\nfunction isPrimitive(value) {\n\n    return isDate(value) ||\n        typeof value === \"string\" ||\n        typeof value === \"number\" ||\n        typeof value === \"boolean\";\n}\n\n/** Checks whether the specified type name is a primitive EDM type.\n * @param {String} typeName - Name of type to check.\n * @returns {Boolean} True if the type is a primitive EDM type; false otherwise.\n */\nfunction isPrimitiveEdmType(typeName) {\n\n    return contains(primitiveEdmTypes, typeName);\n}\n\n/** Gets the kind of a navigation property value.\n * @param value - Value of the navigation property.\n * @param {Object} [propertyModel] - Object that describes the navigation property in an OData conceptual schema.\n * @returns {String} String value describing the kind of the navigation property; null if the kind cannot be determined.\n */\nfunction navigationPropertyKind(value, propertyModel) {\n\n    if (isDeferred(value)) {\n        return \"deferred\";\n    }\n    if (isEntry(value)) {\n        return \"entry\";\n    }\n    if (isFeed(value)) {\n        return \"feed\";\n    }\n    if (propertyModel && propertyModel.relationship) {\n        if (value === null || value === undefined || !isFeed(value)) {\n            return \"entry\";\n        }\n        return \"feed\";\n    }\n    return null;\n}\n\n/** Looks up a property by name.\n * @param {Array} properties - Array of property objects as per EDM metadata (may be null)\n * @param {String} name - Name to look for.\n * @returns {Object} The property object; null if not found.\n */\nfunction lookupProperty(properties, name) {\n\n    return find(properties, function (property) {\n        return property.name === name;\n    });\n}\n\n/** Looks up a type object by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @param {String} kind - Kind of object to look for as per EDM metadata.\n * @returns An type description if the name is found; null otherwise\n */\nfunction lookupInMetadata(name, metadata, kind) {\n\n    return (name) ? forEachSchema(metadata, function (schema) {\n        return lookupInSchema(name, schema, kind);\n    }) : null;\n}\n\n/** Looks up a entity set by name.\n * @param {Array} entitySets - Array of entity set objects as per EDM metadata( may be null)\n * @param {String} name - Name to look for.\n * @returns {Object} The entity set object; null if not found.\n */\nfunction lookupEntitySet(entitySets, name) {\n\n    return find(entitySets, function (entitySet) {\n        return entitySet.name === name;\n    });\n}\n\n/** Looks up a entity set by name.\n * @param {Array} singletons - Array of entity set objects as per EDM metadata (may be null)\n * @param {String} name - Name to look for.\n * @returns {Object} The entity set object; null if not found.\n */\nfunction lookupSingleton(singletons, name) {\n\n    return find(singletons, function (singleton) {\n        return singleton.name === name;\n    });\n}\n\n/** Looks up an action by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns An action description if the name is found; null otherwise.\n */\nfunction lookupAction(name, metadata) {\n\n    return lookupInMetadata(name, metadata, \"action\");\n}\n\n/** Looks up a function by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns A function description if the name is found; null otherwise.\n */\nfunction lookupFunction(name, metadata) {\n\n    return lookupInMetadata(name, metadata, \"function\");\n}\n\n/** Looks up a complex type object by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns A complex type description if the name is found; null otherwise.\n */\nfunction lookupComplexType(name, metadata) {\n\n    return lookupInMetadata(name, metadata, \"complexType\");\n}\n\n/** Looks up an entity type object by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns An entity type description if the name is found; null otherwise.\n */\nfunction lookupEntityType(name, metadata) {\n\n    return lookupInMetadata(name, metadata, \"entityType\");\n}\n\n\n/** Looks up an\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns An entity container description if the name is found; null otherwise.\n */\nfunction lookupDefaultEntityContainer(metadata) {\n\n    return forEachSchema(metadata, function (schema) {\n        if (isObject(schema.entityContainer)) { \n            return schema.entityContainer;\n        }\n    });\n}\n\n/** Looks up an entity container object by name.\n * @param {String} name - Name, possibly null or empty.\n * @param metadata - Metadata store; one of edmx, schema, or an array of any of them.\n * @returns An entity container description if the name is found; null otherwise.\n */\nfunction lookupEntityContainer(name, metadata) {\n\n    return lookupInMetadata(name, metadata, \"entityContainer\");\n}\n\n/** Looks up a function import by name.\n * @param {Array} functionImports - Array of function import objects as per EDM metadata (May be null)\n * @param {String} name - Name to look for.\n * @returns {Object} The function import object; null if not found.\n */\nfunction lookupFunctionImport(functionImports, name) {\n    return find(functionImports, function (functionImport) {\n        return functionImport.name === name;\n    });\n}\n\n/** Looks up an action import by name.\n * @param {Array} actionImports - Array of action import objects as per EDM metadata (May be null)\n * @param {String} name - Name to look for.\n * @returns {Object} The action import object; null if not found.\n */\nfunction lookupActionImport(actionImports, name) {\n    return find(actionImports, function (actionImport) {\n        return actionImport.name === name;\n    });\n}\n\n/** Looks up the target entity type for a navigation property.\n * @param {Object} navigationProperty - \n * @param {Object} metadata - \n * @returns {String} The entity type name for the specified property, null if not found.\n */\nfunction lookupNavigationPropertyType(navigationProperty, metadata) {\n\n    var result = null;\n    if (navigationProperty) {\n        var rel = navigationProperty.relationship;\n        var association = forEachSchema(metadata, function (schema) {\n            // The name should be the namespace qualified name in 'ns'.'type' format.\n            var nameOnly = removeNamespace(schema.namespace, rel);\n            var associations = schema.association;\n            if (nameOnly && associations) {\n                var i, len;\n                for (i = 0, len = associations.length; i < len; i++) {\n                    if (associations[i].name === nameOnly) {\n                        return associations[i];\n                    }\n                }\n            }\n            return null;\n        });\n\n        if (association) {\n            var end = association.end[0];\n            if (end.role !== navigationProperty.toRole) {\n                end = association.end[1];\n                // For metadata to be valid, end.role === navigationProperty.toRole now.\n            }\n            result = end.type;\n        }\n    }\n    return result;\n}\n\n/** Looks up the target entityset name for a navigation property.\n * @param {Object} navigationProperty - \n * @param {Object} sourceEntitySetName -\n * @param {Object} metadata -\n * metadata\n * @returns {String} The entityset name for the specified property, null if not found.\n */\nfunction lookupNavigationPropertyEntitySet(navigationProperty, sourceEntitySetName, metadata) {\n\n    if (navigationProperty) {\n        var rel = navigationProperty.relationship;\n        var associationSet = forEachSchema(metadata, function (schema) {\n            var containers = schema.entityContainer;\n            for (var i = 0; i < containers.length; i++) {\n                var associationSets = containers[i].associationSet;\n                if (associationSets) {\n                    for (var j = 0; j < associationSets.length; j++) {\n                        if (associationSets[j].association == rel) {\n                            return associationSets[j];\n                        }\n                    }\n                }\n            }\n            return null;\n        });\n        if (associationSet && associationSet.end[0] && associationSet.end[1]) {\n            return (associationSet.end[0].entitySet == sourceEntitySetName) ? associationSet.end[1].entitySet : associationSet.end[0].entitySet;\n        }\n    }\n    return null;\n}\n\n/** Gets the entitySet info, container name and functionImports for an entitySet\n * @param {Object} entitySetName -\n * @param {Object} metadata - \n * @returns {Object} The info about the entitySet.\n */\nfunction getEntitySetInfo(entitySetName, metadata) {\n\n    var info = forEachSchema(metadata, function (schema) {\n        var container = schema.entityContainer;\n        var entitySets = container.entitySet;\n        if (entitySets) {\n            for (var j = 0; j < entitySets.length; j++) {\n                if (entitySets[j].name == entitySetName) {\n                    return { entitySet: entitySets[j], containerName: container.name, functionImport: container.functionImport };\n                }\n            }\n        }\n        return null;\n    });\n\n    return info;\n}\n\n/** Given an expected namespace prefix, removes it from a full name.\n * @param {String} ns - Expected namespace.\n * @param {String} fullName - Full name in 'ns'.'name' form.\n * @returns {String} The local name, null if it isn't found in the expected namespace.\n */\nfunction removeNamespace(ns, fullName) {\n\n    if (fullName.indexOf(ns) === 0 && fullName.charAt(ns.length) === \".\") {\n        return fullName.substr(ns.length + 1);\n    }\n\n    return null;\n}\n\n/** Looks up a schema object by name.\n * @param {String} name - Name (assigned).\n * @param schema - Schema object as per EDM metadata.\n * @param {String} kind - Kind of object to look for as per EDM metadata.\n * @returns An entity type description if the name is found; null otherwise.\n */\nfunction lookupInSchema(name, schema, kind) {\n\n    if (name && schema) {\n        // The name should be the namespace qualified name in 'ns'.'type' format.\n        var nameOnly = removeNamespace(schema.namespace, name);\n        if (nameOnly) {\n            return find(schema[kind], function (item) {\n                return item.name === nameOnly;\n            });\n        }\n    }\n    return null;\n}\n\n/** Compares to version strings and returns the higher one.\n * @param {String} left - Version string in the form \"major.minor.rev\"\n * @param {String} right - Version string in the form \"major.minor.rev\"\n * @returns {String} The higher version string.\n */\nfunction maxVersion(left, right) {\n\n    if (left === right) {\n        return left;\n    }\n\n    var leftParts = left.split(\".\");\n    var rightParts = right.split(\".\");\n\n    var len = (leftParts.length >= rightParts.length) ?\n        leftParts.length :\n        rightParts.length;\n\n    for (var i = 0; i < len; i++) {\n        var leftVersion = leftParts[i] && parseInt10(leftParts[i]);\n        var rightVersion = rightParts[i] && parseInt10(rightParts[i]);\n        if (leftVersion > rightVersion) {\n            return left;\n        }\n        if (leftVersion < rightVersion) {\n            return right;\n        }\n    }\n}\n\nvar normalHeaders = {\n    // Headers shared by request and response\n    \"content-type\": \"Content-Type\",\n    \"content-encoding\": \"Content-Encoding\",\n    \"content-length\": \"Content-Length\",\n    \"odata-version\": \"OData-Version\",\n    \n    // Headers used by request\n    \"accept\": \"Accept\",\n    \"accept-charset\": \"Accept-Charset\",\n    \"if-match\": \"If-Match\",\n    \"if-none-match\": \"If-None-Match\",\n    \"odata-isolation\": \"OData-Isolation\",\n    \"odata-maxversion\": \"OData-MaxVersion\",\n    \"prefer\": \"Prefer\",\n    \"content-id\": \"Content-ID\",\n    \"content-transfer-encoding\": \"Content-Transfer-Encoding\",\n    \n    // Headers used by response\n    \"etag\": \"ETag\",\n    \"location\": \"Location\",\n    \"odata-entityid\": \"OData-EntityId\",\n    \"preference-applied\": \"Preference-Applied\",\n    \"retry-after\": \"Retry-After\"\n};\n\n/** Normalizes headers so they can be found with consistent casing.\n * @param {Object} headers - Dictionary of name/value pairs.\n */\nfunction normalizeHeaders(headers) {\n\n    for (var name in headers) {\n        var lowerName = name.toLowerCase();\n        var normalName = normalHeaders[lowerName];\n        if (normalName && name !== normalName) {\n            var val = headers[name];\n            delete headers[name];\n            headers[normalName] = val;\n        }\n    }\n}\n\n/** Parses a string into a boolean value.\n * @param propertyValue - Value to parse.\n * @returns {Boolean} true if the property value is 'true'; false otherwise.\n */\nfunction parseBool(propertyValue) {\n\n    if (typeof propertyValue === \"boolean\") {\n        return propertyValue;\n    }\n\n    return typeof propertyValue === \"string\" && propertyValue.toLowerCase() === \"true\";\n}\n\n\n// The captured indices for this expression are:\n// 0     - complete input\n// 1,2,3 - year with optional minus sign, month, day\n// 4,5,6 - hours, minutes, seconds\n// 7     - optional milliseconds\n// 8     - everything else (presumably offset information)\nvar parseDateTimeRE = /^(-?\\d{4,})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2})(?::(\\d{2}))?(?:\\.(\\d+))?(.*)$/;\n\n/** Parses a string into a DateTime value.\n * @param {String} value - Value to parse.\n * @param {Boolean} withOffset - Whether offset is expected.\n * @param {Boolean} nullOnError - return null instead of throwing an exception\n * @returns {Date} The parsed value.\n */\nfunction parseDateTimeMaybeOffset(value, withOffset, nullOnError) {\n\n    // We cannot parse this in cases of failure to match or if offset information is specified.\n    var parts = parseDateTimeRE.exec(value);\n    var offset = (parts) ? getCanonicalTimezone(parts[8]) : null;\n\n    if (!parts || (!withOffset && offset !== \"Z\")) {\n        if (nullOnError) {\n            return null;\n        }\n        throw { message: \"Invalid date/time value\" };\n    }\n\n    // Pre-parse years, account for year '0' being invalid in dateTime.\n    var year = parseInt10(parts[1]);\n    if (year <= 0) {\n        year++;\n    }\n\n    // Pre-parse optional milliseconds, fill in default. Fail if value is too precise.\n    var ms = parts[7];\n    var ns = 0;\n    if (!ms) {\n        ms = 0;\n    } else {\n        if (ms.length > 7) {\n            if (nullOnError) {\n                return null;\n            }\n            throw { message: \"Cannot parse date/time value to given precision.\" };\n        }\n\n        ns = formatNumberWidth(ms.substring(3), 4, true);\n        ms = formatNumberWidth(ms.substring(0, 3), 3, true);\n\n        ms = parseInt10(ms);\n        ns = parseInt10(ns);\n    }\n\n    // Pre-parse other time components and offset them if necessary.\n    var hours = parseInt10(parts[4]);\n    var minutes = parseInt10(parts[5]);\n    var seconds = parseInt10(parts[6]) || 0;\n    if (offset !== \"Z\") {\n        // The offset is reversed to get back the UTC date, which is\n        // what the API will eventually have.\n        var timezone = parseTimezone(offset);\n        var direction = -(timezone.d);\n        hours += timezone.h * direction;\n        minutes += timezone.m * direction;\n    }\n\n    // Set the date and time separately with setFullYear, so years 0-99 aren't biased like in Date.UTC.\n    var result = new Date();\n    result.setUTCFullYear(\n        year,                       // Year.\n        parseInt10(parts[2]) - 1,   // Month (zero-based for Date.UTC and setFullYear).\n        parseInt10(parts[3])        // Date.\n        );\n    result.setUTCHours(hours, minutes, seconds, ms);\n\n    if (isNaN(result.valueOf())) {\n        if (nullOnError) {\n            return null;\n        }\n        throw { message: \"Invalid date/time value\" };\n    }\n\n    if (withOffset) {\n        result.__edmType = \"Edm.DateTimeOffset\";\n        result.__offset = offset;\n    }\n\n    if (ns) {\n        result.__ns = ns;\n    }\n\n    return result;\n}\n\n/** Parses a string into a Date object.\n * @param {String} propertyValue - Value to parse.\n * @param {Boolean} nullOnError - return null instead of throwing an exception\n * @returns {Date} The parsed with year, month, day set, time values are set to 0\n */\nfunction parseDate(propertyValue, nullOnError) {\n    var parts = propertyValue.split('-');\n\n    if (parts.length != 3 && nullOnError) {\n        return null;\n    }\n    return new Date(\n        parseInt10(parts[0]),       // Year.\n        parseInt10(parts[1]) - 1,   // Month (zero-based for Date.UTC and setFullYear).\n        parseInt10(parts[2],\n        0,0,0,0)        // Date.\n        );\n\n}\n\nvar parseTimeOfDayRE = /^(\\d+):(\\d+)(:(\\d+)(.(\\d+))?)?$/;\n\n/**Parses a time into a Date object.\n * @param propertyValue\n * @param {Boolean} nullOnError - return null instead of throwing an exception\n * @returns {{h: Number, m: Number, s: Number, ms: Number}}\n */\nfunction parseTimeOfDay(propertyValue, nullOnError) {\n    var parts = parseTimeOfDayRE.exec(propertyValue);\n\n\n    return {\n        'h' :parseInt10(parts[1]),\n        'm' :parseInt10(parts[2]),\n        's' :parseInt10(parts[4]),\n        'ms' :parseInt10(parts[6])\n     };\n}\n\n/** Parses a string into a DateTimeOffset value.\n * @param {String} propertyValue - Value to parse.\n * @param {Boolean} nullOnError - return null instead of throwing an exception\n * @returns {Date} The parsed value.\n * The resulting object is annotated with an __edmType property and\n * an __offset property reflecting the original intended offset of\n * the value. The time is adjusted for UTC time, as the current\n * timezone-aware Date APIs will only work with the local timezone.\n */\nfunction parseDateTimeOffset(propertyValue, nullOnError) {\n    \n\n    return parseDateTimeMaybeOffset(propertyValue, true, nullOnError);\n}\n\n// The captured indices for this expression are:\n// 0       - complete input\n// 1       - direction\n// 2,3,4   - years, months, days\n// 5,6,7,8 - hours, minutes, seconds, miliseconds\n\nvar parseTimeRE = /^([+-])?P(?:(\\d+)Y)?(?:(\\d+)M)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)(?:\\.(\\d+))?S)?)?/;\n\nfunction isEdmDurationValue(value) {\n    parseTimeRE.test(value);\n}\n\n/** Parses a string in xsd:duration format.\n * @param {String} duration - Duration value.\n\n * This method will throw an exception if the input string has a year or a month component.\n\n * @returns {Object} Object representing the time\n */\nfunction parseDuration(duration) {\n\n    var parts = parseTimeRE.exec(duration);\n\n    if (parts === null) {\n        throw { message: \"Invalid duration value.\" };\n    }\n\n    var years = parts[2] || \"0\";\n    var months = parts[3] || \"0\";\n    var days = parseInt10(parts[4] || 0);\n    var hours = parseInt10(parts[5] || 0);\n    var minutes = parseInt10(parts[6] || 0);\n    var seconds = parseFloat(parts[7] || 0);\n\n    if (years !== \"0\" || months !== \"0\") {\n        throw { message: \"Unsupported duration value.\" };\n    }\n\n    var ms = parts[8];\n    var ns = 0;\n    if (!ms) {\n        ms = 0;\n    } else {\n        if (ms.length > 7) {\n            throw { message: \"Cannot parse duration value to given precision.\" };\n        }\n\n        ns = formatNumberWidth(ms.substring(3), 4, true);\n        ms = formatNumberWidth(ms.substring(0, 3), 3, true);\n\n        ms = parseInt10(ms);\n        ns = parseInt10(ns);\n    }\n\n    ms += seconds * 1000 + minutes * 60000 + hours * 3600000 + days * 86400000;\n\n    if (parts[1] === \"-\") {\n        ms = -ms;\n    }\n\n    var result = { ms: ms, __edmType: \"Edm.Time\" };\n\n    if (ns) {\n        result.ns = ns;\n    }\n    return result;\n}\n\n/** Parses a timezone description in (+|-)nn:nn format.\n * @param {String} timezone - Timezone offset.\n * @returns {Object} An object with a (d)irection property of 1 for + and -1 for -, offset (h)ours and offset (m)inutes.\n */\nfunction parseTimezone(timezone) {\n\n    var direction = timezone.substring(0, 1);\n    direction = (direction === \"+\") ? 1 : -1;\n\n    var offsetHours = parseInt10(timezone.substring(1));\n    var offsetMinutes = parseInt10(timezone.substring(timezone.indexOf(\":\") + 1));\n    return { d: direction, h: offsetHours, m: offsetMinutes };\n}\n\n/** Prepares a request object so that it can be sent through the network.\n* @param request - Object that represents the request to be sent.\n* @param handler - Handler for data serialization\n* @param context - Context used for preparing the request\n*/\nfunction prepareRequest(request, handler, context) {\n\n    // Default to GET if no method has been specified.\n    if (!request.method) {\n        request.method = \"GET\";\n    }\n\n    if (!request.headers) {\n        request.headers = {};\n    } else {\n        normalizeHeaders(request.headers);\n    }\n\n    if (request.headers.Accept === undefined) {\n        request.headers.Accept = handler.accept;\n    }\n\n    if (assigned(request.data) && request.body === undefined) {\n        handler.write(request, context);\n    }\n\n    if (!assigned(request.headers[\"OData-MaxVersion\"])) {\n        request.headers[\"OData-MaxVersion\"] = handler.maxDataServiceVersion || \"4.0\";\n    }\n\n    if (request.async === undefined) {\n        request.async = true;\n    }\n\n}\n\n/** Traverses a tree of objects invoking callback for every value.\n * @param {Object} item - Object or array to traverse.\n * @param {Object} owner - Pass through each callback\n * @param {Function} callback - Callback function with key and value, similar to JSON.parse reviver.\n * @returns {Object} The object with traversed properties.\n Unlike the JSON reviver, this won't delete null members.\n*/\nfunction traverseInternal(item, owner, callback) {\n\n    if (item && typeof item === \"object\") {\n        for (var name in item) {\n            var value = item[name];\n            var result = traverseInternal(value, name, callback);\n            result = callback(name, result, owner);\n            if (result !== value) {\n                if (value === undefined) {\n                    delete item[name];\n                } else {\n                    item[name] = result;\n                }\n            }\n        }\n    }\n\n    return item;\n}\n\n/** Traverses a tree of objects invoking callback for every value.\n * @param {Object} item - Object or array to traverse.\n * @param {Function} callback - Callback function with key and value, similar to JSON.parse reviver.\n * @returns {Object} The traversed object.\n * Unlike the JSON reviver, this won't delete null members.\n*/\nfunction traverse(item, callback) {\n\n    return callback(\"\", traverseInternal(item, \"\", callback));\n}\n\nexports.dataItemTypeName = dataItemTypeName;\nexports.EDM_BINARY = EDM_BINARY;\nexports.EDM_BOOLEAN = EDM_BOOLEAN;\nexports.EDM_BYTE = EDM_BYTE;\nexports.EDM_DATE = EDM_DATE;\nexports.EDM_DATETIMEOFFSET = EDM_DATETIMEOFFSET;\nexports.EDM_DURATION = EDM_DURATION;\nexports.EDM_DECIMAL = EDM_DECIMAL;\nexports.EDM_DOUBLE = EDM_DOUBLE;\nexports.EDM_GEOGRAPHY = EDM_GEOGRAPHY;\nexports.EDM_GEOGRAPHY_POINT = EDM_GEOGRAPHY_POINT;\nexports.EDM_GEOGRAPHY_LINESTRING = EDM_GEOGRAPHY_LINESTRING;\nexports.EDM_GEOGRAPHY_POLYGON = EDM_GEOGRAPHY_POLYGON;\nexports.EDM_GEOGRAPHY_COLLECTION = EDM_GEOGRAPHY_COLLECTION;\nexports.EDM_GEOGRAPHY_MULTIPOLYGON = EDM_GEOGRAPHY_MULTIPOLYGON;\nexports.EDM_GEOGRAPHY_MULTILINESTRING = EDM_GEOGRAPHY_MULTILINESTRING;\nexports.EDM_GEOGRAPHY_MULTIPOINT = EDM_GEOGRAPHY_MULTIPOINT;\nexports.EDM_GEOMETRY = EDM_GEOMETRY;\nexports.EDM_GEOMETRY_POINT = EDM_GEOMETRY_POINT;\nexports.EDM_GEOMETRY_LINESTRING = EDM_GEOMETRY_LINESTRING;\nexports.EDM_GEOMETRY_POLYGON = EDM_GEOMETRY_POLYGON;\nexports.EDM_GEOMETRY_COLLECTION = EDM_GEOMETRY_COLLECTION;\nexports.EDM_GEOMETRY_MULTIPOLYGON = EDM_GEOMETRY_MULTIPOLYGON;\nexports.EDM_GEOMETRY_MULTILINESTRING = EDM_GEOMETRY_MULTILINESTRING;\nexports.EDM_GEOMETRY_MULTIPOINT = EDM_GEOMETRY_MULTIPOINT;\nexports.EDM_GUID = EDM_GUID;\nexports.EDM_INT16 = EDM_INT16;\nexports.EDM_INT32 = EDM_INT32;\nexports.EDM_INT64 = EDM_INT64;\nexports.EDM_SBYTE = EDM_SBYTE;\nexports.EDM_SINGLE = EDM_SINGLE;\nexports.EDM_STRING = EDM_STRING;\nexports.EDM_TIMEOFDAY = EDM_TIMEOFDAY;\nexports.GEOJSON_POINT = GEOJSON_POINT;\nexports.GEOJSON_LINESTRING = GEOJSON_LINESTRING;\nexports.GEOJSON_POLYGON = GEOJSON_POLYGON;\nexports.GEOJSON_MULTIPOINT = GEOJSON_MULTIPOINT;\nexports.GEOJSON_MULTILINESTRING = GEOJSON_MULTILINESTRING;\nexports.GEOJSON_MULTIPOLYGON = GEOJSON_MULTIPOLYGON;\nexports.GEOJSON_GEOMETRYCOLLECTION = GEOJSON_GEOMETRYCOLLECTION;\nexports.forEachSchema = forEachSchema;\nexports.formatDateTimeOffset = formatDateTimeOffset;\nexports.formatDateTimeOffsetJSON = formatDateTimeOffsetJSON;\nexports.formatDuration = formatDuration;\nexports.formatNumberWidth = formatNumberWidth;\nexports.getCanonicalTimezone = getCanonicalTimezone;\nexports.getCollectionType = getCollectionType;\nexports.invokeRequest = invokeRequest;\nexports.isBatch = isBatch;\nexports.isCollection = isCollection;\nexports.isCollectionType = isCollectionType;\nexports.isComplex = isComplex;\nexports.isDateTimeOffset = isDateTimeOffset;\nexports.isDeferred = isDeferred;\nexports.isEntry = isEntry;\nexports.isFeed = isFeed;\nexports.isGeographyEdmType = isGeographyEdmType;\nexports.isGeometryEdmType = isGeometryEdmType;\nexports.isNamedStream = isNamedStream;\nexports.isPrimitive = isPrimitive;\nexports.isPrimitiveEdmType = isPrimitiveEdmType;\nexports.lookupComplexType = lookupComplexType;\nexports.lookupDefaultEntityContainer = lookupDefaultEntityContainer;\nexports.lookupEntityContainer = lookupEntityContainer;\nexports.lookupEntitySet = lookupEntitySet;\nexports.lookupSingleton = lookupSingleton;\nexports.lookupEntityType = lookupEntityType;\nexports.lookupFunctionImport = lookupFunctionImport;\nexports.lookupNavigationPropertyType = lookupNavigationPropertyType;\nexports.lookupNavigationPropertyEntitySet = lookupNavigationPropertyEntitySet;\nexports.lookupInSchema = lookupInSchema;\nexports.lookupProperty = lookupProperty;\nexports.lookupInMetadata = lookupInMetadata;\nexports.getEntitySetInfo = getEntitySetInfo;\nexports.maxVersion = maxVersion;\nexports.navigationPropertyKind = navigationPropertyKind;\nexports.normalizeHeaders = normalizeHeaders;\nexports.parseBool = parseBool;\n\n\nexports.parseDate = parseDate;\nexports.parseDateTimeOffset = parseDateTimeOffset;\nexports.parseDuration = parseDuration;\nexports.parseTimeOfDay = parseTimeOfDay;\n\nexports.parseInt10 = parseInt10;\nexports.prepareRequest = prepareRequest;\nexports.removeNamespace = removeNamespace;\nexports.traverse = traverse;\n\n\n}, \"store\" : function(exports, module, require) {\n//'use strict';\n\n /** @module store */\n\n\n\n\n\nexports.defaultStoreMechanism = \"best\";\n\n/** Creates a new store object.\n * @param {String} name - Store name.\n * @param {String} [mechanism] - \n * @returns {Object} Store object.\n*/\nexports.createStore = function (name, mechanism) {\n\n\n    if (!mechanism) {\n        mechanism = exports.defaultStoreMechanism;\n    }\n\n    if (mechanism === \"best\") {\n        mechanism = (DomStore.isSupported()) ? \"dom\" : \"memory\";\n    }\n\n    var factory = mechanisms[mechanism];\n    if (factory) {\n        return factory.create(name);\n    }\n\n    throw { message: \"Failed to create store\", name: name, mechanism: mechanism };\n};\n\nexports.DomStore       = DomStore       = require('./store/dom.js');\nexports.IndexedDBStore = IndexedDBStore = require('./store/indexeddb.js');\nexports.MemoryStore    = MemoryStore    = require('./store/memory.js');\n\nvar mechanisms = {\n    indexeddb: IndexedDBStore,\n    dom: DomStore,\n    memory: MemoryStore\n};\n\nexports.mechanisms = mechanisms;\n\n\n\n\n}, \"dom\" : function(exports, module, require) {\n'use strict';\n\n/** @module store/dom */\n\n\n\nvar utils = require('./../utils.js');\n\n// Imports.\nvar throwErrorCallback = utils.throwErrorCallback;\nvar delay = utils.delay;\n\nvar localStorage = null;\n\n/** This method is used to override the Date.toJSON method and is called only by\n * JSON.stringify.  It should never be called directly.\n * @summary Converts a Date object into an object representation friendly to JSON serialization.\n * @returns {Object} Object that represents the Date.\n */\nfunction domStoreDateToJSON() {\n    var newValue = { v: this.valueOf(), t: \"[object Date]\" };\n    // Date objects might have extra properties on them so we save them.\n    for (var name in this) {\n        newValue[name] = this[name];\n    }\n    return newValue;\n}\n\n/** This method is used during JSON parsing and invoked only by the reviver function.\n * It should never be called directly.\n * @summary JSON reviver function for converting an object representing a Date in a JSON stream to a Date object\n * @param value _\n * @param value - Object to convert.\n * @returns {Date} Date object.\n */\nfunction domStoreJSONToDate(_, value) {\n    if (value && value.t === \"[object Date]\") {\n        var newValue = new Date(value.v);\n        for (var name in value) {\n            if (name !== \"t\" && name !== \"v\") {\n                newValue[name] = value[name];\n            }\n        }\n        value = newValue;\n    }\n    return value;\n}\n\n/** Qualifies the key with the name of the store.\n * @param {Object} store - Store object whose name will be used for qualifying the key.\n * @param {String} key - Key string.\n * @returns {String} Fully qualified key string.\n */\nfunction qualifyDomStoreKey(store, key) {\n    return store.name + \"#!#\" + key;\n}\n\n/** Gets the key part of a fully qualified key string.\n * @param {Object} store - Store object whose name will be used for qualifying the key.\n * @param {String} key - Fully qualified key string.\n * @returns {String} Key part string\n */\nfunction unqualifyDomStoreKey(store, key) {\n    return key.replace(store.name + \"#!#\", \"\");\n}\n\n/** Constructor for store objects that use DOM storage as the underlying mechanism.\n * @class DomStore\n * @constructor\n * @param {String} name - Store name.\n */\nfunction DomStore(name) {\n    this.name = name;\n}\n\n/** Creates a store object that uses DOM Storage as its underlying mechanism.\n * @method module:store/dom~DomStore.create\n * @param {String} name - Store name.\n * @returns {Object} Store object.\n */\nDomStore.create = function (name) {\n\n    if (DomStore.isSupported()) {\n        localStorage = localStorage || window.localStorage;\n        return new DomStore(name);\n    }\n\n    throw { message: \"Web Storage not supported by the browser\" };\n};\n\n/** Checks whether the underlying mechanism for this kind of store objects is supported by the browser.\n * @method DomStore.isSupported\n * @returns {Boolean} - True if the mechanism is supported by the browser; otherwise false.\n*/\nDomStore.isSupported = function () {\n    return !!window.localStorage;\n};\n\n/** Adds a new value identified by a key to the store.\n * @method module:store/dom~DomStore#add\n * @param {String} key - Key string.\n * @param value - Value that is going to be added to the store.\n * @param {Function} success - Callback for a successful add operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n * This method errors out if the store already contains the specified key.\n */\nDomStore.prototype.add = function (key, value, success, error) {\n    error = error || this.defaultError;\n    var store = this;\n    this.contains(key, function (contained) {\n        if (!contained) {\n            store.addOrUpdate(key, value, success, error);\n        } else {\n            delay(error, { message: \"key already exists\", key: key });\n        }\n    }, error);\n};\n\n/** This method will overwrite the key's current value if it already exists in the store; otherwise it simply adds the new key and value.\n * @summary Adds or updates a value identified by a key to the store.\n * @method module:store/dom~DomStore#addOrUpdate\n * @param {String} key - Key string.\n * @param value - Value that is going to be added or updated to the store.\n * @param {Function} success - Callback for a successful add or update operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n */\nDomStore.prototype.addOrUpdate = function (key, value, success, error) {\n    error = error || this.defaultError;\n\n    if (key instanceof Array) {\n        error({ message: \"Array of keys not supported\" });\n    } else {\n        var fullKey = qualifyDomStoreKey(this, key);\n        var oldDateToJSON = Date.prototype.toJSON;\n        try {\n            var storedValue = value;\n            if (storedValue !== undefined) {\n                // Dehydrate using json\n                Date.prototype.toJSON = domStoreDateToJSON;\n                storedValue = window.JSON.stringify(value);\n            }\n            // Save the json string.\n            localStorage.setItem(fullKey, storedValue);\n            delay(success, key, value);\n        }\n        catch (e) {\n            if (e.code === 22 || e.number === 0x8007000E) {\n                delay(error, { name: \"QUOTA_EXCEEDED_ERR\", error: e });\n            } else {\n                delay(error, e);\n            }\n        }\n        finally {\n            Date.prototype.toJSON = oldDateToJSON;\n        }\n    }\n};\n\n/** In case of an error, this method will not restore any keys that might have been deleted at that point.\n * @summary Removes all the data associated with this store object.\n * @method module:store/dom~DomStore#clear\n * @param {Function} success - Callback for a successful clear operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n */\nDomStore.prototype.clear = function (success, error) {\n\n    error = error || this.defaultError;\n    try {\n        var i = 0, len = localStorage.length;\n        while (len > 0 && i < len) {\n            var fullKey = localStorage.key(i);\n            var key = unqualifyDomStoreKey(this, fullKey);\n            if (fullKey !== key) {\n                localStorage.removeItem(fullKey);\n                len = localStorage.length;\n            } else {\n                i++;\n            }\n        }\n        delay(success);\n    }\n    catch (e) {\n        delay(error, e);\n    }\n};\n\n/** This function does nothing in DomStore as it does not have a connection model\n * @method module:store/dom~DomStore#close\n */\nDomStore.prototype.close = function () {\n};\n\n/** Checks whether a key exists in the store.\n * @method module:store/dom~DomStore#contains\n * @param {String} key - Key string.\n * @param {Function} success - Callback indicating whether the store contains the key or not.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n*/\nDomStore.prototype.contains = function (key, success, error) {\n    error = error || this.defaultError;\n    try {\n        var fullKey = qualifyDomStoreKey(this, key);\n        var value = localStorage.getItem(fullKey);\n        delay(success, value !== null);\n    } catch (e) {\n        delay(error, e);\n    }\n};\n\nDomStore.prototype.defaultError = throwErrorCallback;\n\n/** Gets all the keys that exist in the store.\n * @method module:store/dom~DomStore#getAllKeys\n * @param {Function} success - Callback for a successful get operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n */\nDomStore.prototype.getAllKeys = function (success, error) {\n\n    error = error || this.defaultError;\n\n    var results = [];\n    var i, len;\n\n    try {\n        for (i = 0, len = localStorage.length; i < len; i++) {\n            var fullKey = localStorage.key(i);\n            var key = unqualifyDomStoreKey(this, fullKey);\n            if (fullKey !== key) {\n                results.push(key);\n            }\n        }\n        delay(success, results);\n    }\n    catch (e) {\n        delay(error, e);\n    }\n};\n\n/** Identifies the underlying mechanism used by the store.*/\nDomStore.prototype.mechanism = \"dom\";\n\n/** Reads the value associated to a key in the store.\n * @method module:store/dom~DomStore#read\n * @param {String} key - Key string.\n * @param {Function} success - Callback for a successful reads operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n */\nDomStore.prototype.read = function (key, success, error) {\n\n    error = error || this.defaultError;\n\n    if (key instanceof Array) {\n        error({ message: \"Array of keys not supported\" });\n    } else {\n        try {\n            var fullKey = qualifyDomStoreKey(this, key);\n            var value = localStorage.getItem(fullKey);\n            if (value !== null && value !== \"undefined\") {\n                // Hydrate using json\n                value = window.JSON.parse(value, domStoreJSONToDate);\n            }\n            else {\n                value = undefined;\n            }\n            delay(success, key, value);\n        } catch (e) {\n            delay(error, e);\n        }\n    }\n};\n\n/** Removes a key and its value from the store.\n * @method module:store/dom~DomStore#remove\n * @param {String} key - Key string.\n * @param {Function} success - Callback for a successful remove operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n */\nDomStore.prototype.remove = function (key, success, error) {\n    error = error || this.defaultError;\n\n    if (key instanceof Array) {\n        error({ message: \"Batches not supported\" });\n    } else {\n        try {\n            var fullKey = qualifyDomStoreKey(this, key);\n            localStorage.removeItem(fullKey);\n            delay(success);\n        } catch (e) {\n            delay(error, e);\n        }\n    }\n};\n\n/** Updates the value associated to a key in the store.\n * @method module:store/dom~DomStore#update\n * @param {String} key - Key string.\n * @param value - New value.\n * @param {Function} success - Callback for a successful update operation.\n * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked\n * This method errors out if the specified key is not found in the store.\n */\nDomStore.prototype.update = function (key, value, success, error) {\n    error = error || this.defaultError;\n    var store = this;\n    this.contains(key, function (contained) {\n        if (contained) {\n            store.addOrUpdate(key, value, success, error);\n        } else {\n            delay(error, { message: \"key not found\", key: key });\n        }\n    }, error);\n};\n\nmodule.exports = DomStore;}, \"indexeddb\" : function(exports, module, require) {\n'use strict';\n\n/** @module store/indexeddb */\nvar utils = require('./../utils.js');\n\n// Imports.\nvar throwErrorCallback = utils.throwErrorCallback;\nvar delay = utils.delay;\n\n\nvar indexedDB = utils.inBrowser() ? window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB || window.indexedDB : undefined;\nvar IDBKeyRange = utils.inBrowser() ? window.IDBKeyRange || window.webkitIDBKeyRange : undefined;\nvar IDBTransaction = utils.inBrowser() ? window.IDBTransaction || window.webkitIDBTransaction || {} : {} ;\n\nvar IDBT_READ_ONLY = IDBTransaction.READ_ONLY || \"readonly\";\nvar IDBT_READ_WRITE = IDBTransaction.READ_WRITE || \"readwrite\";\n\n/** Returns either a specific error handler or the default error handler\n * @param {Function} error - The specific error handler\n * @param {Function} defaultError - The default error handler\n * @returns {Function} The error callback\n */\nfunction getError(error, defaultError) {\n\n    return function (e) {\n        var errorFunc = error || defaultError;\n        if (!errorFunc) {\n            return;\n        }\n\n        // Old api quota exceeded error support.\n        if (Object.prototype.toString.call(e) === \"[object IDBDatabaseException]\") {\n            if (e.code === 11 /* IndexedDb disk quota exceeded */) {\n                errorFunc({ name: \"QuotaExceededError\", error: e });\n                return;\n            }\n            errorFunc(e);\n            return;\n        }\n\n        var errName;\n        try {\n            var errObj = e.target.error || e;\n            errName = errObj.name;\n        } catch (ex) {\n            errName = (e.type === \"blocked\") ? \"IndexedDBBlocked\" : \"UnknownError\";\n        }\n        errorFunc({ name: errName, error: e });\n    };\n}\n\n/** Opens the store object's indexed db database.\n * @param {IndexedDBStore} store - The store object\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nfunction openStoreDb(store, success, error) {\n\n    var storeName = store.name;\n    var dbName = \"_odatajs_\" + storeName;\n\n    var request = indexedDB.open(dbName);\n    request.onblocked = error;\n    request.onerror = error;\n\n    request.onupgradeneeded = function () {\n        var db = request.result;\n        if (!db.objectStoreNames.contains(storeName)) {\n            db.createObjectStore(storeName);\n        }\n    };\n\n    request.onsuccess = function (event) {\n        var db = request.result;\n        if (!db.objectStoreNames.contains(storeName)) {\n            // Should we use the old style api to define the database schema?\n            if (\"setVersion\" in db) {\n                var versionRequest = db.setVersion(\"1.0\");\n                versionRequest.onsuccess = function () {\n                    var transaction = versionRequest.transaction;\n                    transaction.oncomplete = function () {\n                        success(db);\n                    };\n                    db.createObjectStore(storeName, null, false);\n                };\n                versionRequest.onerror = error;\n                versionRequest.onblocked = error;\n                return;\n            }\n\n            // The database doesn't have the expected store.\n            // Fabricate an error object for the event for the schema mismatch\n            // and error out.\n            event.target.error = { name: \"DBSchemaMismatch\" };\n            error(event);\n            return;\n        }\n\n        db.onversionchange = function(event) {\n            event.target.close();\n        };\n        success(db);\n    };\n}\n\n/** Opens a new transaction to the store\n * @param {IndexedDBStore} store - The store object\n * @param {Integer} mode - The read/write mode of the transaction (constants from IDBTransaction)\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nfunction openTransaction(store, mode, success, error) {\n\n    var storeName = store.name;\n    var storeDb = store.db;\n    var errorCallback = getError(error, store.defaultError);\n\n    if (storeDb) {\n        success(storeDb.transaction(storeName, mode));\n        return;\n    }\n\n    openStoreDb(store, function (db) {\n        store.db = db;\n        success(db.transaction(storeName, mode));\n    }, errorCallback);\n}\n\n/** Creates a new IndexedDBStore.\n * @class IndexedDBStore\n * @constructor\n * @param {String} name - The name of the store.\n * @returns {Object} The new IndexedDBStore.\n */\nfunction IndexedDBStore(name) {\n    this.name = name;\n}\n\n/** Creates a new IndexedDBStore.\n * @method module:store/indexeddb~IndexedDBStore.create\n * @param {String} name - The name of the store.\n * @returns {Object} The new IndexedDBStore.\n */\nIndexedDBStore.create = function (name) {\n    if (IndexedDBStore.isSupported()) {\n        return new IndexedDBStore(name);\n    }\n\n    throw { message: \"IndexedDB is not supported on this browser\" };\n};\n\n/** Returns whether IndexedDB is supported.\n * @method module:store/indexeddb~IndexedDBStore.isSupported\n * @returns {Boolean} True if IndexedDB is supported, false otherwise.\n */\nIndexedDBStore.isSupported = function () {\n    return !!indexedDB;\n};\n\n/** Adds a key/value pair to the store\n * @method module:store/indexeddb~IndexedDBStore#add\n * @param {String} key - The key\n * @param {Object} value - The value\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n*/\nIndexedDBStore.prototype.add = function (key, value, success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    var keys = [];\n    var values = [];\n\n    if (key instanceof Array) {\n        keys = key;\n        values = value;\n    } else {\n        keys = [key];\n        values = [value];\n    }\n\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        transaction.onabort = getError(error, defaultError, key, \"add\");\n        transaction.oncomplete = function () {\n            if (key instanceof Array) {\n                success(keys, values);\n            } else {\n                success(key, value);\n            }\n        };\n\n        for (var i = 0; i < keys.length && i < values.length; i++) {\n            transaction.objectStore(name).add({ v: values[i] }, keys[i]);\n        }\n    }, error);\n};\n\n/** Adds or updates a key/value pair in the store\n * @method module:store/indexeddb~IndexedDBStore#addOrUpdate\n * @param {String} key - The key\n * @param {Object} value - The value\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.addOrUpdate = function (key, value, success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    var keys = [];\n    var values = [];\n\n    if (key instanceof Array) {\n        keys = key;\n        values = value;\n    } else {\n        keys = [key];\n        values = [value];\n    }\n\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        transaction.onabort = getError(error, defaultError);\n        transaction.oncomplete = function () {\n            if (key instanceof Array) {\n                success(keys, values);\n            } else {\n                success(key, value);\n            }\n        };\n\n        for (var i = 0; i < keys.length && i < values.length; i++) {\n            var record = { v: values[i] };\n            transaction.objectStore(name).put(record, keys[i]);\n        }\n    }, error);\n};\n\n/** Clears the store\n * @method module:store/indexeddb~IndexedDBStore#clear\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.clear = function (success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        transaction.onerror = getError(error, defaultError);\n        transaction.oncomplete = function () {\n            success();\n        };\n\n        transaction.objectStore(name).clear();\n    }, error);\n};\n\n/** Closes the connection to the database\n * @method module:store/indexeddb~IndexedDBStore#close\n*/\nIndexedDBStore.prototype.close = function () {\n    \n    if (this.db) {\n        this.db.close();\n        this.db = null;\n    }\n};\n\n/** Returns whether the store contains a key\n * @method module:store/indexeddb~IndexedDBStore#contains\n * @param {String} key - The key\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.contains = function (key, success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    openTransaction(this, IDBT_READ_ONLY, function (transaction) {\n        var objectStore = transaction.objectStore(name);\n        var request = objectStore.get(key);\n\n        transaction.oncomplete = function () {\n            success(!!request.result);\n        };\n        transaction.onerror = getError(error, defaultError);\n    }, error);\n};\n\nIndexedDBStore.prototype.defaultError = throwErrorCallback;\n\n/** Gets all the keys from the store\n * @method module:store/indexeddb~IndexedDBStore#getAllKeys\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.getAllKeys = function (success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        var results = [];\n\n        transaction.oncomplete = function () {\n            success(results);\n        };\n\n        var request = transaction.objectStore(name).openCursor();\n\n        request.onerror = getError(error, defaultError);\n        request.onsuccess = function (event) {\n            var cursor = event.target.result;\n            if (cursor) {\n                results.push(cursor.key);\n                // Some tools have issues because continue is a javascript reserved word.\n                cursor[\"continue\"].call(cursor);\n            }\n        };\n    }, error);\n};\n\n/** Identifies the underlying mechanism used by the store.\n*/\nIndexedDBStore.prototype.mechanism = \"indexeddb\";\n\n/** Reads the value for the specified key\n * @method module:store/indexeddb~IndexedDBStore#read\n * @param {String} key - The key\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n * If the key does not exist, the success handler will be called with value = undefined\n */\nIndexedDBStore.prototype.read = function (key, success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    var keys = (key instanceof Array) ? key : [key];\n\n    openTransaction(this, IDBT_READ_ONLY, function (transaction) {\n        var values = [];\n\n        transaction.onerror = getError(error, defaultError, key, \"read\");\n        transaction.oncomplete = function () {\n            if (key instanceof Array) {\n                success(keys, values);\n            } else {\n                success(keys[0], values[0]);\n            }\n        };\n\n        for (var i = 0; i < keys.length; i++) {\n            // Some tools have issues because get is a javascript reserved word. \n            var objectStore = transaction.objectStore(name);\n            var request = objectStore.get.call(objectStore, keys[i]);\n            request.onsuccess = function (event) {\n                var record = event.target.result;\n                values.push(record ? record.v : undefined);\n            };\n        }\n    }, error);\n};\n\n/** Removes the specified key from the store\n * @method module:store/indexeddb~IndexedDBStore#remove\n * @param {String} key - The key\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.remove = function (key, success, error) {\n\n    var name = this.name;\n    var defaultError = this.defaultError;\n    var keys = (key instanceof Array) ? key : [key];\n\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        transaction.onerror = getError(error, defaultError);\n        transaction.oncomplete = function () {\n            success();\n        };\n\n        for (var i = 0; i < keys.length; i++) {\n            // Some tools have issues because continue is a javascript reserved word.\n            var objectStore = transaction.objectStore(name);\n            objectStore[\"delete\"].call(objectStore, keys[i]);\n        }\n    }, error);\n};\n\n/** Updates a key/value pair in the store\n * @method module:store/indexeddb~IndexedDBStore#update\n * @param {String} key - The key\n * @param {Object} value - The value\n * @param {Function} success - The success callback\n * @param {Function} error - The error callback\n */\nIndexedDBStore.prototype.update = function (key, value, success, error) {\n    var name = this.name;\n    var defaultError = this.defaultError;\n    var keys = [];\n    var values = [];\n\n    if (key instanceof Array) {\n        keys = key;\n        values = value;\n    } else {\n        keys = [key];\n        values = [value];\n    }\n\n    openTransaction(this, IDBT_READ_WRITE, function (transaction) {\n        transaction.onabort = getError(error, defaultError);\n        transaction.oncomplete = function () {\n            if (key instanceof Array) {\n                success(keys, values);\n            } else {\n                success(key, value);\n            }\n        };\n\n        for (var i = 0; i < keys.length && i < values.length; i++) {\n            var request = transaction.objectStore(name).openCursor(IDBKeyRange.only(keys[i]));\n            var record = { v: values[i] };\n            request.pair = { key: keys[i], value: record };\n            request.onsuccess = function (event) {\n                var cursor = event.target.result;\n                if (cursor) {\n                    cursor.update(event.target.pair.value);\n                } else {\n                    transaction.abort();\n                }\n            }\n        }\n    }, error);\n};\n\n\nmodule.exports = IndexedDBStore;}, \"memory\" : function(exports, module, require) {\n'use strict';\n\n/** @module store/memory */\n\n\nvar utils = require('./../utils.js');\n\n// Imports.\nvar throwErrorCallback = utils.throwErrorCallback;\nvar delay = utils.delay;\n\n/** Constructor for store objects that use a sorted array as the underlying mechanism.\n * @class MemoryStore\n * @constructor\n * @param {String} name - Store name.\n */\nfunction MemoryStore(name) {\n\n    var holes = [];\n    var items = [];\n    var keys = {};\n\n    this.name = name;\n\n    var getErrorCallback = function (error) {\n        return error || this.defaultError;\n    };\n\n    /** Validates that the specified key is not undefined, not null, and not an array\n     * @param key - Key value.\n     * @param {Function} error - Error callback.\n     * @returns {Boolean} True if the key is valid. False if the key is invalid and the error callback has been queued for execution.\n     */\n    function validateKeyInput(key, error) {\n\n        var messageString;\n\n        if (key instanceof Array) {\n            messageString = \"Array of keys not supported\";\n        }\n\n        if (key === undefined || key === null) {\n            messageString = \"Invalid key\";\n        }\n\n        if (messageString) {\n            delay(error, { message: messageString });\n            return false;\n        }\n        return true;\n    }\n\n    /** This method errors out if the store already contains the specified key.\n     * @summary Adds a new value identified by a key to the store.\n     * @method module:store/memory~MemoryStore#add\n     * @param {String} key - Key string.\n     * @param value - Value that is going to be added to the store.\n     * @param {Function} success - Callback for a successful add operation.\n     * @param {Function} error - Callback for handling errors. If not specified then store.defaultError is invoked.\n     */\n    this.add = function (key, value, success, error) {\n        error = getErrorCallback(error);\n\n        if (validateKeyInput(key, error)) {\n            if (!keys.hasOwnProperty(key)) {\n                this.addOrUpdate(key, value, success, error);\n            } else {\n                error({ message: \"key already exists\", key: key });\n            }\n        }\n    };\n\n    /** This method will overwrite the key's current value if it already exists in the store; otherwise it simply adds the new key and value.\n     * @summary Adds or updates a value identified by a key to the store.\n     * @method module:store/memory~MemoryStore#addOrUpdate\n     * @param {String} key - Key string.\n     * @param value - Value that is going to be added or updated to the store.\n     * @param {Function} success - Callback for a successful add or update operation.\n     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n    */\n    this.addOrUpdate = function (key, value, success, error) {\n        \n        error = getErrorCallback(error);\n\n        if (validateKeyInput(key, error)) {\n            var index = keys[key];\n            if (index === undefined) {\n                if (holes.length > 0) {\n                    index = holes.splice(0, 1);\n                } else {\n                    index = items.length;\n                }\n            }\n            items[index] = value;\n            keys[key] = index;\n            delay(success, key, value);\n        }\n    };\n\n    /** Removes all the data associated with this store object.\n     * @method module:store/memory~MemoryStore#clear\n     * @param {Function} success - Callback for a successful clear operation.\n     */\n    this.clear = function (success) {\n        items = [];\n        keys = {};\n        holes = [];\n        delay(success);\n    };\n\n    /** Checks whether a key exists in the store.\n     * @method module:store/memory~MemoryStore#contains\n     * @param {String} key - Key string.\n     * @param {Function} success - Callback indicating whether the store contains the key or not.\n     */\n    this.contains = function (key, success) {\n        var contained = keys.hasOwnProperty(key);\n        delay(success, contained);\n    };\n\n    /** Gets all the keys that exist in the store.\n     * @method module:store/memory~MemoryStore#getAllKeys\n     * @param {Function} success - Callback for a successful get operation.\n     */\n    this.getAllKeys = function (success) {\n\n        var results = [];\n        for (var name in keys) {\n            results.push(name);\n        }\n        delay(success, results);\n    };\n\n    /** Reads the value associated to a key in the store.\n     * @method module:store/memory~MemoryStore#read\n     * @param {String} key - Key string.\n     * @param {Function} success - Callback for a successful reads operation.\n     * @param {Function} error - Callback for handling errors. If not specified then store.defaultError is invoked.\n     */\n    this.read = function (key, success, error) {\n        error = getErrorCallback(error);\n\n        if (validateKeyInput(key, error)) {\n            var index = keys[key];\n            delay(success, key, items[index]);\n        }\n    };\n\n    /** Removes a key and its value from the store.\n     * @method module:store/memory~MemoryStore#remove\n     * @param {String} key - Key string.\n     * @param {Function} success - Callback for a successful remove operation.\n     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n     */\n    this.remove = function (key, success, error) {\n        error = getErrorCallback(error);\n\n        if (validateKeyInput(key, error)) {\n            var index = keys[key];\n            if (index !== undefined) {\n                if (index === items.length - 1) {\n                    items.pop();\n                } else {\n                    items[index] = undefined;\n                    holes.push(index);\n                }\n                delete keys[key];\n\n                // The last item was removed, no need to keep track of any holes in the array.\n                if (items.length === 0) {\n                    holes = [];\n                }\n            }\n\n            delay(success);\n        }\n    };\n\n    /** Updates the value associated to a key in the store.\n     * @method module:store/memory~MemoryStore#update\n     * @param {String} key - Key string.\n     * @param value - New value.\n     * @param {Function} success - Callback for a successful update operation.\n     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.\n     * This method errors out if the specified key is not found in the store.\n     */\n    this.update = function (key, value, success, error) {\n        error = getErrorCallback(error);\n        if (validateKeyInput(key, error)) {\n            if (keys.hasOwnProperty(key)) {\n                this.addOrUpdate(key, value, success, error);\n            } else {\n                error({ message: \"key not found\", key: key });\n            }\n        }\n    };\n}\n\n/** Creates a store object that uses memory storage as its underlying mechanism.\n * @method MemoryStore.create\n * @param {String} name - Store name.\n * @returns {Object} Store object.\n */\nMemoryStore.create = function (name) {\n    return new MemoryStore(name);\n};\n\n/** Checks whether the underlying mechanism for this kind of store objects is supported by the browser.\n * @method MemoryStore.isSupported\n * @returns {Boolean} True if the mechanism is supported by the browser; otherwise false.\n */\nMemoryStore.isSupported = function () {\n    return true;\n};\n\n/** This function does nothing in MemoryStore as it does not have a connection model.\n*/\nMemoryStore.prototype.close = function () {\n};\n\nMemoryStore.prototype.defaultError = throwErrorCallback;\n\n/** Identifies the underlying mechanism used by the store.\n*/\nMemoryStore.prototype.mechanism = \"memory\";\n\n\n/** MemoryStore (see {@link MemoryStore}) */\nmodule.exports = MemoryStore;}, \"utils\" : function(exports, module, require) {\n'use strict';\n\n/** @module odatajs/utils */\n\n\nfunction inBrowser() {\n    return typeof window !== 'undefined';\n}\n\n/** Creates a new ActiveXObject from the given progId.\n * @param {String} progId - ProgId string of the desired ActiveXObject.\n * @returns {Object} The ActiveXObject instance. Null if ActiveX is not supported by the browser.\n * This function throws whatever exception might occur during the creation\n * of the ActiveXObject.\n*/\nvar activeXObject = function (progId) {\n    \n    if (window.ActiveXObject) {\n        return new window.ActiveXObject(progId);\n    }\n    return null;\n};\n\n/** Checks whether the specified value is different from null and undefined.\n * @param [value] Value to check ( may be null)\n * @returns {Boolean} true if the value is assigned; false otherwise.\n*/     \nfunction assigned(value) {\n    return value !== null && value !== undefined;\n}\n\n/** Checks whether the specified item is in the array.\n * @param {Array} [arr] Array to check in.\n * @param item - Item to look for.\n * @returns {Boolean} true if the item is contained, false otherwise.\n*/\nfunction contains(arr, item) {\n    var i, len;\n    for (i = 0, len = arr.length; i < len; i++) {\n        if (arr[i] === item) {\n            return true;\n        }\n    }\n    return false;\n}\n\n/** Given two values, picks the first one that is not undefined.\n * @param a - First value.\n * @param b - Second value.\n * @returns a if it's a defined value; else b.\n */\nfunction defined(a, b) {\n    return (a !== undefined) ? a : b;\n}\n\n/** Delays the invocation of the specified function until execution unwinds.\n * @param {Function} callback - Callback function.\n */\nfunction delay(callback) {\n\n    if (arguments.length === 1) {\n        window.setTimeout(callback, 0);\n        return;\n    }\n\n    var args = Array.prototype.slice.call(arguments, 1);\n    window.setTimeout(function () {\n        callback.apply(this, args);\n    }, 0);\n}\n\n/** Throws an exception in case that a condition evaluates to false.\n * @param {Boolean} condition - Condition to evaluate.\n * @param {String} message - Message explaining the assertion.\n * @param {Object} data - Additional data to be included in the exception.\n */\nfunction djsassert(condition, message, data) {\n\n\n    if (!condition) {\n        throw { message: \"Assert fired: \" + message, data: data };\n    }\n}\n\n/** Extends the target with the specified values.\n * @param {Object} target - Object to add properties to.\n * @param {Object} values - Object with properties to add into target.\n * @returns {Object} The target object.\n*/\nfunction extend(target, values) {\n    for (var name in values) {\n        target[name] = values[name];\n    }\n\n    return target;\n}\n\nfunction find(arr, callback) {\n    /** Returns the first item in the array that makes the callback function true.\n     * @param {Array} [arr] Array to check in. ( may be null)\n     * @param {Function} callback - Callback function to invoke once per item in the array.\n     * @returns The first item that makes the callback return true; null otherwise or if the array is null.\n    */\n\n    if (arr) {\n        var i, len;\n        for (i = 0, len = arr.length; i < len; i++) {\n            if (callback(arr[i])) {\n                return arr[i];\n            }\n        }\n    }\n    return null;\n}\n\nfunction isArray(value) {\n    /** Checks whether the specified value is an array object.\n     * @param value - Value to check.\n     * @returns {Boolean} true if the value is an array object; false otherwise.\n     */\n\n    return Object.prototype.toString.call(value) === \"[object Array]\";\n}\n\n/** Checks whether the specified value is a Date object.\n * @param value - Value to check.\n * @returns {Boolean} true if the value is a Date object; false otherwise.\n */\nfunction isDate(value) {\n    return Object.prototype.toString.call(value) === \"[object Date]\";\n}\n\n/** Tests whether a value is an object.\n * @param value - Value to test.\n * @returns {Boolean} True is the value is an object; false otherwise.\n * Per javascript rules, null and array values are objects and will cause this function to return true.\n */\nfunction isObject(value) {\n    return typeof value === \"object\";\n}\n\n/** Parses a value in base 10.\n * @param {String} value - String value to parse.\n * @returns {Number} The parsed value, NaN if not a valid value.\n*/   \nfunction parseInt10(value) {\n    return parseInt(value, 10);\n}\n\n/** Renames a property in an object.\n * @param {Object} obj - Object in which the property will be renamed.\n * @param {String} oldName - Name of the property that will be renamed.\n * @param {String} newName - New name of the property.\n * This function will not do anything if the object doesn't own a property with the specified old name.\n */\nfunction renameProperty(obj, oldName, newName) {\n    if (obj.hasOwnProperty(oldName)) {\n        obj[newName] = obj[oldName];\n        delete obj[oldName];\n    }\n}\n\n/** Default error handler.\n * @param {Object} error - Error to handle.\n */\nfunction throwErrorCallback(error) {\n    throw error;\n}\n\n/** Removes leading and trailing whitespaces from a string.\n * @param {String} str String to trim\n * @returns {String} The string with no leading or trailing whitespace.\n */\nfunction trimString(str) {\n    if (str.trim) {\n        return str.trim();\n    }\n\n    return str.replace(/^\\s+|\\s+$/g, '');\n}\n\n/** Returns a default value in place of undefined.\n * @param [value] Value to check (may be null)\n * @param defaultValue - Value to return if value is undefined.\n * @returns value if it's defined; defaultValue otherwise.\n * This should only be used for cases where falsy values are valid;\n * otherwise the pattern should be 'x = (value) ? value : defaultValue;'.\n */\nfunction undefinedDefault(value, defaultValue) {\n    return (value !== undefined) ? value : defaultValue;\n}\n\n// Regular expression that splits a uri into its components:\n// 0 - is the matched string.\n// 1 - is the scheme.\n// 2 - is the authority.\n// 3 - is the path.\n// 4 - is the query.\n// 5 - is the fragment.\nvar uriRegEx = /^([^:\\/?#]+:)?(\\/\\/[^\\/?#]*)?([^?#:]+)?(\\?[^#]*)?(#.*)?/;\nvar uriPartNames = [\"scheme\", \"authority\", \"path\", \"query\", \"fragment\"];\n\n/** Gets information about the components of the specified URI.\n * @param {String} uri - URI to get information from.\n * @return  {Object} An object with an isAbsolute flag and part names (scheme, authority, etc.) if available.\n */\nfunction getURIInfo(uri) {\n    var result = { isAbsolute: false };\n\n    if (uri) {\n        var matches = uriRegEx.exec(uri);\n        if (matches) {\n            var i, len;\n            for (i = 0, len = uriPartNames.length; i < len; i++) {\n                if (matches[i + 1]) {\n                    result[uriPartNames[i]] = matches[i + 1];\n                }\n            }\n        }\n        if (result.scheme) {\n            result.isAbsolute = true;\n        }\n    }\n\n    return result;\n}\n\n/** Builds a URI string from its components.\n * @param {Object} uriInfo -  An object with uri parts (scheme, authority, etc.).\n * @returns {String} URI string.\n */\nfunction getURIFromInfo(uriInfo) {\n    return \"\".concat(\n        uriInfo.scheme || \"\",\n        uriInfo.authority || \"\",\n        uriInfo.path || \"\",\n        uriInfo.query || \"\",\n        uriInfo.fragment || \"\");\n}\n\n// Regular expression that splits a uri authority into its subcomponents:\n// 0 - is the matched string.\n// 1 - is the userinfo subcomponent.\n// 2 - is the host subcomponent.\n// 3 - is the port component.\nvar uriAuthorityRegEx = /^\\/{0,2}(?:([^@]*)@)?([^:]+)(?::{1}(\\d+))?/;\n\n// Regular expression that matches percentage enconded octects (i.e %20 or %3A);\nvar pctEncodingRegEx = /%[0-9A-F]{2}/ig;\n\n/** Normalizes the casing of a URI.\n * @param {String} uri - URI to normalize, absolute or relative.\n * @returns {String} The URI normalized to lower case.\n*/\nfunction normalizeURICase(uri) {\n    var uriInfo = getURIInfo(uri);\n    var scheme = uriInfo.scheme;\n    var authority = uriInfo.authority;\n\n    if (scheme) {\n        uriInfo.scheme = scheme.toLowerCase();\n        if (authority) {\n            var matches = uriAuthorityRegEx.exec(authority);\n            if (matches) {\n                uriInfo.authority = \"//\" +\n                (matches[1] ? matches[1] + \"@\" : \"\") +\n                (matches[2].toLowerCase()) +\n                (matches[3] ? \":\" + matches[3] : \"\");\n            }\n        }\n    }\n\n    uri = getURIFromInfo(uriInfo);\n\n    return uri.replace(pctEncodingRegEx, function (str) {\n        return str.toLowerCase();\n    });\n}\n\n/** Normalizes a possibly relative URI with a base URI.\n * @param {String} uri - URI to normalize, absolute or relative\n * @param {String} base - Base URI to compose with (may be null)\n * @returns {String} The composed URI if relative; the original one if absolute.\n */\nfunction normalizeURI(uri, base) {\n    if (!base) {\n        return uri;\n    }\n\n    var uriInfo = getURIInfo(uri);\n    if (uriInfo.isAbsolute) {\n        return uri;\n    }\n\n    var baseInfo = getURIInfo(base);\n    var normInfo = {};\n    var path;\n\n    if (uriInfo.authority) {\n        normInfo.authority = uriInfo.authority;\n        path = uriInfo.path;\n        normInfo.query = uriInfo.query;\n    } else {\n        if (!uriInfo.path) {\n            path = baseInfo.path;\n            normInfo.query = uriInfo.query || baseInfo.query;\n        } else {\n            if (uriInfo.path.charAt(0) === '/') {\n                path = uriInfo.path;\n            } else {\n                path = mergeUriPathWithBase(uriInfo.path, baseInfo.path);\n            }\n            normInfo.query = uriInfo.query;\n        }\n        normInfo.authority = baseInfo.authority;\n    }\n\n    normInfo.path = removeDotsFromPath(path);\n\n    normInfo.scheme = baseInfo.scheme;\n    normInfo.fragment = uriInfo.fragment;\n\n    return getURIFromInfo(normInfo);\n}\n\n/** Merges the path of a relative URI and a base URI.\n * @param {String} uriPath - Relative URI path.\n * @param {String} basePath - Base URI path.\n * @returns {String} A string with the merged path.\n */\nfunction mergeUriPathWithBase(uriPath, basePath) {\n    var path = \"/\";\n    var end;\n\n    if (basePath) {\n        end = basePath.lastIndexOf(\"/\");\n        path = basePath.substring(0, end);\n\n        if (path.charAt(path.length - 1) !== \"/\") {\n            path = path + \"/\";\n        }\n    }\n\n    return path + uriPath;\n}\n\n/** Removes the special folders . and .. from a URI's path.\n * @param {string} path - URI path component.\n * @returns {String} Path without any . and .. folders.\n */\nfunction removeDotsFromPath(path) {\n    var result = \"\";\n    var segment = \"\";\n    var end;\n\n    while (path) {\n        if (path.indexOf(\"..\") === 0 || path.indexOf(\".\") === 0) {\n            path = path.replace(/^\\.\\.?\\/?/g, \"\");\n        } else if (path.indexOf(\"/..\") === 0) {\n            path = path.replace(/^\\/\\..\\/?/g, \"/\");\n            end = result.lastIndexOf(\"/\");\n            if (end === -1) {\n                result = \"\";\n            } else {\n                result = result.substring(0, end);\n            }\n        } else if (path.indexOf(\"/.\") === 0) {\n            path = path.replace(/^\\/\\.\\/?/g, \"/\");\n        } else {\n            segment = path;\n            end = path.indexOf(\"/\", 1);\n            if (end !== -1) {\n                segment = path.substring(0, end);\n            }\n            result = result + segment;\n            path = path.replace(segment, \"\");\n        }\n    }\n    return result;\n}\n\nfunction convertByteArrayToHexString(str) {\n    var arr = [];\n    if (window.atob === undefined) {\n        arr = decodeBase64(str);\n    } else {\n        var binaryStr = window.atob(str);\n        for (var i = 0; i < binaryStr.length; i++) {\n            arr.push(binaryStr.charCodeAt(i));\n        }\n    }\n    var hexValue = \"\";\n    var hexValues = \"0123456789ABCDEF\";\n    for (var j = 0; j < arr.length; j++) {\n        var t = arr[j];\n        hexValue += hexValues[t >> 4];\n        hexValue += hexValues[t & 0x0F];\n    }\n    return hexValue;\n}\n\nfunction decodeBase64(str) {\n    var binaryString = \"\";\n    for (var i = 0; i < str.length; i++) {\n        var base65IndexValue = getBase64IndexValue(str[i]);\n        var binaryValue = \"\";\n        if (base65IndexValue !== null) {\n            binaryValue = base65IndexValue.toString(2);\n            binaryString += addBase64Padding(binaryValue);\n        }\n    }\n    var byteArray = [];\n    var numberOfBytes = parseInt(binaryString.length / 8, 10);\n    for (i = 0; i < numberOfBytes; i++) {\n        var intValue = parseInt(binaryString.substring(i * 8, (i + 1) * 8), 2);\n        byteArray.push(intValue);\n    }\n    return byteArray;\n}\n\nfunction getBase64IndexValue(character) {\n    var asciiCode = character.charCodeAt(0);\n    var asciiOfA = 65;\n    var differenceBetweenZanda = 6;\n    if (asciiCode >= 65 && asciiCode <= 90) {           // between \"A\" and \"Z\" inclusive\n        return asciiCode - asciiOfA;\n    } else if (asciiCode >= 97 && asciiCode <= 122) {   // between 'a' and 'z' inclusive\n        return asciiCode - asciiOfA - differenceBetweenZanda;\n    } else if (asciiCode >= 48 && asciiCode <= 57) {    // between '0' and '9' inclusive\n        return asciiCode + 4;\n    } else if (character == \"+\") {\n        return 62;\n    } else if (character == \"/\") {\n        return 63;\n    } else {\n        return null;\n    }\n}\n\nfunction addBase64Padding(binaryString) {\n    while (binaryString.length < 6) {\n        binaryString = \"0\" + binaryString;\n    }\n    return binaryString;\n\n}\n\nfunction getJsonValueArraryLength(data) {\n    if (data && data.value) {\n        return data.value.length;\n    }\n\n    return 0;\n}\n\nfunction sliceJsonValueArray(data, start, end) {\n    if (data === undefined || data.value === undefined) {\n        return data;\n    }\n\n    if (start < 0) {\n        start = 0;\n    }\n\n    var length = getJsonValueArraryLength(data);\n    if (length < end) {\n        end = length;\n    }\n\n    var newdata = {};\n    for (var property in data) {\n        if (property == \"value\") {\n            newdata[property] = data[property].slice(start, end);\n        } else {\n            newdata[property] = data[property];\n        }\n    }\n\n    return newdata;\n}\n\nfunction concatJsonValueArray(data, concatData) {\n    if (concatData === undefined || concatData.value === undefined) {\n        return data;\n    }\n\n    if (data === undefined || Object.keys(data).length === 0) {\n        return concatData;\n    }\n\n    if (data.value === undefined) {\n        data.value = concatData.value;\n        return data;\n    }\n\n    data.value = data.value.concat(concatData.value);\n\n    return data;\n}\n\nfunction endsWith(input, search) {\n    return input.indexOf(search, input.length - search.length) !== -1;\n}\n\nfunction startsWith (input, search) {\n    return input.indexOf(search) === 0;\n}\n\nfunction getFormatKind(format, defaultFormatKind) {\n    var formatKind = defaultFormatKind;\n    if (!assigned(format)) {\n        return formatKind;\n    }\n\n    var normalizedFormat = format.toLowerCase();\n    switch (normalizedFormat) {\n        case \"none\":\n            formatKind = 0;\n            break;\n        case \"minimal\":\n            formatKind = 1;\n            break;\n        case \"full\":\n            formatKind = 2;\n            break;\n        default:\n            break;\n    }\n\n    return formatKind;\n}\n\n\n    \n    \nexports.inBrowser = inBrowser;\nexports.activeXObject = activeXObject;\nexports.assigned = assigned;\nexports.contains = contains;\nexports.defined = defined;\nexports.delay = delay;\nexports.djsassert = djsassert;\nexports.extend = extend;\nexports.find = find;\nexports.getURIInfo = getURIInfo;\nexports.isArray = isArray;\nexports.isDate = isDate;\nexports.isObject = isObject;\nexports.normalizeURI = normalizeURI;\nexports.normalizeURICase = normalizeURICase;\nexports.parseInt10 = parseInt10;\nexports.renameProperty = renameProperty;\nexports.throwErrorCallback = throwErrorCallback;\nexports.trimString = trimString;\nexports.undefinedDefault = undefinedDefault;\nexports.decodeBase64 = decodeBase64;\nexports.convertByteArrayToHexString = convertByteArrayToHexString;\nexports.getJsonValueArraryLength = getJsonValueArraryLength;\nexports.sliceJsonValueArray = sliceJsonValueArray;\nexports.concatJsonValueArray = concatJsonValueArray;\nexports.startsWith = startsWith;\nexports.endsWith = endsWith;\nexports.getFormatKind = getFormatKind;}, \"xml\" : function(exports, module, require) {\n'use strict';\n \n\n/** @module odatajs/xml */\n\nvar utils    = require('./utils.js');\n\nvar activeXObject = utils.activeXObject;\nvar djsassert = utils.djsassert;\nvar extend = utils.extend;\nvar isArray = utils.isArray;\nvar normalizeURI = utils.normalizeURI;\n\n// URI prefixes to generate smaller code.\nvar http = \"http://\";\nvar w3org = http + \"www.w3.org/\";               // http://www.w3.org/\n\nvar xhtmlNS = w3org + \"1999/xhtml\";             // http://www.w3.org/1999/xhtml\nvar xmlnsNS = w3org + \"2000/xmlns/\";            // http://www.w3.org/2000/xmlns/\nvar xmlNS = w3org + \"XML/1998/namespace\";       // http://www.w3.org/XML/1998/namespace\n\nvar mozillaParserErroNS = http + \"www.mozilla.org/newlayout/xml/parsererror.xml\";\n\n/** Checks whether the specified string has leading or trailing spaces.\n * @param {String} text - String to check.\n * @returns {Boolean} true if text has any leading or trailing whitespace; false otherwise.\n */\nfunction hasLeadingOrTrailingWhitespace(text) {\n    var re = /(^\\s)|(\\s$)/;\n    return re.test(text);\n}\n\n/** Determines whether the specified text is empty or whitespace.\n * @param {String} text - Value to inspect.\n * @returns {Boolean} true if the text value is empty or all whitespace; false otherwise.\n */\nfunction isWhitespace(text) {\n\n\n    var ws = /^\\s*$/;\n    return text === null || ws.test(text);\n}\n\n/** Determines whether the specified element has xml:space='preserve' applied.\n * @param domElement - Element to inspect.\n * @returns {Boolean} Whether xml:space='preserve' is in effect.\n */\nfunction isWhitespacePreserveContext(domElement) {\n\n\n    while (domElement !== null && domElement.nodeType === 1) {\n        var val = xmlAttributeValue(domElement, \"space\", xmlNS);\n        if (val === \"preserve\") {\n            return true;\n        } else if (val === \"default\") {\n            break;\n        } else {\n            domElement = domElement.parentNode;\n        }\n    }\n\n    return false;\n}\n\n/** Determines whether the attribute is a XML namespace declaration.\n * @param domAttribute - Element to inspect.\n * @return {Boolean} True if the attribute is a namespace declaration (its name is 'xmlns' or starts with 'xmlns:'; false otherwise.\n */\nfunction isXmlNSDeclaration(domAttribute) {\n    var nodeName = domAttribute.nodeName;\n    return nodeName == \"xmlns\" || nodeName.indexOf(\"xmlns:\") === 0;\n}\n\n/** Safely set as property in an object by invoking obj.setProperty.\n * @param obj - Object that exposes a setProperty method.\n * @param {String} name - Property name\n * @param value - Property value.\n */\nfunction safeSetProperty(obj, name, value) {\n\n\n    try {\n        obj.setProperty(name, value);\n    } catch (_) { }\n}\n\n/** Creates an configures new MSXML 3.0 ActiveX object.\n * @returns {Object} New MSXML 3.0 ActiveX object.\n * This function throws any exception that occurs during the creation\n * of the MSXML 3.0 ActiveX object.\n */\nfunction msXmlDom3() {\n    var msxml3 = activeXObject(\"Msxml2.DOMDocument.3.0\");\n    if (msxml3) {\n        safeSetProperty(msxml3, \"ProhibitDTD\", true);\n        safeSetProperty(msxml3, \"MaxElementDepth\", 256);\n        safeSetProperty(msxml3, \"AllowDocumentFunction\", false);\n        safeSetProperty(msxml3, \"AllowXsltScript\", false);\n    }\n    return msxml3;\n}\n\n/** Creates an configures new MSXML 6.0 or MSXML 3.0 ActiveX object.\n * @returns {Object} New MSXML 3.0 ActiveX object.\n * This function will try to create a new MSXML 6.0 ActiveX object. If it fails then\n * it will fallback to create a new MSXML 3.0 ActiveX object. Any exception that\n * happens during the creation of the MSXML 6.0 will be handled by the function while\n * the ones that happend during the creation of the MSXML 3.0 will be thrown.\n */\nfunction msXmlDom() {\n    try {\n        var msxml = activeXObject(\"Msxml2.DOMDocument.6.0\");\n        if (msxml) {\n            msxml.async = true;\n        }\n        return msxml;\n    } catch (_) {\n        return msXmlDom3();\n    }\n}\n\n/** Parses an XML string using the MSXML DOM.\n * @returns {Object} New MSXML DOMDocument node representing the parsed XML string.\n * This function throws any exception that occurs during the creation\n * of the MSXML ActiveX object.  It also will throw an exception\n * in case of a parsing error.\n */\nfunction msXmlParse(text) {\n    var dom = msXmlDom();\n    if (!dom) {\n        return null;\n    }\n\n    dom.loadXML(text);\n    var parseError = dom.parseError;\n    if (parseError.errorCode !== 0) {\n        xmlThrowParserError(parseError.reason, parseError.srcText, text);\n    }\n    return dom;\n}\n\n/** Throws a new exception containing XML parsing error information.\n * @param exceptionOrReason - String indicating the reason of the parsing failure or Object detailing the parsing error.\n * @param {String} srcText -     String indicating the part of the XML string that caused the parsing error.\n * @param {String} errorXmlText - XML string for wich the parsing failed.\n */\nfunction xmlThrowParserError(exceptionOrReason, srcText, errorXmlText) {\n\n    if (typeof exceptionOrReason === \"string\") {\n        exceptionOrReason = { message: exceptionOrReason };\n    }\n    throw extend(exceptionOrReason, { srcText: srcText || \"\", errorXmlText: errorXmlText || \"\" });\n}\n\n/** Returns an XML DOM document from the specified text.\n * @param {String} text - Document text.\n * @returns XML DOM document.\n * This function will throw an exception in case of a parse error\n */\nfunction xmlParse(text) {\n    var domParser = undefined;\n    if (utils.inBrowser()) {\n        domParser = window.DOMParser && new window.DOMParser();\n    } else {\n        domParser = new (require('xmldom').DOMParser)();\n    }\n    var dom;\n\n    if (!domParser) {\n        dom = msXmlParse(text);\n        if (!dom) {\n            xmlThrowParserError(\"XML DOM parser not supported\");\n        }\n        return dom;\n    }\n\n    try {\n        dom = domParser.parseFromString(text, \"text/xml\");\n    } catch (e) {\n        xmlThrowParserError(e, \"\", text);\n    }\n\n    var element = dom.documentElement;\n    var nsURI = element.namespaceURI;\n    var localName = xmlLocalName(element);\n\n    // Firefox reports errors by returing the DOM for an xml document describing the problem.\n    if (localName === \"parsererror\" && nsURI === mozillaParserErroNS) {\n        var srcTextElement = xmlFirstChildElement(element, mozillaParserErroNS, \"sourcetext\");\n        var srcText = srcTextElement ? xmlNodeValue(srcTextElement) : \"\";\n        xmlThrowParserError(xmlInnerText(element) || \"\", srcText, text);\n    }\n\n    // Chrome (and maybe other webkit based browsers) report errors by injecting a header with an error message.\n    // The error may be localized, so instead we simply check for a header as the\n    // top element or descendant child of the document.\n    if (localName === \"h3\" && nsURI === xhtmlNS || xmlFirstDescendantElement(element, xhtmlNS, \"h3\")) {\n        var reason = \"\";\n        var siblings = [];\n        var cursor = element.firstChild;\n        while (cursor) {\n            if (cursor.nodeType === 1) {\n                reason += xmlInnerText(cursor) || \"\";\n            }\n            siblings.push(cursor.nextSibling);\n            cursor = cursor.firstChild || siblings.shift();\n        }\n        reason += xmlInnerText(element) || \"\";\n        xmlThrowParserError(reason, \"\", text);\n    }\n\n    return dom;\n}\n\n/** Builds a XML qualified name string in the form of \"prefix:name\".\n * @param {String} prefix - Prefix string (may be null)\n * @param {String} name - Name string to qualify with the prefix.\n * @returns {String} Qualified name.\n */\nfunction xmlQualifiedName(prefix, name) {\n    return prefix ? prefix + \":\" + name : name;\n}\n\n/** Appends a text node into the specified DOM element node.\n * @param domNode - DOM node for the element.\n * @param {String} textNode - Text to append as a child of element.\n*/\nfunction xmlAppendText(domNode, textNode) {\n    if (hasLeadingOrTrailingWhitespace(textNode.data)) {\n        var attr = xmlAttributeNode(domNode, xmlNS, \"space\");\n        if (!attr) {\n            attr = xmlNewAttribute(domNode.ownerDocument, xmlNS, xmlQualifiedName(\"xml\", \"space\"));\n            xmlAppendChild(domNode, attr);\n        }\n        attr.value = \"preserve\";\n    }\n    domNode.appendChild(textNode);\n    return domNode;\n}\n\n/** Iterates through the XML element's attributes and invokes the callback function for each one.\n * @param element - Wrapped element to iterate over.\n * @param {Function} onAttributeCallback - Callback function to invoke with wrapped attribute nodes.\n*/\nfunction xmlAttributes(element, onAttributeCallback) {\n    var attributes = element.attributes;\n    var i, len;\n    for (i = 0, len = attributes.length; i < len; i++) {\n        onAttributeCallback(attributes.item(i));\n    }\n}\n\n/** Returns the value of a DOM element's attribute.\n * @param domNode - DOM node for the owning element.\n * @param {String} localName - Local name of the attribute.\n * @param {String} nsURI - Namespace URI of the attribute.\n * @returns {String} - The attribute value, null if not found (may be null)\n */\nfunction xmlAttributeValue(domNode, localName, nsURI) {\n\n    var attribute = xmlAttributeNode(domNode, localName, nsURI);\n    return attribute ? xmlNodeValue(attribute) : null;\n}\n\n/** Gets an attribute node from a DOM element.\n * @param domNode - DOM node for the owning element.\n * @param {String} localName - Local name of the attribute.\n * @param {String} nsURI - Namespace URI of the attribute.\n * @returns The attribute node, null if not found.\n */\nfunction xmlAttributeNode(domNode, localName, nsURI) {\n\n    var attributes = domNode.attributes;\n    if (attributes.getNamedItemNS) {\n        return attributes.getNamedItemNS(nsURI || null, localName);\n    }\n\n    return attributes.getQualifiedItem(localName, nsURI) || null;\n}\n\n/** Gets the value of the xml:base attribute on the specified element.\n * @param domNode - Element to get xml:base attribute value from.\n * @param [baseURI] - Base URI used to normalize the value of the xml:base attribute ( may be null)\n * @returns {String} Value of the xml:base attribute if found; the baseURI or null otherwise.\n */\nfunction xmlBaseURI(domNode, baseURI) {\n\n    var base = xmlAttributeNode(domNode, \"base\", xmlNS);\n    return (base ? normalizeURI(base.value, baseURI) : baseURI) || null;\n}\n\n\n/** Iterates through the XML element's child DOM elements and invokes the callback function for each one.\n * @param domNode - DOM Node containing the DOM elements to iterate over.\n * @param {Function} onElementCallback - Callback function to invoke for each child DOM element.\n*/\nfunction xmlChildElements(domNode, onElementCallback) {\n\n    xmlTraverse(domNode, /*recursive*/false, function (child) {\n        if (child.nodeType === 1) {\n            onElementCallback(child);\n        }\n        // continue traversing.\n        return true;\n    });\n}\n\n/** Gets the descendant element under root that corresponds to the specified path and namespace URI.\n * @param root - DOM element node from which to get the descendant element.\n * @param {String} namespaceURI - The namespace URI of the element to match.\n * @param {String} path - Path to the desired descendant element.\n * @return The element specified by path and namespace URI.\n * All the elements in the path are matched against namespaceURI.\n * The function will stop searching on the first element that doesn't match the namespace and the path.\n */\nfunction xmlFindElementByPath(root, namespaceURI, path) {\n    var parts = path.split(\"/\");\n    var i, len;\n    for (i = 0, len = parts.length; i < len; i++) {\n        root = root && xmlFirstChildElement(root, namespaceURI, parts[i]);\n    }\n    return root || null;\n}\n\n/** Gets the DOM element or DOM attribute node under root that corresponds to the specified path and namespace URI.\n * @param root - DOM element node from which to get the descendant node.\n * @param {String} namespaceURI - The namespace URI of the node to match.\n * @param {String} path - Path to the desired descendant node.\n * @return The node specified by path and namespace URI.\n\n* This function will traverse the path and match each node associated to a path segement against the namespace URI.\n* The traversal stops when the whole path has been exahusted or a node that doesn't belogong the specified namespace is encountered.\n* The last segment of the path may be decorated with a starting @ character to indicate that the desired node is a DOM attribute.\n*/\nfunction xmlFindNodeByPath(root, namespaceURI, path) {\n    \n\n    var lastSegmentStart = path.lastIndexOf(\"/\");\n    var nodePath = path.substring(lastSegmentStart + 1);\n    var parentPath = path.substring(0, lastSegmentStart);\n\n    var node = parentPath ? xmlFindElementByPath(root, namespaceURI, parentPath) : root;\n    if (node) {\n        if (nodePath.charAt(0) === \"@\") {\n            return xmlAttributeNode(node, nodePath.substring(1), namespaceURI);\n        }\n        return xmlFirstChildElement(node, namespaceURI, nodePath);\n    }\n    return null;\n}\n\n/** Returns the first child DOM element under the specified DOM node that matches the specified namespace URI and local name.\n * @param domNode - DOM node from which the child DOM element is going to be retrieved.\n * @param {String} [namespaceURI] - \n * @param {String} [localName] - \n * @return The node's first child DOM element that matches the specified namespace URI and local name; null otherwise.\n */\nfunction xmlFirstChildElement(domNode, namespaceURI, localName) {\n\n    return xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, /*recursive*/false);\n}\n\n/** Returns the first descendant DOM element under the specified DOM node that matches the specified namespace URI and local name.\n * @param domNode - DOM node from which the descendant DOM element is going to be retrieved.\n * @param {String} [namespaceURI] - \n * @param {String} [localName] - \n * @return The node's first descendant DOM element that matches the specified namespace URI and local name; null otherwise.\n*/\nfunction xmlFirstDescendantElement(domNode, namespaceURI, localName) {\n    if (domNode.getElementsByTagNameNS) {\n        var result = domNode.getElementsByTagNameNS(namespaceURI, localName);\n        return result.length > 0 ? result[0] : null;\n    }\n    return xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, /*recursive*/true);\n}\n\n/** Returns the first descendant DOM element under the specified DOM node that matches the specified namespace URI and local name.\n * @param domNode - DOM node from which the descendant DOM element is going to be retrieved.\n * @param {String} [namespaceURI] - \n * @param {String} [localName] - \n * @param {Boolean} recursive \n * - True if the search should include all the descendants of the DOM node.  \n * - False if the search should be scoped only to the direct children of the DOM node.\n * @return The node's first descendant DOM element that matches the specified namespace URI and local name; null otherwise.\n */\nfunction xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, recursive) {\n\n    var firstElement = null;\n    xmlTraverse(domNode, recursive, function (child) {\n        if (child.nodeType === 1) {\n            var isExpectedNamespace = !namespaceURI || xmlNamespaceURI(child) === namespaceURI;\n            var isExpectedNodeName = !localName || xmlLocalName(child) === localName;\n\n            if (isExpectedNamespace && isExpectedNodeName) {\n                firstElement = child;\n            }\n        }\n        return firstElement === null;\n    });\n    return firstElement;\n}\n\n/** Gets the concatenated value of all immediate child text and CDATA nodes for the specified element.\n * @param xmlElement - Element to get values for.\n * @returns {String} Text for all direct children.\n */\nfunction xmlInnerText(xmlElement) {\n\n    var result = null;\n    var root = (xmlElement.nodeType === 9 && xmlElement.documentElement) ? xmlElement.documentElement : xmlElement;\n    var whitespaceAlreadyRemoved = root.ownerDocument.preserveWhiteSpace === false;\n    var whitespacePreserveContext;\n\n    xmlTraverse(root, false, function (child) {\n        if (child.nodeType === 3 || child.nodeType === 4) {\n            // isElementContentWhitespace indicates that this is 'ignorable whitespace',\n            // but it's not defined by all browsers, and does not honor xml:space='preserve'\n            // in some implementations.\n            //\n            // If we can't tell either way, we walk up the tree to figure out whether\n            // xml:space is set to preserve; otherwise we discard pure-whitespace.\n            //\n            // For example <a>  <b>1</b></a>. The space between <a> and <b> is usually 'ignorable'.\n            var text = xmlNodeValue(child);\n            var shouldInclude = whitespaceAlreadyRemoved || !isWhitespace(text);\n            if (!shouldInclude) {\n                // Walk up the tree to figure out whether we are in xml:space='preserve' context\n                // for the cursor (needs to happen only once).\n                if (whitespacePreserveContext === undefined) {\n                    whitespacePreserveContext = isWhitespacePreserveContext(root);\n                }\n\n                shouldInclude = whitespacePreserveContext;\n            }\n\n            if (shouldInclude) {\n                if (!result) {\n                    result = text;\n                } else {\n                    result += text;\n                }\n            }\n        }\n        // Continue traversing?\n        return true;\n    });\n    return result;\n}\n\n/** Returns the localName of a XML node.\n * @param domNode - DOM node to get the value from.\n * @returns {String} localName of domNode.\n */\nfunction xmlLocalName(domNode) {\n\n    return domNode.localName || domNode.baseName;\n}\n\n/** Returns the namespace URI of a XML node.\n * @param domNode - DOM node to get the value from.\n * @returns {String} Namespace URI of domNode.\n */\nfunction xmlNamespaceURI(domNode) {\n\n    return domNode.namespaceURI || null;\n}\n\n/** Returns the value or the inner text of a XML node.\n * @param domNode - DOM node to get the value from.\n * @return Value of the domNode or the inner text if domNode represents a DOM element node.\n */\nfunction xmlNodeValue(domNode) {\n    \n    if (domNode.nodeType === 1) {\n        return xmlInnerText(domNode);\n    }\n    return domNode.nodeValue;\n}\n\n/** Walks through the descendants of the domNode and invokes a callback for each node.\n * @param domNode - DOM node whose descendants are going to be traversed.\n * @param {Boolean} recursive\n * - True if the traversal should include all the descenants of the DOM node.\n * - False if the traversal should be scoped only to the direct children of the DOM node.\n * @param {Boolean} onChildCallback - Called for each child\n * @returns {String} Namespace URI of node.\n */\nfunction xmlTraverse(domNode, recursive, onChildCallback) {\n\n    var subtrees = [];\n    var child = domNode.firstChild;\n    var proceed = true;\n    while (child && proceed) {\n        proceed = onChildCallback(child);\n        if (proceed) {\n            if (recursive && child.firstChild) {\n                subtrees.push(child.firstChild);\n            }\n            child = child.nextSibling || subtrees.shift();\n        }\n    }\n}\n\n/** Returns the next sibling DOM element of the specified DOM node.\n * @param domNode - DOM node from which the next sibling is going to be retrieved.\n * @param {String} [namespaceURI] - \n * @param {String} [localName] - \n * @return The node's next sibling DOM element, null if there is none.\n */\nfunction xmlSiblingElement(domNode, namespaceURI, localName) {\n\n    var sibling = domNode.nextSibling;\n    while (sibling) {\n        if (sibling.nodeType === 1) {\n            var isExpectedNamespace = !namespaceURI || xmlNamespaceURI(sibling) === namespaceURI;\n            var isExpectedNodeName = !localName || xmlLocalName(sibling) === localName;\n\n            if (isExpectedNamespace && isExpectedNodeName) {\n                return sibling;\n            }\n        }\n        sibling = sibling.nextSibling;\n    }\n    return null;\n}\n\n/** Creates a new empty DOM document node.\n * @return New DOM document node.\n *\n * This function will first try to create a native DOM document using\n * the browsers createDocument function.  If the browser doesn't\n * support this but supports ActiveXObject, then an attempt to create\n * an MSXML 6.0 DOM will be made. If this attempt fails too, then an attempt\n * for creating an MXSML 3.0 DOM will be made.  If this last attemp fails or\n * the browser doesn't support ActiveXObject then an exception will be thrown.\n */\nfunction xmlDom() {\n    var implementation = window.document.implementation;\n    return (implementation && implementation.createDocument) ?\n       implementation.createDocument(null, null, null) :\n       msXmlDom();\n}\n\n/** Appends a collection of child nodes or string values to a parent DOM node.\n * @param parent - DOM node to which the children will be appended.\n * @param {Array} children - Array containing DOM nodes or string values that will be appended to the parent.\n * @return The parent with the appended children or string values.\n *  If a value in the children collection is a string, then a new DOM text node is going to be created\n *  for it and then appended to the parent.\n */\nfunction xmlAppendChildren(parent, children) {\n    if (!isArray(children)) {\n        return xmlAppendChild(parent, children);\n    }\n\n    var i, len;\n    for (i = 0, len = children.length; i < len; i++) {\n        children[i] && xmlAppendChild(parent, children[i]);\n    }\n    return parent;\n}\n\n/** Appends a child node or a string value to a parent DOM node.\n * @param parent - DOM node to which the child will be appended.\n * @param child - Child DOM node or string value to append to the parent.\n * @return The parent with the appended child or string value.\n * If child is a string value, then a new DOM text node is going to be created\n * for it and then appended to the parent.\n */\nfunction xmlAppendChild(parent, child) {\n\n    djsassert(parent !== child, \"xmlAppendChild() - parent and child are one and the same!\");\n    if (child) {\n        if (typeof child === \"string\") {\n            return xmlAppendText(parent, xmlNewText(parent.ownerDocument, child));\n        }\n        if (child.nodeType === 2) {\n            parent.setAttributeNodeNS ? parent.setAttributeNodeNS(child) : parent.setAttributeNode(child);\n        } else {\n            parent.appendChild(child);\n        }\n    }\n    return parent;\n}\n\n/** Creates a new DOM attribute node.\n * @param dom - DOM document used to create the attribute.\n * @param {String} namespaceURI - Namespace URI.\n * @param {String} qualifiedName - Qualified OData name\n * @param {String} value - Value of the new attribute\n * @return DOM attribute node for the namespace declaration.\n */\nfunction xmlNewAttribute(dom, namespaceURI, qualifiedName, value) {\n\n    var attribute =\n        dom.createAttributeNS && dom.createAttributeNS(namespaceURI, qualifiedName) ||\n        dom.createNode(2, qualifiedName, namespaceURI || undefined);\n\n    attribute.value = value || \"\";\n    return attribute;\n}\n\n/** Creates a new DOM element node.\n * @param dom - DOM document used to create the DOM element.\n * @param {String} namespaceURI - Namespace URI of the new DOM element.\n * @param {String} qualifiedName - Qualified name in the form of \"prefix:name\" of the new DOM element.\n * @param {Array} [children] Collection of child DOM nodes or string values that are going to be appended to the new DOM element.\n * @return New DOM element.\n * If a value in the children collection is a string, then a new DOM text node is going to be created\n * for it and then appended to the new DOM element.\n */\nfunction xmlNewElement(dom, namespaceURI, qualifiedName, children) {\n    var element =\n        dom.createElementNS && dom.createElementNS(nampespaceURI, qualifiedName) ||\n        dom.createNode(1, qualifiedName, nampespaceURI || undefined);\n\n    return xmlAppendChildren(element, children || []);\n}\n\n/** Creates a namespace declaration attribute.\n * @param dom - DOM document used to create the attribute.\n * @param {String} namespaceURI - Namespace URI.\n * @param {String} prefix - Namespace prefix.\n * @return DOM attribute node for the namespace declaration.\n */\nfunction xmlNewNSDeclaration(dom, namespaceURI, prefix) {\n    return xmlNewAttribute(dom, xmlnsNS, xmlQualifiedName(\"xmlns\", prefix), namespaceURI);\n}\n\n/** Creates a new DOM document fragment node for the specified xml text.\n * @param dom - DOM document from which the fragment node is going to be created.\n * @param {String} text XML text to be represented by the XmlFragment.\n * @return New DOM document fragment object.\n */\nfunction xmlNewFragment(dom, text) {\n\n    var value = \"<c>\" + text + \"</c>\";\n    var tempDom = xmlParse(value);\n    var tempRoot = tempDom.documentElement;\n    var imported = (\"importNode\" in dom) ? dom.importNode(tempRoot, true) : tempRoot;\n    var fragment = dom.createDocumentFragment();\n\n    var importedChild = imported.firstChild;\n    while (importedChild) {\n        fragment.appendChild(importedChild);\n        importedChild = importedChild.nextSibling;\n    }\n    return fragment;\n}\n\n/** Creates new DOM text node.\n * @param dom - DOM document used to create the text node.\n * @param {String} text - Text value for the DOM text node.\n * @return DOM text node.\n */ \nfunction xmlNewText(dom, text) {\n    return dom.createTextNode(text);\n}\n\n/** Creates a new DOM element or DOM attribute node as specified by path and appends it to the DOM tree pointed by root.\n * @param dom - DOM document used to create the new node.\n * @param root - DOM element node used as root of the subtree on which the new nodes are going to be created.\n * @param {String} namespaceURI - Namespace URI of the new DOM element or attribute.\n * @param {String} prefix - Prefix used to qualify the name of the new DOM element or attribute.\n * @param {String} path - Path string describing the location of the new DOM element or attribute from the root element.\n * @return DOM element or attribute node for the last segment of the path.\n\n * This function will traverse the path and will create a new DOM element with the specified namespace URI and prefix\n * for each segment that doesn't have a matching element under root.\n * The last segment of the path may be decorated with a starting @ character. In this case a new DOM attribute node\n * will be created.\n */\nfunction xmlNewNodeByPath(dom, root, namespaceURI, prefix, path) {\n    var name = \"\";\n    var parts = path.split(\"/\");\n    var xmlFindNode = xmlFirstChildElement;\n    var xmlNewNode = xmlNewElement;\n    var xmlNode = root;\n\n    var i, len;\n    for (i = 0, len = parts.length; i < len; i++) {\n        name = parts[i];\n        if (name.charAt(0) === \"@\") {\n            name = name.substring(1);\n            xmlFindNode = xmlAttributeNode;\n            xmlNewNode = xmlNewAttribute;\n        }\n\n        var childNode = xmlFindNode(xmlNode, namespaceURI, name);\n        if (!childNode) {\n            childNode = xmlNewNode(dom, namespaceURI, xmlQualifiedName(prefix, name));\n            xmlAppendChild(xmlNode, childNode);\n        }\n        xmlNode = childNode;\n    }\n    return xmlNode;\n}\n\n/** Returns the text representation of the document to which the specified node belongs.\n * @param domNode - Wrapped element in the document to serialize.\n * @returns {String} Serialized document.\n*/\nfunction xmlSerialize(domNode) {\n    var xmlSerializer = window.XMLSerializer;\n    if (xmlSerializer) {\n        var serializer = new xmlSerializer();\n        return serializer.serializeToString(domNode);\n    }\n\n    if (domNode.xml) {\n        return domNode.xml;\n    }\n\n    throw { message: \"XML serialization unsupported\" };\n}\n\n/** Returns the XML representation of the all the descendants of the node.\n * @param domNode - Node to serialize.\n * @returns {String} The XML representation of all the descendants of the node.\n */\nfunction xmlSerializeDescendants(domNode) {\n    var children = domNode.childNodes;\n    var i, len = children.length;\n    if (len === 0) {\n        return \"\";\n    }\n\n    // Some implementations of the XMLSerializer don't deal very well with fragments that\n    // don't have a DOMElement as their first child. The work around is to wrap all the\n    // nodes in a dummy root node named \"c\", serialize it and then just extract the text between\n    // the <c> and the </c> substrings.\n\n    var dom = domNode.ownerDocument;\n    var fragment = dom.createDocumentFragment();\n    var fragmentRoot = dom.createElement(\"c\");\n\n    fragment.appendChild(fragmentRoot);\n    // Move the children to the fragment tree.\n    for (i = 0; i < len; i++) {\n        fragmentRoot.appendChild(children[i]);\n    }\n\n    var xml = xmlSerialize(fragment);\n    xml = xml.substr(3, xml.length - 7);\n\n    // Move the children back to the original dom tree.\n    for (i = 0; i < len; i++) {\n        domNode.appendChild(fragmentRoot.childNodes[i]);\n    }\n\n    return xml;\n}\n\n/** Returns the XML representation of the node and all its descendants.\n * @param domNode - Node to serialize\n * @returns {String} The XML representation of the node and all its descendants.\n */\nfunction xmlSerializeNode(domNode) {\n\n    var xml = domNode.xml;\n    if (xml !== undefined) {\n        return xml;\n    }\n\n    if (window.XMLSerializer) {\n        var serializer = new window.XMLSerializer();\n        return serializer.serializeToString(domNode);\n    }\n\n    throw { message: \"XML serialization unsupported\" };\n}\n\nexports.http = http;\nexports.w3org = w3org;\nexports.xmlNS = xmlNS;\nexports.xmlnsNS = xmlnsNS;\n\nexports.hasLeadingOrTrailingWhitespace = hasLeadingOrTrailingWhitespace;\nexports.isXmlNSDeclaration = isXmlNSDeclaration;\nexports.xmlAppendChild = xmlAppendChild;\nexports.xmlAppendChildren = xmlAppendChildren;\nexports.xmlAttributeNode = xmlAttributeNode;\nexports.xmlAttributes = xmlAttributes;\nexports.xmlAttributeValue = xmlAttributeValue;\nexports.xmlBaseURI = xmlBaseURI;\nexports.xmlChildElements = xmlChildElements;\nexports.xmlFindElementByPath = xmlFindElementByPath;\nexports.xmlFindNodeByPath = xmlFindNodeByPath;\nexports.xmlFirstChildElement = xmlFirstChildElement;\nexports.xmlFirstDescendantElement = xmlFirstDescendantElement;\nexports.xmlInnerText = xmlInnerText;\nexports.xmlLocalName = xmlLocalName;\nexports.xmlNamespaceURI = xmlNamespaceURI;\nexports.xmlNodeValue = xmlNodeValue;\nexports.xmlDom = xmlDom;\nexports.xmlNewAttribute = xmlNewAttribute;\nexports.xmlNewElement = xmlNewElement;\nexports.xmlNewFragment = xmlNewFragment;\nexports.xmlNewNodeByPath = xmlNewNodeByPath;\nexports.xmlNewNSDeclaration = xmlNewNSDeclaration;\nexports.xmlNewText = xmlNewText;\nexports.xmlParse = xmlParse;\nexports.xmlQualifiedName = xmlQualifiedName;\nexports.xmlSerialize = xmlSerialize;\nexports.xmlSerializeDescendants = xmlSerializeDescendants;\nexports.xmlSiblingElement = xmlSiblingElement;\n}};\n\n  var modules = {};\n\n  var require = function (path) {\n    var name = path.substring(path.lastIndexOf('/') + 1, path.length - 3);\n    if (modules[name]) { return modules[name].exports; }\n\n    modules[name] = { exports: {} };\n    datas[name].call(this, modules[name].exports, modules[name], require);\n    return modules[name].exports;\n  };\n\n  window.odatajs = {};\n  init.call(this, window.odatajs, window.odatajs, require);\n})();\n"]}