{"version":3,"file":"service-worker.js","mappings":"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","sources":["webpack:///./workers/cache-guard.ts","webpack:///../../node_modules/localforage/dist/localforage.js","webpack:///./workers/http-meta.ts","webpack:///./workers/cache-manager.ts","webpack:///webpack/bootstrap","webpack:///webpack/runtime/global","webpack:///./workers/service-worker.ts"],"sourcesContent":["import { RequestMeta, ResponseMeta } from './http-meta';\n\nconst workerName = 'service-worker.js';\n\n/**\n * Provides methods encapsulating the logic for verifying the cache eligibility\n * of `Request` and `Response` objects in a service worker.\n */\nexport class CacheGuard {\n    constructor(\n        private worker: ServiceWorkerGlobalScope,\n        private endpointWhiteList: string[] = []\n    ) {}\n\n    public verifyRequest(req: Request) {\n        const meta = new RequestMeta(req, this.worker);\n        const { url } = req;\n\n        // requests for HTTP verbs that result in side effects should not be cached\n        if (!meta.isIdempotent) {\n            return false;\n        }\n\n        // ignore requests to other origins (e.g., Google fonts)\n        if (!meta.isSameOrigin) {\n            return false;\n        }\n\n        // do not cache workers or Webpack updates\n        if (meta.isWorker || url.endsWith('hot-update.js') || url.endsWith(workerName)) {\n            return false;\n        }\n\n        // HTML should be treated as configuration and never cached:\n        // https://immutablewebapps.com/#indexhtml-is-deployable-configuration\n        if (meta.isHtml) {\n            return false;\n        }\n\n        return true;\n    }\n\n    public verifyResponse(resp: Response) {\n        const { isValid, isHtml, isJson } = new ResponseMeta(resp);\n\n        if (!isValid || isHtml) {\n            return false;\n        }\n\n        if (isJson) {\n            return isValidUrl(resp.url, this.endpointWhiteList);\n        }\n\n        return true;\n    }\n}\n\n/**\n * Validates that a request or response URL is against\n * the channel API and on a whitelist of endpoints.\n */\nfunction isValidUrl(url: string, whitelist: string[]) {\n    return (\n        url.includes('Jha.Web.Treasury.Channel.API') &&\n        whitelist.some(endpoint => url.endsWith(endpoint))\n    );\n}\n","/*!\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","/// <reference no-default-lib=\"true\"/>\n/// <reference lib=\"WebWorker\"/>\nexport class RequestMeta {\n    constructor(\n        private req: Request,\n        private worker: ServiceWorkerGlobalScope\n    ) {\n        // must assign these all in the ctor rather than inline\n        // due to https://github.com/microsoft/TypeScript/issues/44298\n        this.isIdempotent = this.req.method === 'GET';\n        this.isSameOrigin = this.req.url.startsWith(this.worker.location.origin);\n        this.isImage = this.req.destination === 'image';\n        this.isHtml = this.req.destination === 'document';\n        this.isJs = this.req.destination === 'script';\n        this.isCss = this.req.destination === 'style';\n        this.isFont = this.req.destination === 'font';\n        this.isWorker = this.req.destination === 'worker';\n        this.isStatic = this.req.destination !== '';\n    }\n\n    public readonly isIdempotent: boolean;\n\n    public readonly isSameOrigin: boolean;\n\n    public readonly isImage: boolean;\n\n    public readonly isHtml: boolean;\n\n    public readonly isJs: boolean;\n\n    public readonly isCss: boolean;\n\n    public readonly isFont: boolean;\n\n    public readonly isWorker: boolean;\n\n    // https://developer.mozilla.org/en-US/docs/Web/API/Request/destination#sect1\n    public readonly isStatic: boolean;\n}\n\nexport class ResponseMeta {\n    constructor(private res: Response) {\n        // must assign these all in the ctor rather than inline\n        // due to https://github.com/microsoft/TypeScript/issues/44298\n        this.isValid = this.res.status === 200;\n        this.contentType = this.res.headers.get('Content-Type') || '';\n        this.isJson = this.contentType.includes('application/json');\n        this.isHtml = this.contentType.includes('text/html');\n    }\n\n    public readonly isValid: boolean;\n\n    public readonly contentType: string;\n\n    public readonly isJson: boolean;\n\n    public readonly isHtml: boolean;\n}\n","// cspell:ignore localforage\nimport localforage from 'localforage';\n\nconst VERSION_KEY = 'version';\nconst DEFAULT_VERSION = '1.0.0';\n\ntype Enum = Record<string, string | number>;\n/**\n * Provides versioned, scoped access to known worker caches.\n */\nclass CacheManager<CacheType extends Enum> {\n    constructor(\n        /**\n         * Enum/key:value pairs object of cache names and their keys.\n         */\n        private cacheType: CacheType,\n        private worker: ServiceWorkerGlobalScope,\n        private store: LocalForage,\n        private prefix: string,\n        private endpoints?: string[]\n    ) {}\n\n    public async getVersion() {\n        try {\n            return (await this.store.getItem<string>(VERSION_KEY)) || DEFAULT_VERSION;\n        } catch {\n            return DEFAULT_VERSION;\n        }\n    }\n\n    public async setVersion(version: string) {\n        const previousVersion = await this.getVersion();\n        if (version === previousVersion) {\n            return;\n        }\n\n        await this.store.setItem(VERSION_KEY, version);\n        await this.clearStaleCaches();\n    }\n\n    /**\n     * Cache slow endpoints preemptively before they would be requested during normal app navigation.\n     */\n    public async cacheEndpoints<K extends keyof CacheType>(\n        cacheName: CacheType[K],\n        apiRoot: string,\n        authToken: string\n    ) {\n        if (!this.endpoints) {\n            return undefined;\n        }\n\n        const cache = await this.getCache(cacheName);\n        const fullyQualifiedEndpoints = this.endpoints.map(endpoint => `${apiRoot}${endpoint}`);\n        const requests = fullyQualifiedEndpoints.map(\n            endpoint =>\n                new Request(endpoint, {\n                    headers: {\n                        'x-tm-client-web': 'true',\n                        'Jha-Treasury-ClientInfo': 'Web',\n                        'Jha-Treasury-JhaAuthToken': authToken,\n                    },\n                })\n        );\n\n        return cache.addAll(requests);\n    }\n\n    /**\n     * Removes versioned caches that are not current with the latest service worker.\n     */\n    public async clearStaleCaches() {\n        const { caches } = this.worker;\n        const cacheNames = getTypedKeys(this.cacheType).map(k => this.cacheType[k]);\n        const versionedCacheKeys = await Promise.all(\n            cacheNames.map(name => this.genCacheKey(name))\n        );\n        const currentCacheKeys = await caches.keys();\n        const staleCacheKeys = currentCacheKeys.filter(key => !versionedCacheKeys.includes(key));\n        const deletionTasks = staleCacheKeys.map(cacheToDelete => caches.delete(cacheToDelete));\n\n        await Promise.all(deletionTasks);\n\n        return this.worker.clients.claim();\n    }\n\n    public async getCache<K extends keyof CacheType>(cacheName: CacheType[K]) {\n        const versionedKey = await this.genCacheKey(cacheName);\n        const cache = await caches.open(versionedKey);\n\n        return cache;\n    }\n\n    /**\n     * Helper for generating a versioned cache key.\n     * Mostly exists to ensure that the format is consistent everywhere it's used.\n     */\n    private async genCacheKey<K extends keyof CacheType>(cacheName: CacheType[K]) {\n        const version = await this.getVersion();\n        return `${this.prefix}-${cacheName}-${version}`;\n    }\n}\n\nexport function createCacheManager<CacheType extends Enum>(\n    cacheType: CacheType,\n    prefix: string,\n    worker: ServiceWorkerGlobalScope,\n    endpoints: string[] = []\n) {\n    const store = localforage.createInstance({\n        storeName: `${prefix}-worker-metadata`,\n    });\n\n    return new CacheManager(cacheType, worker, store, prefix, endpoints);\n}\n\nfunction getTypedKeys<T extends object>(obj: T) {\n    return Object.keys(obj) as (keyof T)[];\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\tif (cachedModule.error !== undefined) throw cachedModule.error;\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\ttry {\n\t\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\t} catch(e) {\n\t\tmodule.error = e;\n\t\tthrow e;\n\t}\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\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})();","/// <reference no-default-lib=\"true\"/>\n/// <reference lib=\"WebWorker\"/>\nimport { CacheGuard } from './cache-guard';\nimport { createCacheManager } from './cache-manager';\nimport { ResponseMeta } from './http-meta';\n\nconst endpointWhitelist = ['/achBanks'];\n\nexport enum PwaCache {\n    Static = 'static',\n    Runtime = 'runtime',\n}\n\ninterface MessagePayload {\n    version?: string;\n    authToken?: string;\n    apiRoot?: string;\n}\n\n/**\n * Aliases `self` mostly to enable better typing.\n */\n\nconst worker = self as unknown as ServiceWorkerGlobalScope;\nconst cm = createCacheManager(PwaCache, 'pwa', worker, endpointWhitelist);\nconst guard = new CacheGuard(worker, endpointWhitelist);\ncm.getCache(PwaCache.Runtime).then(cache =>\n    // eslint-disable-next-line no-console\n    cache.keys().then(keys => console.log('Current SW runtime cache keys:', keys))\n);\ncm.getCache(PwaCache.Static).then(cache =>\n    // eslint-disable-next-line no-console\n    cache.keys().then(keys => console.log('Current SW static cache keys:', keys))\n);\n\n// The activate event occurs when a new version of the worker is invoked.\nworker.addEventListener('activate', event => {\n    event.waitUntil(cm.clearStaleCaches());\n});\n\n// DE: Temporarily disabling caching for all requests - 8-7-24\n// worker.addEventListener('fetch', event => {\n//     if (!guard.verifyRequest(event.request)) {\n//         return;\n//     }\n\n//     event.respondWith(onCacheableFetch(event));\n// });\n\nworker.addEventListener('message', event => {\n    const { version, authToken, apiRoot } = event.data as MessagePayload;\n\n    if (version) {\n        event.waitUntil(cm.setVersion(version));\n    }\n\n    if (authToken && apiRoot) {\n        cm.cacheEndpoints(PwaCache.Runtime, apiRoot, authToken);\n    }\n});\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nasync function tryCache(req: Request, res: Response) {\n    const meta = new ResponseMeta(res);\n    if (!guard.verifyResponse(res)) {\n        return undefined;\n    }\n\n    const cache = meta.isJson\n        ? await cm.getCache(PwaCache.Runtime)\n        : await cm.getCache(PwaCache.Static);\n\n    return cache.put(req, res.clone());\n}\n"],"names":["CacheGuard","constructor","worker","endpointWhiteList","verifyRequest","req","meta","RequestMeta","this","url","isIdempotent","isSameOrigin","isWorker","endsWith","isHtml","verifyResponse","resp","isValid","isJson","ResponseMeta","whitelist","includes","some","endpoint","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","immediate","task","push","g","self","window","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","tryToUnwrap","result","tryCatch","status","out","reason","all","iterable","Object","prototype","toString","values","Array","resolved","allResolver","resolveFromAll","outValue","error","race","response","_typeof","Symbol","iterator","_classCallCheck","instance","Constructor","getIDB","indexedDB","webkitIndexedDB","mozIndexedDB","OIndexedDB","msIndexedDB","idb","isIndexedDBValid","open","isSafari","openDatabase","test","navigator","userAgent","platform","hasFetch","fetch","indexOf","IDBKeyRange","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","_checkBlobSupportWithoutCaching","txn","transaction","blob","objectStore","put","onabort","preventDefault","stopPropagation","oncomplete","matchedChrome","match","matchedEdge","parseInt","_checkBlobSupport","_deferReadiness","dbInfo","dbContext","deferredOperation","deferredOperations","dbReady","_advanceReadiness","pop","_rejectReadiness","err","_getConnection","upgradeNeeded","createDbContext","db","close","dbArgs","version","openreq","onupgradeneeded","createObjectStore","storeName","oldVersion","ex","newVersion","onerror","onsuccess","onversionchange","target","_getOriginalConnection","_getUpgradedConnection","_isUpgradeNeeded","defaultVersion","isNewStore","objectStoreNames","contains","isDowngrade","isUpgrade","incVersion","_encodeBlob","reader","FileReader","onloadend","base64","btoa","__local_forage_encoded_blob","readAsBinaryString","_decodeBlob","encodedBlob","atob","_isEncodedBlob","_fullyReady","_initReady","_dbInfo","_tryReconnect","forages","forage","createTransaction","mode","retries","undefined","tx","_initStorage","options","ready","initPromises","ignoreErrors","j","slice","_defaultConfig","k","getItem","get","iterate","openCursor","iterationNumber","cursor","setItem","blobSupport","store","removeItem","clear","count","advanced","openKeyCursor","advance","keys","dropInstance","currentConfig","config","dbPromise","dropObjectPromise","deleteObjectStore","_forage2","dropDBPromise","deleteDatabase","onblocked","asyncStorage","_driver","_support","isWebSQLValid","BASE_CHARS","BLOB_TYPE_PREFIX","BLOB_TYPE_PREFIX_REGEX","SERIALIZED_MARKER","SERIALIZED_MARKER_LENGTH","TYPE_ARRAYBUFFER","TYPE_BLOB","TYPE_INT8ARRAY","TYPE_UINT8ARRAY","TYPE_UINT8CLAMPEDARRAY","TYPE_INT16ARRAY","TYPE_INT32ARRAY","TYPE_UINT16ARRAY","TYPE_UINT32ARRAY","TYPE_FLOAT32ARRAY","TYPE_FLOAT64ARRAY","TYPE_SERIALIZED_MARKER_LENGTH","toString$1","stringToBuffer","serializedString","encoded1","encoded2","encoded3","encoded4","bufferLength","p","buffer","bytes","bufferToString","base64String","substring","serialize","valueType","marker","fileReader","onload","str","readAsArrayBuffer","JSON","stringify","deserialize","parse","blobType","matcher","Int8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","localforageSerializer","createDbTable","executeSql","_initStorage$1","dbInfoPromise","description","size","serializer","tryExecuteSql","sqlStatement","args","SYNTAX_ERR","results","rows","getItem$1","item","iterate$1","_setItem","retriesLeft","originalValue","sqlError","QUOTA_ERR","setItem$1","removeItem$1","clear$1","length$1","c","key$1","keys$1","getAllStoreNames","storeNames","dropInstance$1","operationInfo","dropTable","operations","webSQLStorage","isLocalStorageValid","localStorage","_getKeyPrefix","defaultConfig","keyPrefix","checkIfLocalStorageThrows","localStorageTestKey","_isLocalStorageUsable","_initStorage$2","clear$2","getItem$2","iterate$2","keyPrefixLength","key$2","keys$2","itemKey","length$2","removeItem$2","setItem$2","dropInstance$2","localStorageWrapper","sameValue","x","y","isNaN","array","searchElement","isArray","arg","DefinedDrivers","DriverSupport","DefaultDrivers","INDEXEDDB","WEBSQL","LOCALSTORAGE","DefaultDriverOrder","OptionalDriverMethods","LibraryMethods","concat","DefaultConfig","driver","callWhenReady","localForageInstance","libraryMethod","_args","extend","_key","hasOwnProperty","LocalForage","driverTypeKey","driverName","defineDriver","_config","_driverSet","_initDriver","_ready","_wrapLibraryMethodsWithReady","setDriver","replace","driverObject","complianceError","driverMethods","driverMethodName","configureMissingMethods","methodNotImplementedFactory","methodName","_i","_len","optionalDriverMethod","setDriverSupport","support","info","getDriver","getDriverPromise","getSerializer","serializerPromise","drivers","supportedDrivers","_getSupportedDrivers","setDriverToConfig","extendSelfWithDriver","_extend","initDriver","currentDriverIndex","driverPromiseLoop","oldDriverSetDone","supports","libraryMethodsAndProperties","createInstance","localforage_js","method","startsWith","location","origin","isImage","destination","isJs","isCss","isFont","isStatic","res","contentType","headers","cacheType","prefix","endpoints","CacheManager","VERSION_KEY","DEFAULT_VERSION","getVersion","setVersion","clearStaleCaches","cacheEndpoints","cacheName","apiRoot","authToken","cache","getCache","requests","map","Request","addAll","caches","cacheNames","versionedCacheKeys","genCacheKey","deletionTasks","filter","cacheToDelete","delete","clients","claim","versionedKey","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","globalThis","Function","endpointWhitelist","PwaCache","cm","createCacheManager","Runtime","log","Static","addEventListener","event","waitUntil"],"sourceRoot":""}