{"version":3,"file":"cxStoreBundle.js","mappings":"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","sources":["webpack://Candex/./node_modules/localforage/dist/localforage.js","webpack://Candex/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://Candex/./node_modules/@babel/runtime/helpers/typeof.js","webpack://Candex/./node_modules/@babel/runtime/regenerator/index.js","webpack://Candex/webpack/bootstrap","webpack://Candex/webpack/runtime/compat get default export","webpack://Candex/webpack/runtime/define property getters","webpack://Candex/webpack/runtime/global","webpack://Candex/webpack/runtime/hasOwnProperty shorthand","webpack://Candex/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://Candex/./Scripts/app/CXStore.js"],"sourcesContent":["/*!\n    localForage -- Offline Storage, Improved\n    Version 1.10.0\n    https://localforage.github.io/localForage\n    (c) 2013-2017 Mozilla, Apache License 2.0\n*/\n(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.localforage = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw (f.code=\"MODULE_NOT_FOUND\", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){\n(function (global){\n'use strict';\nvar Mutation = global.MutationObserver || global.WebKitMutationObserver;\n\nvar scheduleDrain;\n\n{\n  if (Mutation) {\n    var called = 0;\n    var observer = new Mutation(nextTick);\n    var element = global.document.createTextNode('');\n    observer.observe(element, {\n      characterData: true\n    });\n    scheduleDrain = function () {\n      element.data = (called = ++called % 2);\n    };\n  } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {\n    var channel = new global.MessageChannel();\n    channel.port1.onmessage = nextTick;\n    scheduleDrain = function () {\n      channel.port2.postMessage(0);\n    };\n  } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {\n    scheduleDrain = function () {\n\n      // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n      // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n      var scriptEl = global.document.createElement('script');\n      scriptEl.onreadystatechange = function () {\n        nextTick();\n\n        scriptEl.onreadystatechange = null;\n        scriptEl.parentNode.removeChild(scriptEl);\n        scriptEl = null;\n      };\n      global.document.documentElement.appendChild(scriptEl);\n    };\n  } else {\n    scheduleDrain = function () {\n      setTimeout(nextTick, 0);\n    };\n  }\n}\n\nvar draining;\nvar queue = [];\n//named nextTick for less confusing stack traces\nfunction nextTick() {\n  draining = true;\n  var i, oldQueue;\n  var len = queue.length;\n  while (len) {\n    oldQueue = queue;\n    queue = [];\n    i = -1;\n    while (++i < len) {\n      oldQueue[i]();\n    }\n    len = queue.length;\n  }\n  draining = false;\n}\n\nmodule.exports = immediate;\nfunction immediate(task) {\n  if (queue.push(task) === 1 && !draining) {\n    scheduleDrain();\n  }\n}\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{}],2:[function(_dereq_,module,exports){\n'use strict';\nvar immediate = _dereq_(1);\n\n/* istanbul ignore next */\nfunction INTERNAL() {}\n\nvar handlers = {};\n\nvar REJECTED = ['REJECTED'];\nvar FULFILLED = ['FULFILLED'];\nvar PENDING = ['PENDING'];\n\nmodule.exports = Promise;\n\nfunction Promise(resolver) {\n  if (typeof resolver !== 'function') {\n    throw new TypeError('resolver must be a function');\n  }\n  this.state = PENDING;\n  this.queue = [];\n  this.outcome = void 0;\n  if (resolver !== INTERNAL) {\n    safelyResolveThenable(this, resolver);\n  }\n}\n\nPromise.prototype[\"catch\"] = function (onRejected) {\n  return this.then(null, onRejected);\n};\nPromise.prototype.then = function (onFulfilled, onRejected) {\n  if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||\n    typeof onRejected !== 'function' && this.state === REJECTED) {\n    return this;\n  }\n  var promise = new this.constructor(INTERNAL);\n  if (this.state !== PENDING) {\n    var resolver = this.state === FULFILLED ? onFulfilled : onRejected;\n    unwrap(promise, resolver, this.outcome);\n  } else {\n    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));\n  }\n\n  return promise;\n};\nfunction QueueItem(promise, onFulfilled, onRejected) {\n  this.promise = promise;\n  if (typeof onFulfilled === 'function') {\n    this.onFulfilled = onFulfilled;\n    this.callFulfilled = this.otherCallFulfilled;\n  }\n  if (typeof onRejected === 'function') {\n    this.onRejected = onRejected;\n    this.callRejected = this.otherCallRejected;\n  }\n}\nQueueItem.prototype.callFulfilled = function (value) {\n  handlers.resolve(this.promise, value);\n};\nQueueItem.prototype.otherCallFulfilled = function (value) {\n  unwrap(this.promise, this.onFulfilled, value);\n};\nQueueItem.prototype.callRejected = function (value) {\n  handlers.reject(this.promise, value);\n};\nQueueItem.prototype.otherCallRejected = function (value) {\n  unwrap(this.promise, this.onRejected, value);\n};\n\nfunction unwrap(promise, func, value) {\n  immediate(function () {\n    var returnValue;\n    try {\n      returnValue = func(value);\n    } catch (e) {\n      return handlers.reject(promise, e);\n    }\n    if (returnValue === promise) {\n      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));\n    } else {\n      handlers.resolve(promise, returnValue);\n    }\n  });\n}\n\nhandlers.resolve = function (self, value) {\n  var result = tryCatch(getThen, value);\n  if (result.status === 'error') {\n    return handlers.reject(self, result.value);\n  }\n  var thenable = result.value;\n\n  if (thenable) {\n    safelyResolveThenable(self, thenable);\n  } else {\n    self.state = FULFILLED;\n    self.outcome = value;\n    var i = -1;\n    var len = self.queue.length;\n    while (++i < len) {\n      self.queue[i].callFulfilled(value);\n    }\n  }\n  return self;\n};\nhandlers.reject = function (self, error) {\n  self.state = REJECTED;\n  self.outcome = error;\n  var i = -1;\n  var len = self.queue.length;\n  while (++i < len) {\n    self.queue[i].callRejected(error);\n  }\n  return self;\n};\n\nfunction getThen(obj) {\n  // Make sure we only access the accessor once as required by the spec\n  var then = obj && obj.then;\n  if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {\n    return function appyThen() {\n      then.apply(obj, arguments);\n    };\n  }\n}\n\nfunction safelyResolveThenable(self, thenable) {\n  // Either fulfill, reject or reject with error\n  var called = false;\n  function onError(value) {\n    if (called) {\n      return;\n    }\n    called = true;\n    handlers.reject(self, value);\n  }\n\n  function onSuccess(value) {\n    if (called) {\n      return;\n    }\n    called = true;\n    handlers.resolve(self, value);\n  }\n\n  function tryToUnwrap() {\n    thenable(onSuccess, onError);\n  }\n\n  var result = tryCatch(tryToUnwrap);\n  if (result.status === 'error') {\n    onError(result.value);\n  }\n}\n\nfunction tryCatch(func, value) {\n  var out = {};\n  try {\n    out.value = func(value);\n    out.status = 'success';\n  } catch (e) {\n    out.status = 'error';\n    out.value = e;\n  }\n  return out;\n}\n\nPromise.resolve = resolve;\nfunction resolve(value) {\n  if (value instanceof this) {\n    return value;\n  }\n  return handlers.resolve(new this(INTERNAL), value);\n}\n\nPromise.reject = reject;\nfunction reject(reason) {\n  var promise = new this(INTERNAL);\n  return handlers.reject(promise, reason);\n}\n\nPromise.all = all;\nfunction all(iterable) {\n  var self = this;\n  if (Object.prototype.toString.call(iterable) !== '[object Array]') {\n    return this.reject(new TypeError('must be an array'));\n  }\n\n  var len = iterable.length;\n  var called = false;\n  if (!len) {\n    return this.resolve([]);\n  }\n\n  var values = new Array(len);\n  var resolved = 0;\n  var i = -1;\n  var promise = new this(INTERNAL);\n\n  while (++i < len) {\n    allResolver(iterable[i], i);\n  }\n  return promise;\n  function allResolver(value, i) {\n    self.resolve(value).then(resolveFromAll, function (error) {\n      if (!called) {\n        called = true;\n        handlers.reject(promise, error);\n      }\n    });\n    function resolveFromAll(outValue) {\n      values[i] = outValue;\n      if (++resolved === len && !called) {\n        called = true;\n        handlers.resolve(promise, values);\n      }\n    }\n  }\n}\n\nPromise.race = race;\nfunction race(iterable) {\n  var self = this;\n  if (Object.prototype.toString.call(iterable) !== '[object Array]') {\n    return this.reject(new TypeError('must be an array'));\n  }\n\n  var len = iterable.length;\n  var called = false;\n  if (!len) {\n    return this.resolve([]);\n  }\n\n  var i = -1;\n  var promise = new this(INTERNAL);\n\n  while (++i < len) {\n    resolver(iterable[i]);\n  }\n  return promise;\n  function resolver(value) {\n    self.resolve(value).then(function (response) {\n      if (!called) {\n        called = true;\n        handlers.resolve(promise, response);\n      }\n    }, function (error) {\n      if (!called) {\n        called = true;\n        handlers.reject(promise, error);\n      }\n    });\n  }\n}\n\n},{\"1\":1}],3:[function(_dereq_,module,exports){\n(function (global){\n'use strict';\nif (typeof global.Promise !== 'function') {\n  global.Promise = _dereq_(2);\n}\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{\"2\":2}],4:[function(_dereq_,module,exports){\n'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction getIDB() {\n    /* global indexedDB,webkitIndexedDB,mozIndexedDB,OIndexedDB,msIndexedDB */\n    try {\n        if (typeof indexedDB !== 'undefined') {\n            return indexedDB;\n        }\n        if (typeof webkitIndexedDB !== 'undefined') {\n            return webkitIndexedDB;\n        }\n        if (typeof mozIndexedDB !== 'undefined') {\n            return mozIndexedDB;\n        }\n        if (typeof OIndexedDB !== 'undefined') {\n            return OIndexedDB;\n        }\n        if (typeof msIndexedDB !== 'undefined') {\n            return msIndexedDB;\n        }\n    } catch (e) {\n        return;\n    }\n}\n\nvar idb = getIDB();\n\nfunction isIndexedDBValid() {\n    try {\n        // Initialize IndexedDB; fall back to vendor-prefixed versions\n        // if needed.\n        if (!idb || !idb.open) {\n            return false;\n        }\n        // We mimic PouchDB here;\n        //\n        // We test for openDatabase because IE Mobile identifies itself\n        // as Safari. Oh the lulz...\n        var isSafari = typeof openDatabase !== 'undefined' && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform);\n\n        var hasFetch = typeof fetch === 'function' && fetch.toString().indexOf('[native code') !== -1;\n\n        // Safari <10.1 does not meet our requirements for IDB support\n        // (see: https://github.com/pouchdb/pouchdb/issues/5572).\n        // Safari 10.1 shipped with fetch, we can use that to detect it.\n        // Note: this creates issues with `window.fetch` polyfills and\n        // overrides; see:\n        // https://github.com/localForage/localForage/issues/856\n        return (!isSafari || hasFetch) && typeof indexedDB !== 'undefined' &&\n        // some outdated implementations of IDB that appear on Samsung\n        // and HTC Android devices <4.4 are missing IDBKeyRange\n        // See: https://github.com/mozilla/localForage/issues/128\n        // See: https://github.com/mozilla/localForage/issues/272\n        typeof IDBKeyRange !== 'undefined';\n    } catch (e) {\n        return false;\n    }\n}\n\n// Abstracts constructing a Blob object, so it also works in older\n// browsers that don't support the native Blob constructor. (i.e.\n// old QtWebKit versions, at least).\n// Abstracts constructing a Blob object, so it also works in older\n// browsers that don't support the native Blob constructor. (i.e.\n// old QtWebKit versions, at least).\nfunction createBlob(parts, properties) {\n    /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */\n    parts = parts || [];\n    properties = properties || {};\n    try {\n        return new Blob(parts, properties);\n    } catch (e) {\n        if (e.name !== 'TypeError') {\n            throw e;\n        }\n        var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder : typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder : typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : WebKitBlobBuilder;\n        var builder = new Builder();\n        for (var i = 0; i < parts.length; i += 1) {\n            builder.append(parts[i]);\n        }\n        return builder.getBlob(properties.type);\n    }\n}\n\n// This is CommonJS because lie is an external dependency, so Rollup\n// can just ignore it.\nif (typeof Promise === 'undefined') {\n    // In the \"nopromises\" build this will just throw if you don't have\n    // a global promise object, but it would throw anyway later.\n    _dereq_(3);\n}\nvar Promise$1 = Promise;\n\nfunction executeCallback(promise, callback) {\n    if (callback) {\n        promise.then(function (result) {\n            callback(null, result);\n        }, function (error) {\n            callback(error);\n        });\n    }\n}\n\nfunction executeTwoCallbacks(promise, callback, errorCallback) {\n    if (typeof callback === 'function') {\n        promise.then(callback);\n    }\n\n    if (typeof errorCallback === 'function') {\n        promise[\"catch\"](errorCallback);\n    }\n}\n\nfunction normalizeKey(key) {\n    // Cast the key to a string, as that's all we can set as a key.\n    if (typeof key !== 'string') {\n        console.warn(key + ' used as a key, but it is not a string.');\n        key = String(key);\n    }\n\n    return key;\n}\n\nfunction getCallback() {\n    if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {\n        return arguments[arguments.length - 1];\n    }\n}\n\n// Some code originally from async_storage.js in\n// [Gaia](https://github.com/mozilla-b2g/gaia).\n\nvar DETECT_BLOB_SUPPORT_STORE = 'local-forage-detect-blob-support';\nvar supportsBlobs = void 0;\nvar dbContexts = {};\nvar toString = Object.prototype.toString;\n\n// Transaction Modes\nvar READ_ONLY = 'readonly';\nvar READ_WRITE = 'readwrite';\n\n// Transform a binary string to an array buffer, because otherwise\n// weird stuff happens when you try to work with the binary string directly.\n// It is known.\n// From http://stackoverflow.com/questions/14967647/ (continues on next line)\n// encode-decode-image-with-base64-breaks-image (2013-04-21)\nfunction _binStringToArrayBuffer(bin) {\n    var length = bin.length;\n    var buf = new ArrayBuffer(length);\n    var arr = new Uint8Array(buf);\n    for (var i = 0; i < length; i++) {\n        arr[i] = bin.charCodeAt(i);\n    }\n    return buf;\n}\n\n//\n// Blobs are not supported in all versions of IndexedDB, notably\n// Chrome <37 and Android <5. In those versions, storing a blob will throw.\n//\n// Various other blob bugs exist in Chrome v37-42 (inclusive).\n// Detecting them is expensive and confusing to users, and Chrome 37-42\n// is at very low usage worldwide, so we do a hacky userAgent check instead.\n//\n// content-type bug: https://code.google.com/p/chromium/issues/detail?id=408120\n// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916\n// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836\n//\n// Code borrowed from PouchDB. See:\n// https://github.com/pouchdb/pouchdb/blob/master/packages/node_modules/pouchdb-adapter-idb/src/blobSupport.js\n//\nfunction _checkBlobSupportWithoutCaching(idb) {\n    return new Promise$1(function (resolve) {\n        var txn = idb.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE);\n        var blob = createBlob(['']);\n        txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');\n\n        txn.onabort = function (e) {\n            // If the transaction aborts now its due to not being able to\n            // write to the database, likely due to the disk being full\n            e.preventDefault();\n            e.stopPropagation();\n            resolve(false);\n        };\n\n        txn.oncomplete = function () {\n            var matchedChrome = navigator.userAgent.match(/Chrome\\/(\\d+)/);\n            var matchedEdge = navigator.userAgent.match(/Edge\\//);\n            // MS Edge pretends to be Chrome 42:\n            // https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx\n            resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43);\n        };\n    })[\"catch\"](function () {\n        return false; // error, so assume unsupported\n    });\n}\n\nfunction _checkBlobSupport(idb) {\n    if (typeof supportsBlobs === 'boolean') {\n        return Promise$1.resolve(supportsBlobs);\n    }\n    return _checkBlobSupportWithoutCaching(idb).then(function (value) {\n        supportsBlobs = value;\n        return supportsBlobs;\n    });\n}\n\nfunction _deferReadiness(dbInfo) {\n    var dbContext = dbContexts[dbInfo.name];\n\n    // Create a deferred object representing the current database operation.\n    var deferredOperation = {};\n\n    deferredOperation.promise = new Promise$1(function (resolve, reject) {\n        deferredOperation.resolve = resolve;\n        deferredOperation.reject = reject;\n    });\n\n    // Enqueue the deferred operation.\n    dbContext.deferredOperations.push(deferredOperation);\n\n    // Chain its promise to the database readiness.\n    if (!dbContext.dbReady) {\n        dbContext.dbReady = deferredOperation.promise;\n    } else {\n        dbContext.dbReady = dbContext.dbReady.then(function () {\n            return deferredOperation.promise;\n        });\n    }\n}\n\nfunction _advanceReadiness(dbInfo) {\n    var dbContext = dbContexts[dbInfo.name];\n\n    // Dequeue a deferred operation.\n    var deferredOperation = dbContext.deferredOperations.pop();\n\n    // Resolve its promise (which is part of the database readiness\n    // chain of promises).\n    if (deferredOperation) {\n        deferredOperation.resolve();\n        return deferredOperation.promise;\n    }\n}\n\nfunction _rejectReadiness(dbInfo, err) {\n    var dbContext = dbContexts[dbInfo.name];\n\n    // Dequeue a deferred operation.\n    var deferredOperation = dbContext.deferredOperations.pop();\n\n    // Reject its promise (which is part of the database readiness\n    // chain of promises).\n    if (deferredOperation) {\n        deferredOperation.reject(err);\n        return deferredOperation.promise;\n    }\n}\n\nfunction _getConnection(dbInfo, upgradeNeeded) {\n    return new Promise$1(function (resolve, reject) {\n        dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext();\n\n        if (dbInfo.db) {\n            if (upgradeNeeded) {\n                _deferReadiness(dbInfo);\n                dbInfo.db.close();\n            } else {\n                return resolve(dbInfo.db);\n            }\n        }\n\n        var dbArgs = [dbInfo.name];\n\n        if (upgradeNeeded) {\n            dbArgs.push(dbInfo.version);\n        }\n\n        var openreq = idb.open.apply(idb, dbArgs);\n\n        if (upgradeNeeded) {\n            openreq.onupgradeneeded = function (e) {\n                var db = openreq.result;\n                try {\n                    db.createObjectStore(dbInfo.storeName);\n                    if (e.oldVersion <= 1) {\n                        // Added when support for blob shims was added\n                        db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);\n                    }\n                } catch (ex) {\n                    if (ex.name === 'ConstraintError') {\n                        console.warn('The database \"' + dbInfo.name + '\"' + ' has been upgraded from version ' + e.oldVersion + ' to version ' + e.newVersion + ', but the storage \"' + dbInfo.storeName + '\" already exists.');\n                    } else {\n                        throw ex;\n                    }\n                }\n            };\n        }\n\n        openreq.onerror = function (e) {\n            e.preventDefault();\n            reject(openreq.error);\n        };\n\n        openreq.onsuccess = function () {\n            var db = openreq.result;\n            db.onversionchange = function (e) {\n                // Triggered when the database is modified (e.g. adding an objectStore) or\n                // deleted (even when initiated by other sessions in different tabs).\n                // Closing the connection here prevents those operations from being blocked.\n                // If the database is accessed again later by this instance, the connection\n                // will be reopened or the database recreated as needed.\n                e.target.close();\n            };\n            resolve(db);\n            _advanceReadiness(dbInfo);\n        };\n    });\n}\n\nfunction _getOriginalConnection(dbInfo) {\n    return _getConnection(dbInfo, false);\n}\n\nfunction _getUpgradedConnection(dbInfo) {\n    return _getConnection(dbInfo, true);\n}\n\nfunction _isUpgradeNeeded(dbInfo, defaultVersion) {\n    if (!dbInfo.db) {\n        return true;\n    }\n\n    var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName);\n    var isDowngrade = dbInfo.version < dbInfo.db.version;\n    var isUpgrade = dbInfo.version > dbInfo.db.version;\n\n    if (isDowngrade) {\n        // If the version is not the default one\n        // then warn for impossible downgrade.\n        if (dbInfo.version !== defaultVersion) {\n            console.warn('The database \"' + dbInfo.name + '\"' + \" can't be downgraded from version \" + dbInfo.db.version + ' to version ' + dbInfo.version + '.');\n        }\n        // Align the versions to prevent errors.\n        dbInfo.version = dbInfo.db.version;\n    }\n\n    if (isUpgrade || isNewStore) {\n        // If the store is new then increment the version (if needed).\n        // This will trigger an \"upgradeneeded\" event which is required\n        // for creating a store.\n        if (isNewStore) {\n            var incVersion = dbInfo.db.version + 1;\n            if (incVersion > dbInfo.version) {\n                dbInfo.version = incVersion;\n            }\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n// encode a blob for indexeddb engines that don't support blobs\nfunction _encodeBlob(blob) {\n    return new Promise$1(function (resolve, reject) {\n        var reader = new FileReader();\n        reader.onerror = reject;\n        reader.onloadend = function (e) {\n            var base64 = btoa(e.target.result || '');\n            resolve({\n                __local_forage_encoded_blob: true,\n                data: base64,\n                type: blob.type\n            });\n        };\n        reader.readAsBinaryString(blob);\n    });\n}\n\n// decode an encoded blob\nfunction _decodeBlob(encodedBlob) {\n    var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data));\n    return createBlob([arrayBuff], { type: encodedBlob.type });\n}\n\n// is this one of our fancy encoded blobs?\nfunction _isEncodedBlob(value) {\n    return value && value.__local_forage_encoded_blob;\n}\n\n// Specialize the default `ready()` function by making it dependent\n// on the current database operations. Thus, the driver will be actually\n// ready when it's been initialized (default) *and* there are no pending\n// operations on the database (initiated by some other instances).\nfunction _fullyReady(callback) {\n    var self = this;\n\n    var promise = self._initReady().then(function () {\n        var dbContext = dbContexts[self._dbInfo.name];\n\n        if (dbContext && dbContext.dbReady) {\n            return dbContext.dbReady;\n        }\n    });\n\n    executeTwoCallbacks(promise, callback, callback);\n    return promise;\n}\n\n// Try to establish a new db connection to replace the\n// current one which is broken (i.e. experiencing\n// InvalidStateError while creating a transaction).\nfunction _tryReconnect(dbInfo) {\n    _deferReadiness(dbInfo);\n\n    var dbContext = dbContexts[dbInfo.name];\n    var forages = dbContext.forages;\n\n    for (var i = 0; i < forages.length; i++) {\n        var forage = forages[i];\n        if (forage._dbInfo.db) {\n            forage._dbInfo.db.close();\n            forage._dbInfo.db = null;\n        }\n    }\n    dbInfo.db = null;\n\n    return _getOriginalConnection(dbInfo).then(function (db) {\n        dbInfo.db = db;\n        if (_isUpgradeNeeded(dbInfo)) {\n            // Reopen the database for upgrading.\n            return _getUpgradedConnection(dbInfo);\n        }\n        return db;\n    }).then(function (db) {\n        // store the latest db reference\n        // in case the db was upgraded\n        dbInfo.db = dbContext.db = db;\n        for (var i = 0; i < forages.length; i++) {\n            forages[i]._dbInfo.db = db;\n        }\n    })[\"catch\"](function (err) {\n        _rejectReadiness(dbInfo, err);\n        throw err;\n    });\n}\n\n// FF doesn't like Promises (micro-tasks) and IDDB store operations,\n// so we have to do it with callbacks\nfunction createTransaction(dbInfo, mode, callback, retries) {\n    if (retries === undefined) {\n        retries = 1;\n    }\n\n    try {\n        var tx = dbInfo.db.transaction(dbInfo.storeName, mode);\n        callback(null, tx);\n    } catch (err) {\n        if (retries > 0 && (!dbInfo.db || err.name === 'InvalidStateError' || err.name === 'NotFoundError')) {\n            return Promise$1.resolve().then(function () {\n                if (!dbInfo.db || err.name === 'NotFoundError' && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) {\n                    // increase the db version, to create the new ObjectStore\n                    if (dbInfo.db) {\n                        dbInfo.version = dbInfo.db.version + 1;\n                    }\n                    // Reopen the database for upgrading.\n                    return _getUpgradedConnection(dbInfo);\n                }\n            }).then(function () {\n                return _tryReconnect(dbInfo).then(function () {\n                    createTransaction(dbInfo, mode, callback, retries - 1);\n                });\n            })[\"catch\"](callback);\n        }\n\n        callback(err);\n    }\n}\n\nfunction createDbContext() {\n    return {\n        // Running localForages sharing a database.\n        forages: [],\n        // Shared database.\n        db: null,\n        // Database readiness (promise).\n        dbReady: null,\n        // Deferred operations on the database.\n        deferredOperations: []\n    };\n}\n\n// Open the IndexedDB database (automatically creates one if one didn't\n// previously exist), using any options set in the config.\nfunction _initStorage(options) {\n    var self = this;\n    var dbInfo = {\n        db: null\n    };\n\n    if (options) {\n        for (var i in options) {\n            dbInfo[i] = options[i];\n        }\n    }\n\n    // Get the current context of the database;\n    var dbContext = dbContexts[dbInfo.name];\n\n    // ...or create a new context.\n    if (!dbContext) {\n        dbContext = createDbContext();\n        // Register the new context in the global container.\n        dbContexts[dbInfo.name] = dbContext;\n    }\n\n    // Register itself as a running localForage in the current context.\n    dbContext.forages.push(self);\n\n    // Replace the default `ready()` function with the specialized one.\n    if (!self._initReady) {\n        self._initReady = self.ready;\n        self.ready = _fullyReady;\n    }\n\n    // Create an array of initialization states of the related localForages.\n    var initPromises = [];\n\n    function ignoreErrors() {\n        // Don't handle errors here,\n        // just makes sure related localForages aren't pending.\n        return Promise$1.resolve();\n    }\n\n    for (var j = 0; j < dbContext.forages.length; j++) {\n        var forage = dbContext.forages[j];\n        if (forage !== self) {\n            // Don't wait for itself...\n            initPromises.push(forage._initReady()[\"catch\"](ignoreErrors));\n        }\n    }\n\n    // Take a snapshot of the related localForages.\n    var forages = dbContext.forages.slice(0);\n\n    // Initialize the connection process only when\n    // all the related localForages aren't pending.\n    return Promise$1.all(initPromises).then(function () {\n        dbInfo.db = dbContext.db;\n        // Get the connection or open a new one without upgrade.\n        return _getOriginalConnection(dbInfo);\n    }).then(function (db) {\n        dbInfo.db = db;\n        if (_isUpgradeNeeded(dbInfo, self._defaultConfig.version)) {\n            // Reopen the database for upgrading.\n            return _getUpgradedConnection(dbInfo);\n        }\n        return db;\n    }).then(function (db) {\n        dbInfo.db = dbContext.db = db;\n        self._dbInfo = dbInfo;\n        // Share the final connection amongst related localForages.\n        for (var k = 0; k < forages.length; k++) {\n            var forage = forages[k];\n            if (forage !== self) {\n                // Self is already up-to-date.\n                forage._dbInfo.db = dbInfo.db;\n                forage._dbInfo.version = dbInfo.version;\n            }\n        }\n    });\n}\n\nfunction getItem(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var req = store.get(key);\n\n                    req.onsuccess = function () {\n                        var value = req.result;\n                        if (value === undefined) {\n                            value = null;\n                        }\n                        if (_isEncodedBlob(value)) {\n                            value = _decodeBlob(value);\n                        }\n                        resolve(value);\n                    };\n\n                    req.onerror = function () {\n                        reject(req.error);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Iterate over all items stored in database.\nfunction iterate(iterator, callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var req = store.openCursor();\n                    var iterationNumber = 1;\n\n                    req.onsuccess = function () {\n                        var cursor = req.result;\n\n                        if (cursor) {\n                            var value = cursor.value;\n                            if (_isEncodedBlob(value)) {\n                                value = _decodeBlob(value);\n                            }\n                            var result = iterator(value, cursor.key, iterationNumber++);\n\n                            // when the iterator callback returns any\n                            // (non-`undefined`) value, then we stop\n                            // the iteration immediately\n                            if (result !== void 0) {\n                                resolve(result);\n                            } else {\n                                cursor[\"continue\"]();\n                            }\n                        } else {\n                            resolve();\n                        }\n                    };\n\n                    req.onerror = function () {\n                        reject(req.error);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n\n    return promise;\n}\n\nfunction setItem(key, value, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        var dbInfo;\n        self.ready().then(function () {\n            dbInfo = self._dbInfo;\n            if (toString.call(value) === '[object Blob]') {\n                return _checkBlobSupport(dbInfo.db).then(function (blobSupport) {\n                    if (blobSupport) {\n                        return value;\n                    }\n                    return _encodeBlob(value);\n                });\n            }\n            return value;\n        }).then(function (value) {\n            createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n\n                    // The reason we don't _save_ null is because IE 10 does\n                    // not support saving the `null` type in IndexedDB. How\n                    // ironic, given the bug below!\n                    // See: https://github.com/mozilla/localForage/issues/161\n                    if (value === null) {\n                        value = undefined;\n                    }\n\n                    var req = store.put(value, key);\n\n                    transaction.oncomplete = function () {\n                        // Cast to undefined so the value passed to\n                        // callback/promise is the same as what one would get out\n                        // of `getItem()` later. This leads to some weirdness\n                        // (setItem('foo', undefined) will return `null`), but\n                        // it's not my fault localStorage is our baseline and that\n                        // it's weird.\n                        if (value === undefined) {\n                            value = null;\n                        }\n\n                        resolve(value);\n                    };\n                    transaction.onabort = transaction.onerror = function () {\n                        var err = req.error ? req.error : req.transaction.error;\n                        reject(err);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction removeItem(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    // We use a Grunt task to make this safe for IE and some\n                    // versions of Android (including those used by Cordova).\n                    // Normally IE won't like `.delete()` and will insist on\n                    // using `['delete']()`, but we have a build step that\n                    // fixes this for us now.\n                    var req = store[\"delete\"](key);\n                    transaction.oncomplete = function () {\n                        resolve();\n                    };\n\n                    transaction.onerror = function () {\n                        reject(req.error);\n                    };\n\n                    // The request will be also be aborted if we've exceeded our storage\n                    // space.\n                    transaction.onabort = function () {\n                        var err = req.error ? req.error : req.transaction.error;\n                        reject(err);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction clear(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var req = store.clear();\n\n                    transaction.oncomplete = function () {\n                        resolve();\n                    };\n\n                    transaction.onabort = transaction.onerror = function () {\n                        var err = req.error ? req.error : req.transaction.error;\n                        reject(err);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction length(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var req = store.count();\n\n                    req.onsuccess = function () {\n                        resolve(req.result);\n                    };\n\n                    req.onerror = function () {\n                        reject(req.error);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction key(n, callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        if (n < 0) {\n            resolve(null);\n\n            return;\n        }\n\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var advanced = false;\n                    var req = store.openKeyCursor();\n\n                    req.onsuccess = function () {\n                        var cursor = req.result;\n                        if (!cursor) {\n                            // this means there weren't enough keys\n                            resolve(null);\n\n                            return;\n                        }\n\n                        if (n === 0) {\n                            // We have the first key, return it if that's what they\n                            // wanted.\n                            resolve(cursor.key);\n                        } else {\n                            if (!advanced) {\n                                // Otherwise, ask the cursor to skip ahead n\n                                // records.\n                                advanced = true;\n                                cursor.advance(n);\n                            } else {\n                                // When we get here, we've got the nth key.\n                                resolve(cursor.key);\n                            }\n                        }\n                    };\n\n                    req.onerror = function () {\n                        reject(req.error);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction keys(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {\n                if (err) {\n                    return reject(err);\n                }\n\n                try {\n                    var store = transaction.objectStore(self._dbInfo.storeName);\n                    var req = store.openKeyCursor();\n                    var keys = [];\n\n                    req.onsuccess = function () {\n                        var cursor = req.result;\n\n                        if (!cursor) {\n                            resolve(keys);\n                            return;\n                        }\n\n                        keys.push(cursor.key);\n                        cursor[\"continue\"]();\n                    };\n\n                    req.onerror = function () {\n                        reject(req.error);\n                    };\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction dropInstance(options, callback) {\n    callback = getCallback.apply(this, arguments);\n\n    var currentConfig = this.config();\n    options = typeof options !== 'function' && options || {};\n    if (!options.name) {\n        options.name = options.name || currentConfig.name;\n        options.storeName = options.storeName || currentConfig.storeName;\n    }\n\n    var self = this;\n    var promise;\n    if (!options.name) {\n        promise = Promise$1.reject('Invalid arguments');\n    } else {\n        var isCurrentDb = options.name === currentConfig.name && self._dbInfo.db;\n\n        var dbPromise = isCurrentDb ? Promise$1.resolve(self._dbInfo.db) : _getOriginalConnection(options).then(function (db) {\n            var dbContext = dbContexts[options.name];\n            var forages = dbContext.forages;\n            dbContext.db = db;\n            for (var i = 0; i < forages.length; i++) {\n                forages[i]._dbInfo.db = db;\n            }\n            return db;\n        });\n\n        if (!options.storeName) {\n            promise = dbPromise.then(function (db) {\n                _deferReadiness(options);\n\n                var dbContext = dbContexts[options.name];\n                var forages = dbContext.forages;\n\n                db.close();\n                for (var i = 0; i < forages.length; i++) {\n                    var forage = forages[i];\n                    forage._dbInfo.db = null;\n                }\n\n                var dropDBPromise = new Promise$1(function (resolve, reject) {\n                    var req = idb.deleteDatabase(options.name);\n\n                    req.onerror = function () {\n                        var db = req.result;\n                        if (db) {\n                            db.close();\n                        }\n                        reject(req.error);\n                    };\n\n                    req.onblocked = function () {\n                        // Closing all open connections in onversionchange handler should prevent this situation, but if\n                        // we do get here, it just means the request remains pending - eventually it will succeed or error\n                        console.warn('dropInstance blocked for database \"' + options.name + '\" until all open connections are closed');\n                    };\n\n                    req.onsuccess = function () {\n                        var db = req.result;\n                        if (db) {\n                            db.close();\n                        }\n                        resolve(db);\n                    };\n                });\n\n                return dropDBPromise.then(function (db) {\n                    dbContext.db = db;\n                    for (var i = 0; i < forages.length; i++) {\n                        var _forage = forages[i];\n                        _advanceReadiness(_forage._dbInfo);\n                    }\n                })[\"catch\"](function (err) {\n                    (_rejectReadiness(options, err) || Promise$1.resolve())[\"catch\"](function () {});\n                    throw err;\n                });\n            });\n        } else {\n            promise = dbPromise.then(function (db) {\n                if (!db.objectStoreNames.contains(options.storeName)) {\n                    return;\n                }\n\n                var newVersion = db.version + 1;\n\n                _deferReadiness(options);\n\n                var dbContext = dbContexts[options.name];\n                var forages = dbContext.forages;\n\n                db.close();\n                for (var i = 0; i < forages.length; i++) {\n                    var forage = forages[i];\n                    forage._dbInfo.db = null;\n                    forage._dbInfo.version = newVersion;\n                }\n\n                var dropObjectPromise = new Promise$1(function (resolve, reject) {\n                    var req = idb.open(options.name, newVersion);\n\n                    req.onerror = function (err) {\n                        var db = req.result;\n                        db.close();\n                        reject(err);\n                    };\n\n                    req.onupgradeneeded = function () {\n                        var db = req.result;\n                        db.deleteObjectStore(options.storeName);\n                    };\n\n                    req.onsuccess = function () {\n                        var db = req.result;\n                        db.close();\n                        resolve(db);\n                    };\n                });\n\n                return dropObjectPromise.then(function (db) {\n                    dbContext.db = db;\n                    for (var j = 0; j < forages.length; j++) {\n                        var _forage2 = forages[j];\n                        _forage2._dbInfo.db = db;\n                        _advanceReadiness(_forage2._dbInfo);\n                    }\n                })[\"catch\"](function (err) {\n                    (_rejectReadiness(options, err) || Promise$1.resolve())[\"catch\"](function () {});\n                    throw err;\n                });\n            });\n        }\n    }\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nvar asyncStorage = {\n    _driver: 'asyncStorage',\n    _initStorage: _initStorage,\n    _support: isIndexedDBValid(),\n    iterate: iterate,\n    getItem: getItem,\n    setItem: setItem,\n    removeItem: removeItem,\n    clear: clear,\n    length: length,\n    key: key,\n    keys: keys,\n    dropInstance: dropInstance\n};\n\nfunction isWebSQLValid() {\n    return typeof openDatabase === 'function';\n}\n\n// Sadly, the best way to save binary data in WebSQL/localStorage is serializing\n// it to Base64, so this is how we store it to prevent very strange errors with less\n// verbose ways of binary <-> string data storage.\nvar BASE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nvar BLOB_TYPE_PREFIX = '~~local_forage_type~';\nvar BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;\n\nvar SERIALIZED_MARKER = '__lfsc__:';\nvar SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length;\n\n// OMG the serializations!\nvar TYPE_ARRAYBUFFER = 'arbf';\nvar TYPE_BLOB = 'blob';\nvar TYPE_INT8ARRAY = 'si08';\nvar TYPE_UINT8ARRAY = 'ui08';\nvar TYPE_UINT8CLAMPEDARRAY = 'uic8';\nvar TYPE_INT16ARRAY = 'si16';\nvar TYPE_INT32ARRAY = 'si32';\nvar TYPE_UINT16ARRAY = 'ur16';\nvar TYPE_UINT32ARRAY = 'ui32';\nvar TYPE_FLOAT32ARRAY = 'fl32';\nvar TYPE_FLOAT64ARRAY = 'fl64';\nvar TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length;\n\nvar toString$1 = Object.prototype.toString;\n\nfunction stringToBuffer(serializedString) {\n    // Fill the string into a ArrayBuffer.\n    var bufferLength = serializedString.length * 0.75;\n    var len = serializedString.length;\n    var i;\n    var p = 0;\n    var encoded1, encoded2, encoded3, encoded4;\n\n    if (serializedString[serializedString.length - 1] === '=') {\n        bufferLength--;\n        if (serializedString[serializedString.length - 2] === '=') {\n            bufferLength--;\n        }\n    }\n\n    var buffer = new ArrayBuffer(bufferLength);\n    var bytes = new Uint8Array(buffer);\n\n    for (i = 0; i < len; i += 4) {\n        encoded1 = BASE_CHARS.indexOf(serializedString[i]);\n        encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]);\n        encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]);\n        encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]);\n\n        /*jslint bitwise: true */\n        bytes[p++] = encoded1 << 2 | encoded2 >> 4;\n        bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;\n        bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;\n    }\n    return buffer;\n}\n\n// Converts a buffer to a string to store, serialized, in the backend\n// storage library.\nfunction bufferToString(buffer) {\n    // base64-arraybuffer\n    var bytes = new Uint8Array(buffer);\n    var base64String = '';\n    var i;\n\n    for (i = 0; i < bytes.length; i += 3) {\n        /*jslint bitwise: true */\n        base64String += BASE_CHARS[bytes[i] >> 2];\n        base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];\n        base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];\n        base64String += BASE_CHARS[bytes[i + 2] & 63];\n    }\n\n    if (bytes.length % 3 === 2) {\n        base64String = base64String.substring(0, base64String.length - 1) + '=';\n    } else if (bytes.length % 3 === 1) {\n        base64String = base64String.substring(0, base64String.length - 2) + '==';\n    }\n\n    return base64String;\n}\n\n// Serialize a value, afterwards executing a callback (which usually\n// instructs the `setItem()` callback/promise to be executed). This is how\n// we store binary data with localStorage.\nfunction serialize(value, callback) {\n    var valueType = '';\n    if (value) {\n        valueType = toString$1.call(value);\n    }\n\n    // Cannot use `value instanceof ArrayBuffer` or such here, as these\n    // checks fail when running the tests using casper.js...\n    //\n    // TODO: See why those tests fail and use a better solution.\n    if (value && (valueType === '[object ArrayBuffer]' || value.buffer && toString$1.call(value.buffer) === '[object ArrayBuffer]')) {\n        // Convert binary arrays to a string and prefix the string with\n        // a special marker.\n        var buffer;\n        var marker = SERIALIZED_MARKER;\n\n        if (value instanceof ArrayBuffer) {\n            buffer = value;\n            marker += TYPE_ARRAYBUFFER;\n        } else {\n            buffer = value.buffer;\n\n            if (valueType === '[object Int8Array]') {\n                marker += TYPE_INT8ARRAY;\n            } else if (valueType === '[object Uint8Array]') {\n                marker += TYPE_UINT8ARRAY;\n            } else if (valueType === '[object Uint8ClampedArray]') {\n                marker += TYPE_UINT8CLAMPEDARRAY;\n            } else if (valueType === '[object Int16Array]') {\n                marker += TYPE_INT16ARRAY;\n            } else if (valueType === '[object Uint16Array]') {\n                marker += TYPE_UINT16ARRAY;\n            } else if (valueType === '[object Int32Array]') {\n                marker += TYPE_INT32ARRAY;\n            } else if (valueType === '[object Uint32Array]') {\n                marker += TYPE_UINT32ARRAY;\n            } else if (valueType === '[object Float32Array]') {\n                marker += TYPE_FLOAT32ARRAY;\n            } else if (valueType === '[object Float64Array]') {\n                marker += TYPE_FLOAT64ARRAY;\n            } else {\n                callback(new Error('Failed to get type for BinaryArray'));\n            }\n        }\n\n        callback(marker + bufferToString(buffer));\n    } else if (valueType === '[object Blob]') {\n        // Conver the blob to a binaryArray and then to a string.\n        var fileReader = new FileReader();\n\n        fileReader.onload = function () {\n            // Backwards-compatible prefix for the blob type.\n            var str = BLOB_TYPE_PREFIX + value.type + '~' + bufferToString(this.result);\n\n            callback(SERIALIZED_MARKER + TYPE_BLOB + str);\n        };\n\n        fileReader.readAsArrayBuffer(value);\n    } else {\n        try {\n            callback(JSON.stringify(value));\n        } catch (e) {\n            console.error(\"Couldn't convert value into a JSON string: \", value);\n\n            callback(null, e);\n        }\n    }\n}\n\n// Deserialize data we've inserted into a value column/field. We place\n// special markers into our strings to mark them as encoded; this isn't\n// as nice as a meta field, but it's the only sane thing we can do whilst\n// keeping localStorage support intact.\n//\n// Oftentimes this will just deserialize JSON content, but if we have a\n// special marker (SERIALIZED_MARKER, defined above), we will extract\n// some kind of arraybuffer/binary data/typed array out of the string.\nfunction deserialize(value) {\n    // If we haven't marked this string as being specially serialized (i.e.\n    // something other than serialized JSON), we can just return it and be\n    // done with it.\n    if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) {\n        return JSON.parse(value);\n    }\n\n    // The following code deals with deserializing some kind of Blob or\n    // TypedArray. First we separate out the type of data we're dealing\n    // with from the data itself.\n    var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);\n    var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH);\n\n    var blobType;\n    // Backwards-compatible blob type serialization strategy.\n    // DBs created with older versions of localForage will simply not have the blob type.\n    if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {\n        var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);\n        blobType = matcher[1];\n        serializedString = serializedString.substring(matcher[0].length);\n    }\n    var buffer = stringToBuffer(serializedString);\n\n    // Return the right type based on the code/type set during\n    // serialization.\n    switch (type) {\n        case TYPE_ARRAYBUFFER:\n            return buffer;\n        case TYPE_BLOB:\n            return createBlob([buffer], { type: blobType });\n        case TYPE_INT8ARRAY:\n            return new Int8Array(buffer);\n        case TYPE_UINT8ARRAY:\n            return new Uint8Array(buffer);\n        case TYPE_UINT8CLAMPEDARRAY:\n            return new Uint8ClampedArray(buffer);\n        case TYPE_INT16ARRAY:\n            return new Int16Array(buffer);\n        case TYPE_UINT16ARRAY:\n            return new Uint16Array(buffer);\n        case TYPE_INT32ARRAY:\n            return new Int32Array(buffer);\n        case TYPE_UINT32ARRAY:\n            return new Uint32Array(buffer);\n        case TYPE_FLOAT32ARRAY:\n            return new Float32Array(buffer);\n        case TYPE_FLOAT64ARRAY:\n            return new Float64Array(buffer);\n        default:\n            throw new Error('Unkown type: ' + type);\n    }\n}\n\nvar localforageSerializer = {\n    serialize: serialize,\n    deserialize: deserialize,\n    stringToBuffer: stringToBuffer,\n    bufferToString: bufferToString\n};\n\n/*\n * Includes code from:\n *\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n\nfunction createDbTable(t, dbInfo, callback, errorCallback) {\n    t.executeSql('CREATE TABLE IF NOT EXISTS ' + dbInfo.storeName + ' ' + '(id INTEGER PRIMARY KEY, key unique, value)', [], callback, errorCallback);\n}\n\n// Open the WebSQL database (automatically creates one if one didn't\n// previously exist), using any options set in the config.\nfunction _initStorage$1(options) {\n    var self = this;\n    var dbInfo = {\n        db: null\n    };\n\n    if (options) {\n        for (var i in options) {\n            dbInfo[i] = typeof options[i] !== 'string' ? options[i].toString() : options[i];\n        }\n    }\n\n    var dbInfoPromise = new Promise$1(function (resolve, reject) {\n        // Open the database; the openDatabase API will automatically\n        // create it for us if it doesn't exist.\n        try {\n            dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size);\n        } catch (e) {\n            return reject(e);\n        }\n\n        // Create our key/value table if it doesn't exist.\n        dbInfo.db.transaction(function (t) {\n            createDbTable(t, dbInfo, function () {\n                self._dbInfo = dbInfo;\n                resolve();\n            }, function (t, error) {\n                reject(error);\n            });\n        }, reject);\n    });\n\n    dbInfo.serializer = localforageSerializer;\n    return dbInfoPromise;\n}\n\nfunction tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) {\n    t.executeSql(sqlStatement, args, callback, function (t, error) {\n        if (error.code === error.SYNTAX_ERR) {\n            t.executeSql('SELECT name FROM sqlite_master ' + \"WHERE type='table' AND name = ?\", [dbInfo.storeName], function (t, results) {\n                if (!results.rows.length) {\n                    // if the table is missing (was deleted)\n                    // re-create it table and retry\n                    createDbTable(t, dbInfo, function () {\n                        t.executeSql(sqlStatement, args, callback, errorCallback);\n                    }, errorCallback);\n                } else {\n                    errorCallback(t, error);\n                }\n            }, errorCallback);\n        } else {\n            errorCallback(t, error);\n        }\n    }, errorCallback);\n}\n\nfunction getItem$1(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName + ' WHERE key = ? LIMIT 1', [key], function (t, results) {\n                    var result = results.rows.length ? results.rows.item(0).value : null;\n\n                    // Check to see if this is serialized content we need to\n                    // unpack.\n                    if (result) {\n                        result = dbInfo.serializer.deserialize(result);\n                    }\n\n                    resolve(result);\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction iterate$1(iterator, callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName, [], function (t, results) {\n                    var rows = results.rows;\n                    var length = rows.length;\n\n                    for (var i = 0; i < length; i++) {\n                        var item = rows.item(i);\n                        var result = item.value;\n\n                        // Check to see if this is serialized content\n                        // we need to unpack.\n                        if (result) {\n                            result = dbInfo.serializer.deserialize(result);\n                        }\n\n                        result = iterator(result, item.key, i + 1);\n\n                        // void(0) prevents problems with redefinition\n                        // of `undefined`.\n                        if (result !== void 0) {\n                            resolve(result);\n                            return;\n                        }\n                    }\n\n                    resolve();\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction _setItem(key, value, callback, retriesLeft) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            // The localStorage API doesn't return undefined values in an\n            // \"expected\" way, so undefined is always cast to null in all\n            // drivers. See: https://github.com/mozilla/localForage/pull/42\n            if (value === undefined) {\n                value = null;\n            }\n\n            // Save the original value to pass to the callback.\n            var originalValue = value;\n\n            var dbInfo = self._dbInfo;\n            dbInfo.serializer.serialize(value, function (value, error) {\n                if (error) {\n                    reject(error);\n                } else {\n                    dbInfo.db.transaction(function (t) {\n                        tryExecuteSql(t, dbInfo, 'INSERT OR REPLACE INTO ' + dbInfo.storeName + ' ' + '(key, value) VALUES (?, ?)', [key, value], function () {\n                            resolve(originalValue);\n                        }, function (t, error) {\n                            reject(error);\n                        });\n                    }, function (sqlError) {\n                        // The transaction failed; check\n                        // to see if it's a quota error.\n                        if (sqlError.code === sqlError.QUOTA_ERR) {\n                            // We reject the callback outright for now, but\n                            // it's worth trying to re-run the transaction.\n                            // Even if the user accepts the prompt to use\n                            // more storage on Safari, this error will\n                            // be called.\n                            //\n                            // Try to re-run the transaction.\n                            if (retriesLeft > 0) {\n                                resolve(_setItem.apply(self, [key, originalValue, callback, retriesLeft - 1]));\n                                return;\n                            }\n                            reject(sqlError);\n                        }\n                    });\n                }\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction setItem$1(key, value, callback) {\n    return _setItem.apply(this, [key, value, callback, 1]);\n}\n\nfunction removeItem$1(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName + ' WHERE key = ?', [key], function () {\n                    resolve();\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Deletes every item in the table.\n// TODO: Find out if this resets the AUTO_INCREMENT number.\nfunction clear$1(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName, [], function () {\n                    resolve();\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Does a simple `COUNT(key)` to get the number of items stored in\n// localForage.\nfunction length$1(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                // Ahhh, SQL makes this one soooooo easy.\n                tryExecuteSql(t, dbInfo, 'SELECT COUNT(key) as c FROM ' + dbInfo.storeName, [], function (t, results) {\n                    var result = results.rows.item(0).c;\n                    resolve(result);\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Return the key located at key index X; essentially gets the key from a\n// `WHERE id = ?`. This is the most efficient way I can think to implement\n// this rarely-used (in my experience) part of the API, but it can seem\n// inconsistent, because we do `INSERT OR REPLACE INTO` on `setItem()`, so\n// the ID of each key will change every time it's updated. Perhaps a stored\n// procedure for the `setItem()` SQL would solve this problem?\n// TODO: Don't change ID on `setItem()`.\nfunction key$1(n, callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName + ' WHERE id = ? LIMIT 1', [n + 1], function (t, results) {\n                    var result = results.rows.length ? results.rows.item(0).key : null;\n                    resolve(result);\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction keys$1(callback) {\n    var self = this;\n\n    var promise = new Promise$1(function (resolve, reject) {\n        self.ready().then(function () {\n            var dbInfo = self._dbInfo;\n            dbInfo.db.transaction(function (t) {\n                tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName, [], function (t, results) {\n                    var keys = [];\n\n                    for (var i = 0; i < results.rows.length; i++) {\n                        keys.push(results.rows.item(i).key);\n                    }\n\n                    resolve(keys);\n                }, function (t, error) {\n                    reject(error);\n                });\n            });\n        })[\"catch\"](reject);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// https://www.w3.org/TR/webdatabase/#databases\n// > There is no way to enumerate or delete the databases available for an origin from this API.\nfunction getAllStoreNames(db) {\n    return new Promise$1(function (resolve, reject) {\n        db.transaction(function (t) {\n            t.executeSql('SELECT name FROM sqlite_master ' + \"WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'\", [], function (t, results) {\n                var storeNames = [];\n\n                for (var i = 0; i < results.rows.length; i++) {\n                    storeNames.push(results.rows.item(i).name);\n                }\n\n                resolve({\n                    db: db,\n                    storeNames: storeNames\n                });\n            }, function (t, error) {\n                reject(error);\n            });\n        }, function (sqlError) {\n            reject(sqlError);\n        });\n    });\n}\n\nfunction dropInstance$1(options, callback) {\n    callback = getCallback.apply(this, arguments);\n\n    var currentConfig = this.config();\n    options = typeof options !== 'function' && options || {};\n    if (!options.name) {\n        options.name = options.name || currentConfig.name;\n        options.storeName = options.storeName || currentConfig.storeName;\n    }\n\n    var self = this;\n    var promise;\n    if (!options.name) {\n        promise = Promise$1.reject('Invalid arguments');\n    } else {\n        promise = new Promise$1(function (resolve) {\n            var db;\n            if (options.name === currentConfig.name) {\n                // use the db reference of the current instance\n                db = self._dbInfo.db;\n            } else {\n                db = openDatabase(options.name, '', '', 0);\n            }\n\n            if (!options.storeName) {\n                // drop all database tables\n                resolve(getAllStoreNames(db));\n            } else {\n                resolve({\n                    db: db,\n                    storeNames: [options.storeName]\n                });\n            }\n        }).then(function (operationInfo) {\n            return new Promise$1(function (resolve, reject) {\n                operationInfo.db.transaction(function (t) {\n                    function dropTable(storeName) {\n                        return new Promise$1(function (resolve, reject) {\n                            t.executeSql('DROP TABLE IF EXISTS ' + storeName, [], function () {\n                                resolve();\n                            }, function (t, error) {\n                                reject(error);\n                            });\n                        });\n                    }\n\n                    var operations = [];\n                    for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) {\n                        operations.push(dropTable(operationInfo.storeNames[i]));\n                    }\n\n                    Promise$1.all(operations).then(function () {\n                        resolve();\n                    })[\"catch\"](function (e) {\n                        reject(e);\n                    });\n                }, function (sqlError) {\n                    reject(sqlError);\n                });\n            });\n        });\n    }\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nvar webSQLStorage = {\n    _driver: 'webSQLStorage',\n    _initStorage: _initStorage$1,\n    _support: isWebSQLValid(),\n    iterate: iterate$1,\n    getItem: getItem$1,\n    setItem: setItem$1,\n    removeItem: removeItem$1,\n    clear: clear$1,\n    length: length$1,\n    key: key$1,\n    keys: keys$1,\n    dropInstance: dropInstance$1\n};\n\nfunction isLocalStorageValid() {\n    try {\n        return typeof localStorage !== 'undefined' && 'setItem' in localStorage &&\n        // in IE8 typeof localStorage.setItem === 'object'\n        !!localStorage.setItem;\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction _getKeyPrefix(options, defaultConfig) {\n    var keyPrefix = options.name + '/';\n\n    if (options.storeName !== defaultConfig.storeName) {\n        keyPrefix += options.storeName + '/';\n    }\n    return keyPrefix;\n}\n\n// Check if localStorage throws when saving an item\nfunction checkIfLocalStorageThrows() {\n    var localStorageTestKey = '_localforage_support_test';\n\n    try {\n        localStorage.setItem(localStorageTestKey, true);\n        localStorage.removeItem(localStorageTestKey);\n\n        return false;\n    } catch (e) {\n        return true;\n    }\n}\n\n// Check if localStorage is usable and allows to save an item\n// This method checks if localStorage is usable in Safari Private Browsing\n// mode, or in any other case where the available quota for localStorage\n// is 0 and there wasn't any saved items yet.\nfunction _isLocalStorageUsable() {\n    return !checkIfLocalStorageThrows() || localStorage.length > 0;\n}\n\n// Config the localStorage backend, using options set in the config.\nfunction _initStorage$2(options) {\n    var self = this;\n    var dbInfo = {};\n    if (options) {\n        for (var i in options) {\n            dbInfo[i] = options[i];\n        }\n    }\n\n    dbInfo.keyPrefix = _getKeyPrefix(options, self._defaultConfig);\n\n    if (!_isLocalStorageUsable()) {\n        return Promise$1.reject();\n    }\n\n    self._dbInfo = dbInfo;\n    dbInfo.serializer = localforageSerializer;\n\n    return Promise$1.resolve();\n}\n\n// Remove all keys from the datastore, effectively destroying all data in\n// the app's key/value store!\nfunction clear$2(callback) {\n    var self = this;\n    var promise = self.ready().then(function () {\n        var keyPrefix = self._dbInfo.keyPrefix;\n\n        for (var i = localStorage.length - 1; i >= 0; i--) {\n            var key = localStorage.key(i);\n\n            if (key.indexOf(keyPrefix) === 0) {\n                localStorage.removeItem(key);\n            }\n        }\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Retrieve an item from the store. Unlike the original async_storage\n// library in Gaia, we don't modify return values at all. If a key's value\n// is `undefined`, we pass that value to the callback function.\nfunction getItem$2(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = self.ready().then(function () {\n        var dbInfo = self._dbInfo;\n        var result = localStorage.getItem(dbInfo.keyPrefix + key);\n\n        // If a result was found, parse it from the serialized\n        // string into a JS object. If result isn't truthy, the key\n        // is likely undefined and we'll pass it straight to the\n        // callback.\n        if (result) {\n            result = dbInfo.serializer.deserialize(result);\n        }\n\n        return result;\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Iterate over all items in the store.\nfunction iterate$2(iterator, callback) {\n    var self = this;\n\n    var promise = self.ready().then(function () {\n        var dbInfo = self._dbInfo;\n        var keyPrefix = dbInfo.keyPrefix;\n        var keyPrefixLength = keyPrefix.length;\n        var length = localStorage.length;\n\n        // We use a dedicated iterator instead of the `i` variable below\n        // so other keys we fetch in localStorage aren't counted in\n        // the `iterationNumber` argument passed to the `iterate()`\n        // callback.\n        //\n        // See: github.com/mozilla/localForage/pull/435#discussion_r38061530\n        var iterationNumber = 1;\n\n        for (var i = 0; i < length; i++) {\n            var key = localStorage.key(i);\n            if (key.indexOf(keyPrefix) !== 0) {\n                continue;\n            }\n            var value = localStorage.getItem(key);\n\n            // If a result was found, parse it from the serialized\n            // string into a JS object. If result isn't truthy, the\n            // key is likely undefined and we'll pass it straight\n            // to the iterator.\n            if (value) {\n                value = dbInfo.serializer.deserialize(value);\n            }\n\n            value = iterator(value, key.substring(keyPrefixLength), iterationNumber++);\n\n            if (value !== void 0) {\n                return value;\n            }\n        }\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Same as localStorage's key() method, except takes a callback.\nfunction key$2(n, callback) {\n    var self = this;\n    var promise = self.ready().then(function () {\n        var dbInfo = self._dbInfo;\n        var result;\n        try {\n            result = localStorage.key(n);\n        } catch (error) {\n            result = null;\n        }\n\n        // Remove the prefix from the key, if a key is found.\n        if (result) {\n            result = result.substring(dbInfo.keyPrefix.length);\n        }\n\n        return result;\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction keys$2(callback) {\n    var self = this;\n    var promise = self.ready().then(function () {\n        var dbInfo = self._dbInfo;\n        var length = localStorage.length;\n        var keys = [];\n\n        for (var i = 0; i < length; i++) {\n            var itemKey = localStorage.key(i);\n            if (itemKey.indexOf(dbInfo.keyPrefix) === 0) {\n                keys.push(itemKey.substring(dbInfo.keyPrefix.length));\n            }\n        }\n\n        return keys;\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Supply the number of keys in the datastore to the callback function.\nfunction length$2(callback) {\n    var self = this;\n    var promise = self.keys().then(function (keys) {\n        return keys.length;\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Remove an item from the store, nice and simple.\nfunction removeItem$2(key, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = self.ready().then(function () {\n        var dbInfo = self._dbInfo;\n        localStorage.removeItem(dbInfo.keyPrefix + key);\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\n// Set a key's value and run an optional callback once the value is set.\n// Unlike Gaia's implementation, the callback function is passed the value,\n// in case you want to operate on that value only after you're sure it\n// saved, or something like that.\nfunction setItem$2(key, value, callback) {\n    var self = this;\n\n    key = normalizeKey(key);\n\n    var promise = self.ready().then(function () {\n        // Convert undefined values to null.\n        // https://github.com/mozilla/localForage/pull/42\n        if (value === undefined) {\n            value = null;\n        }\n\n        // Save the original value to pass to the callback.\n        var originalValue = value;\n\n        return new Promise$1(function (resolve, reject) {\n            var dbInfo = self._dbInfo;\n            dbInfo.serializer.serialize(value, function (value, error) {\n                if (error) {\n                    reject(error);\n                } else {\n                    try {\n                        localStorage.setItem(dbInfo.keyPrefix + key, value);\n                        resolve(originalValue);\n                    } catch (e) {\n                        // localStorage capacity exceeded.\n                        // TODO: Make this a specific error/event.\n                        if (e.name === 'QuotaExceededError' || e.name === 'NS_ERROR_DOM_QUOTA_REACHED') {\n                            reject(e);\n                        }\n                        reject(e);\n                    }\n                }\n            });\n        });\n    });\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nfunction dropInstance$2(options, callback) {\n    callback = getCallback.apply(this, arguments);\n\n    options = typeof options !== 'function' && options || {};\n    if (!options.name) {\n        var currentConfig = this.config();\n        options.name = options.name || currentConfig.name;\n        options.storeName = options.storeName || currentConfig.storeName;\n    }\n\n    var self = this;\n    var promise;\n    if (!options.name) {\n        promise = Promise$1.reject('Invalid arguments');\n    } else {\n        promise = new Promise$1(function (resolve) {\n            if (!options.storeName) {\n                resolve(options.name + '/');\n            } else {\n                resolve(_getKeyPrefix(options, self._defaultConfig));\n            }\n        }).then(function (keyPrefix) {\n            for (var i = localStorage.length - 1; i >= 0; i--) {\n                var key = localStorage.key(i);\n\n                if (key.indexOf(keyPrefix) === 0) {\n                    localStorage.removeItem(key);\n                }\n            }\n        });\n    }\n\n    executeCallback(promise, callback);\n    return promise;\n}\n\nvar localStorageWrapper = {\n    _driver: 'localStorageWrapper',\n    _initStorage: _initStorage$2,\n    _support: isLocalStorageValid(),\n    iterate: iterate$2,\n    getItem: getItem$2,\n    setItem: setItem$2,\n    removeItem: removeItem$2,\n    clear: clear$2,\n    length: length$2,\n    key: key$2,\n    keys: keys$2,\n    dropInstance: dropInstance$2\n};\n\nvar sameValue = function sameValue(x, y) {\n    return x === y || typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y);\n};\n\nvar includes = function includes(array, searchElement) {\n    var len = array.length;\n    var i = 0;\n    while (i < len) {\n        if (sameValue(array[i], searchElement)) {\n            return true;\n        }\n        i++;\n    }\n\n    return false;\n};\n\nvar isArray = Array.isArray || function (arg) {\n    return Object.prototype.toString.call(arg) === '[object Array]';\n};\n\n// Drivers are stored here when `defineDriver()` is called.\n// They are shared across all instances of localForage.\nvar DefinedDrivers = {};\n\nvar DriverSupport = {};\n\nvar DefaultDrivers = {\n    INDEXEDDB: asyncStorage,\n    WEBSQL: webSQLStorage,\n    LOCALSTORAGE: localStorageWrapper\n};\n\nvar DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver];\n\nvar OptionalDriverMethods = ['dropInstance'];\n\nvar LibraryMethods = ['clear', 'getItem', 'iterate', 'key', 'keys', 'length', 'removeItem', 'setItem'].concat(OptionalDriverMethods);\n\nvar DefaultConfig = {\n    description: '',\n    driver: DefaultDriverOrder.slice(),\n    name: 'localforage',\n    // Default DB size is _JUST UNDER_ 5MB, as it's the highest size\n    // we can use without a prompt.\n    size: 4980736,\n    storeName: 'keyvaluepairs',\n    version: 1.0\n};\n\nfunction callWhenReady(localForageInstance, libraryMethod) {\n    localForageInstance[libraryMethod] = function () {\n        var _args = arguments;\n        return localForageInstance.ready().then(function () {\n            return localForageInstance[libraryMethod].apply(localForageInstance, _args);\n        });\n    };\n}\n\nfunction extend() {\n    for (var i = 1; i < arguments.length; i++) {\n        var arg = arguments[i];\n\n        if (arg) {\n            for (var _key in arg) {\n                if (arg.hasOwnProperty(_key)) {\n                    if (isArray(arg[_key])) {\n                        arguments[0][_key] = arg[_key].slice();\n                    } else {\n                        arguments[0][_key] = arg[_key];\n                    }\n                }\n            }\n        }\n    }\n\n    return arguments[0];\n}\n\nvar LocalForage = function () {\n    function LocalForage(options) {\n        _classCallCheck(this, LocalForage);\n\n        for (var driverTypeKey in DefaultDrivers) {\n            if (DefaultDrivers.hasOwnProperty(driverTypeKey)) {\n                var driver = DefaultDrivers[driverTypeKey];\n                var driverName = driver._driver;\n                this[driverTypeKey] = driverName;\n\n                if (!DefinedDrivers[driverName]) {\n                    // we don't need to wait for the promise,\n                    // since the default drivers can be defined\n                    // in a blocking manner\n                    this.defineDriver(driver);\n                }\n            }\n        }\n\n        this._defaultConfig = extend({}, DefaultConfig);\n        this._config = extend({}, this._defaultConfig, options);\n        this._driverSet = null;\n        this._initDriver = null;\n        this._ready = false;\n        this._dbInfo = null;\n\n        this._wrapLibraryMethodsWithReady();\n        this.setDriver(this._config.driver)[\"catch\"](function () {});\n    }\n\n    // Set any config values for localForage; can be called anytime before\n    // the first API call (e.g. `getItem`, `setItem`).\n    // We loop through options so we don't overwrite existing config\n    // values.\n\n\n    LocalForage.prototype.config = function config(options) {\n        // If the options argument is an object, we use it to set values.\n        // Otherwise, we return either a specified config value or all\n        // config values.\n        if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {\n            // If localforage is ready and fully initialized, we can't set\n            // any new configuration values. Instead, we return an error.\n            if (this._ready) {\n                return new Error(\"Can't call config() after localforage \" + 'has been used.');\n            }\n\n            for (var i in options) {\n                if (i === 'storeName') {\n                    options[i] = options[i].replace(/\\W/g, '_');\n                }\n\n                if (i === 'version' && typeof options[i] !== 'number') {\n                    return new Error('Database version must be a number.');\n                }\n\n                this._config[i] = options[i];\n            }\n\n            // after all config options are set and\n            // the driver option is used, try setting it\n            if ('driver' in options && options.driver) {\n                return this.setDriver(this._config.driver);\n            }\n\n            return true;\n        } else if (typeof options === 'string') {\n            return this._config[options];\n        } else {\n            return this._config;\n        }\n    };\n\n    // Used to define a custom driver, shared across all instances of\n    // localForage.\n\n\n    LocalForage.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {\n        var promise = new Promise$1(function (resolve, reject) {\n            try {\n                var driverName = driverObject._driver;\n                var complianceError = new Error('Custom driver not compliant; see ' + 'https://mozilla.github.io/localForage/#definedriver');\n\n                // A driver name should be defined and not overlap with the\n                // library-defined, default drivers.\n                if (!driverObject._driver) {\n                    reject(complianceError);\n                    return;\n                }\n\n                var driverMethods = LibraryMethods.concat('_initStorage');\n                for (var i = 0, len = driverMethods.length; i < len; i++) {\n                    var driverMethodName = driverMethods[i];\n\n                    // when the property is there,\n                    // it should be a method even when optional\n                    var isRequired = !includes(OptionalDriverMethods, driverMethodName);\n                    if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== 'function') {\n                        reject(complianceError);\n                        return;\n                    }\n                }\n\n                var configureMissingMethods = function configureMissingMethods() {\n                    var methodNotImplementedFactory = function methodNotImplementedFactory(methodName) {\n                        return function () {\n                            var error = new Error('Method ' + methodName + ' is not implemented by the current driver');\n                            var promise = Promise$1.reject(error);\n                            executeCallback(promise, arguments[arguments.length - 1]);\n                            return promise;\n                        };\n                    };\n\n                    for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) {\n                        var optionalDriverMethod = OptionalDriverMethods[_i];\n                        if (!driverObject[optionalDriverMethod]) {\n                            driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod);\n                        }\n                    }\n                };\n\n                configureMissingMethods();\n\n                var setDriverSupport = function setDriverSupport(support) {\n                    if (DefinedDrivers[driverName]) {\n                        console.info('Redefining LocalForage driver: ' + driverName);\n                    }\n                    DefinedDrivers[driverName] = driverObject;\n                    DriverSupport[driverName] = support;\n                    // don't use a then, so that we can define\n                    // drivers that have simple _support methods\n                    // in a blocking manner\n                    resolve();\n                };\n\n                if ('_support' in driverObject) {\n                    if (driverObject._support && typeof driverObject._support === 'function') {\n                        driverObject._support().then(setDriverSupport, reject);\n                    } else {\n                        setDriverSupport(!!driverObject._support);\n                    }\n                } else {\n                    setDriverSupport(true);\n                }\n            } catch (e) {\n                reject(e);\n            }\n        });\n\n        executeTwoCallbacks(promise, callback, errorCallback);\n        return promise;\n    };\n\n    LocalForage.prototype.driver = function driver() {\n        return this._driver || null;\n    };\n\n    LocalForage.prototype.getDriver = function getDriver(driverName, callback, errorCallback) {\n        var getDriverPromise = DefinedDrivers[driverName] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error('Driver not found.'));\n\n        executeTwoCallbacks(getDriverPromise, callback, errorCallback);\n        return getDriverPromise;\n    };\n\n    LocalForage.prototype.getSerializer = function getSerializer(callback) {\n        var serializerPromise = Promise$1.resolve(localforageSerializer);\n        executeTwoCallbacks(serializerPromise, callback);\n        return serializerPromise;\n    };\n\n    LocalForage.prototype.ready = function ready(callback) {\n        var self = this;\n\n        var promise = self._driverSet.then(function () {\n            if (self._ready === null) {\n                self._ready = self._initDriver();\n            }\n\n            return self._ready;\n        });\n\n        executeTwoCallbacks(promise, callback, callback);\n        return promise;\n    };\n\n    LocalForage.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {\n        var self = this;\n\n        if (!isArray(drivers)) {\n            drivers = [drivers];\n        }\n\n        var supportedDrivers = this._getSupportedDrivers(drivers);\n\n        function setDriverToConfig() {\n            self._config.driver = self.driver();\n        }\n\n        function extendSelfWithDriver(driver) {\n            self._extend(driver);\n            setDriverToConfig();\n\n            self._ready = self._initStorage(self._config);\n            return self._ready;\n        }\n\n        function initDriver(supportedDrivers) {\n            return function () {\n                var currentDriverIndex = 0;\n\n                function driverPromiseLoop() {\n                    while (currentDriverIndex < supportedDrivers.length) {\n                        var driverName = supportedDrivers[currentDriverIndex];\n                        currentDriverIndex++;\n\n                        self._dbInfo = null;\n                        self._ready = null;\n\n                        return self.getDriver(driverName).then(extendSelfWithDriver)[\"catch\"](driverPromiseLoop);\n                    }\n\n                    setDriverToConfig();\n                    var error = new Error('No available storage method found.');\n                    self._driverSet = Promise$1.reject(error);\n                    return self._driverSet;\n                }\n\n                return driverPromiseLoop();\n            };\n        }\n\n        // There might be a driver initialization in progress\n        // so wait for it to finish in order to avoid a possible\n        // race condition to set _dbInfo\n        var oldDriverSetDone = this._driverSet !== null ? this._driverSet[\"catch\"](function () {\n            return Promise$1.resolve();\n        }) : Promise$1.resolve();\n\n        this._driverSet = oldDriverSetDone.then(function () {\n            var driverName = supportedDrivers[0];\n            self._dbInfo = null;\n            self._ready = null;\n\n            return self.getDriver(driverName).then(function (driver) {\n                self._driver = driver._driver;\n                setDriverToConfig();\n                self._wrapLibraryMethodsWithReady();\n                self._initDriver = initDriver(supportedDrivers);\n            });\n        })[\"catch\"](function () {\n            setDriverToConfig();\n            var error = new Error('No available storage method found.');\n            self._driverSet = Promise$1.reject(error);\n            return self._driverSet;\n        });\n\n        executeTwoCallbacks(this._driverSet, callback, errorCallback);\n        return this._driverSet;\n    };\n\n    LocalForage.prototype.supports = function supports(driverName) {\n        return !!DriverSupport[driverName];\n    };\n\n    LocalForage.prototype._extend = function _extend(libraryMethodsAndProperties) {\n        extend(this, libraryMethodsAndProperties);\n    };\n\n    LocalForage.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) {\n        var supportedDrivers = [];\n        for (var i = 0, len = drivers.length; i < len; i++) {\n            var driverName = drivers[i];\n            if (this.supports(driverName)) {\n                supportedDrivers.push(driverName);\n            }\n        }\n        return supportedDrivers;\n    };\n\n    LocalForage.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() {\n        // Add a stub for each driver API method that delays the call to the\n        // corresponding driver method until localForage is ready. These stubs\n        // will be replaced by the driver methods as soon as the driver is\n        // loaded, so there is no performance impact.\n        for (var i = 0, len = LibraryMethods.length; i < len; i++) {\n            callWhenReady(this, LibraryMethods[i]);\n        }\n    };\n\n    LocalForage.prototype.createInstance = function createInstance(options) {\n        return new LocalForage(options);\n    };\n\n    return LocalForage;\n}();\n\n// The actual localForage object that we expose as a module or via a\n// global. It's extended by pulling in one of our other libraries.\n\n\nvar localforage_js = new LocalForage();\n\nmodule.exports = localforage_js;\n\n},{\"3\":3}]},{},[4])(4)\n});\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return exports;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var exports = {},\n    Op = Object.prototype,\n    hasOwn = Op.hasOwnProperty,\n    defineProperty = Object.defineProperty || function (obj, key, desc) {\n      obj[key] = desc.value;\n    },\n    $Symbol = \"function\" == typeof Symbol ? Symbol : {},\n    iteratorSymbol = $Symbol.iterator || \"@@iterator\",\n    asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\",\n    toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n  function define(obj, key, value) {\n    return Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), obj[key];\n  }\n  try {\n    define({}, \"\");\n  } catch (err) {\n    define = function define(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\n      generator = Object.create(protoGenerator.prototype),\n      context = new Context(tryLocsList || []);\n    return defineProperty(generator, \"_invoke\", {\n      value: makeInvokeMethod(innerFn, self, context)\n    }), generator;\n  }\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n  exports.wrap = wrap;\n  var ContinueSentinel = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n  var getProto = Object.getPrototypeOf,\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      define(prototype, method, function (arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (\"throw\" !== record.type) {\n        var result = record.arg,\n          value = result.value;\n        return value && \"object\" == _typeof(value) && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) {\n          invoke(\"next\", value, resolve, reject);\n        }, function (err) {\n          invoke(\"throw\", err, resolve, reject);\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\n          result.value = unwrapped, resolve(result);\n        }, function (error) {\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n      reject(record.arg);\n    }\n    var previousPromise;\n    defineProperty(this, \"_invoke\", {\n      value: function value(method, arg) {\n        function callInvokeWithMethodAndArg() {\n          return new PromiseImpl(function (resolve, reject) {\n            invoke(method, arg, resolve, reject);\n          });\n        }\n        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = \"suspendedStart\";\n    return function (method, arg) {\n      if (\"executing\" === state) throw new Error(\"Generator is already running\");\n      if (\"completed\" === state) {\n        if (\"throw\" === method) throw arg;\n        return doneResult();\n      }\n      for (context.method = method, context.arg = arg;;) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n        if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) {\n          if (\"suspendedStart\" === state) throw state = \"completed\", context.arg;\n          context.dispatchException(context.arg);\n        } else \"return\" === context.method && context.abrupt(\"return\", context.arg);\n        state = \"executing\";\n        var record = tryCatch(innerFn, self, context);\n        if (\"normal\" === record.type) {\n          if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue;\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        }\n        \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method,\n      method = delegate.iterator[methodName];\n    if (undefined === method) return context.delegate = null, \"throw\" === methodName && delegate.iterator[\"return\"] && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method) || \"return\" !== methodName && (context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a '\" + methodName + \"' method\")), ContinueSentinel;\n    var record = tryCatch(method, delegate.iterator, context.arg);\n    if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\n    var info = record.arg;\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel);\n  }\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\n  }\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\", delete record.arg, entry.completion = record;\n  }\n  function Context(tryLocsList) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) return iteratorMethod.call(iterable);\n      if (\"function\" == typeof iterable.next) return iterable;\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n          next = function next() {\n            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\n            return next.value = undefined, next.done = !0, next;\n          };\n        return next.next = next;\n      }\n    }\n    return {\n      next: doneResult\n    };\n  }\n  function doneResult() {\n    return {\n      value: undefined,\n      done: !0\n    };\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), defineProperty(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) {\n    var ctor = \"function\" == typeof genFun && genFun.constructor;\n    return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name));\n  }, exports.mark = function (genFun) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun;\n  }, exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () {\n    return this;\n  }), define(Gp, \"toString\", function () {\n    return \"[object Generator]\";\n  }), exports.keys = function (val) {\n    var object = Object(val),\n      keys = [];\n    for (var key in object) keys.push(key);\n    return keys.reverse(), function next() {\n      for (; keys.length;) {\n        var key = keys.pop();\n        if (key in object) return next.value = key, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, exports.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var rootRecord = this.tryEntries[0].completion;\n      if (\"throw\" === rootRecord.type) throw rootRecord.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) throw exception;\n      var context = this;\n      function handle(loc, caught) {\n        return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught;\n      }\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i],\n          record = entry.completion;\n        if (\"root\" === entry.tryLoc) return handle(\"end\");\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\"),\n            hasFinally = hasOwn.call(entry, \"finallyLoc\");\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n          } else {\n            if (!hasFinally) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n      finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\n      var record = finallyEntry ? finallyEntry.completion : {};\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (\"throw\" === record.type) throw record.arg;\n      return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (\"throw\" === record.type) {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      return this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel;\n    }\n  }, exports;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}","import localforage from \"localforage\"\r\nconst InitLocalStoreWrapper = () => {\r\n    localforage.config({\r\n        name: \"candexAppStorage\", // Name of the database\r\n        storeName: \"candexDataStore\", // Name of the data store\r\n        version: 1.0, // Database version\r\n        description: \"Local storage for candex web app\", // Description for the database\r\n        driver: [localforage.INDEXEDDB, localforage.WEBSQL, localforage.LOCALSTORAGE] // Preferred storage drivers in order\r\n    });\r\n}\r\n\r\nconst get = async (key) => {\r\n    const value = await localforage.getItem(key);\r\n    return value;\r\n}\r\nconst set = async (key, value) => {\r\n    await localforage.setItem(key, value);\r\n}\r\nconst remove = async (key) => {\r\n    await localforage.removeItem(key);\r\n}\r\nwindow.CXLocalStore = {\r\n    get: get,\r\n    set: set,\r\n    remove: remove,\r\n    InitLocalStoreWrapper: InitLocalStoreWrapper,\r\n    localforage: localforage\r\n};\r\n"],"names":["module","exports","e","t","n","r","s","o","u","i","f","Error","code","l","call","length","_dereq_","global","scheduleDrain","draining","Mutation","MutationObserver","WebKitMutationObserver","called","observer","nextTick","element","document","createTextNode","observe","characterData","data","setImmediate","MessageChannel","createElement","scriptEl","onreadystatechange","parentNode","removeChild","documentElement","appendChild","setTimeout","channel","port1","onmessage","port2","postMessage","queue","oldQueue","len","task","push","this","g","self","window","immediate","INTERNAL","handlers","REJECTED","FULFILLED","PENDING","Promise","resolver","TypeError","state","outcome","safelyResolveThenable","QueueItem","promise","onFulfilled","onRejected","callFulfilled","otherCallFulfilled","callRejected","otherCallRejected","unwrap","func","value","returnValue","reject","resolve","getThen","obj","then","apply","arguments","thenable","onError","onSuccess","result","tryCatch","status","out","prototype","constructor","error","reason","all","iterable","Object","toString","values","Array","resolved","allResolver","outValue","race","response","_typeof","Symbol","iterator","idb","indexedDB","webkitIndexedDB","mozIndexedDB","OIndexedDB","msIndexedDB","getIDB","createBlob","parts","properties","Blob","name","builder","BlobBuilder","MSBlobBuilder","MozBlobBuilder","WebKitBlobBuilder","append","getBlob","type","Promise$1","executeCallback","callback","executeTwoCallbacks","errorCallback","normalizeKey","key","console","warn","String","getCallback","DETECT_BLOB_SUPPORT_STORE","supportsBlobs","dbContexts","READ_ONLY","READ_WRITE","_binStringToArrayBuffer","bin","buf","ArrayBuffer","arr","Uint8Array","charCodeAt","_checkBlobSupport","txn","transaction","blob","objectStore","put","onabort","preventDefault","stopPropagation","oncomplete","matchedChrome","navigator","userAgent","match","matchedEdge","parseInt","_checkBlobSupportWithoutCaching","_deferReadiness","dbInfo","dbContext","deferredOperation","deferredOperations","dbReady","_advanceReadiness","pop","_rejectReadiness","err","_getConnection","upgradeNeeded","forages","db","close","dbArgs","version","openreq","open","onupgradeneeded","createObjectStore","storeName","oldVersion","ex","newVersion","onerror","onsuccess","onversionchange","target","_getOriginalConnection","_getUpgradedConnection","_isUpgradeNeeded","defaultVersion","isNewStore","objectStoreNames","contains","isDowngrade","isUpgrade","incVersion","_decodeBlob","encodedBlob","atob","_isEncodedBlob","__local_forage_encoded_blob","_fullyReady","_initReady","_dbInfo","createTransaction","mode","retries","undefined","tx","forage","_tryReconnect","asyncStorage","_driver","_initStorage","options","ready","initPromises","ignoreErrors","j","slice","_defaultConfig","k","_support","isSafari","openDatabase","test","platform","hasFetch","fetch","indexOf","IDBKeyRange","isIndexedDBValid","iterate","req","openCursor","iterationNumber","cursor","getItem","get","setItem","blobSupport","reader","FileReader","onloadend","base64","btoa","readAsBinaryString","store","removeItem","clear","count","advanced","openKeyCursor","advance","keys","dropInstance","currentConfig","config","dbPromise","dropObjectPromise","deleteObjectStore","_forage2","dropDBPromise","deleteDatabase","onblocked","BASE_CHARS","BLOB_TYPE_PREFIX_REGEX","SERIALIZED_MARKER","TYPE_ARRAYBUFFER","TYPE_BLOB","TYPE_INT8ARRAY","TYPE_UINT8ARRAY","TYPE_UINT8CLAMPEDARRAY","TYPE_INT16ARRAY","TYPE_INT32ARRAY","TYPE_UINT16ARRAY","TYPE_UINT32ARRAY","TYPE_FLOAT32ARRAY","TYPE_FLOAT64ARRAY","toString$1","stringToBuffer","serializedString","encoded1","encoded2","encoded3","encoded4","bufferLength","p","buffer","bytes","bufferToString","base64String","substring","localforageSerializer","serialize","valueType","marker","fileReader","onload","str","readAsArrayBuffer","JSON","stringify","deserialize","parse","blobType","SERIALIZED_MARKER_LENGTH","matcher","Int8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","createDbTable","executeSql","tryExecuteSql","sqlStatement","args","SYNTAX_ERR","results","rows","_setItem","retriesLeft","originalValue","serializer","sqlError","QUOTA_ERR","webSQLStorage","dbInfoPromise","description","size","item","c","storeNames","getAllStoreNames","operationInfo","dropTable","operations","_getKeyPrefix","defaultConfig","keyPrefix","_isLocalStorageUsable","localStorageTestKey","localStorage","checkIfLocalStorageThrows","localStorageWrapper","isLocalStorageValid","keyPrefixLength","itemKey","includes","array","searchElement","x","y","isNaN","isArray","arg","DefinedDrivers","DriverSupport","DefaultDrivers","INDEXEDDB","WEBSQL","LOCALSTORAGE","DefaultDriverOrder","OptionalDriverMethods","LibraryMethods","concat","DefaultConfig","driver","callWhenReady","localForageInstance","libraryMethod","_args","extend","_key","hasOwnProperty","LocalForage","driverTypeKey","instance","Constructor","_classCallCheck","driverName","defineDriver","_config","_driverSet","_initDriver","_ready","_wrapLibraryMethodsWithReady","setDriver","replace","driverObject","complianceError","driverMethods","driverMethodName","methodNotImplementedFactory","methodName","_i","_len","optionalDriverMethod","configureMissingMethods","setDriverSupport","support","info","getDriver","getDriverPromise","getSerializer","serializerPromise","drivers","supportedDrivers","_getSupportedDrivers","setDriverToConfig","extendSelfWithDriver","_extend","oldDriverSetDone","currentDriverIndex","driverPromiseLoop","initDriver","supports","libraryMethodsAndProperties","createInstance","localforage_js","_regeneratorRuntime","__esModule","Op","hasOwn","defineProperty","desc","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","configurable","writable","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","fn","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","forEach","method","_invoke","AsyncIterator","PromiseImpl","invoke","record","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","done","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iteratorMethod","doneResult","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","val","object","reverse","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","Function","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","d","a","definition","prop","asyncGeneratorStep","gen","_next","_throw","_asyncToGenerator","_ref","_callee","_context","localforage","_x","set","_ref2","_callee2","_context2","_x2","_x3","remove","_ref3","_callee3","_context3","_x4","CXLocalStore","InitLocalStoreWrapper"],"sourceRoot":""}