RubyGems - jekyll-pwa-workbox - Versions diffs - 0.0.7 → 5.1.41 - Mend

jekyll-pwa-workbox 0.0.7 → 5.1.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (95) hide show

data/lib/vendor/workbox-v5.1.4/workbox-window.dev.mjs.map ADDED

@@ -0,0 +1 @@

+ {"version":3,"file":"workbox-window.dev.mjs","sources":["../_version.js","../messageSW.js","../../workbox-core/_version.js","../../workbox-core/_private/Deferred.js","../../workbox-core/_private/dontWaitFor.js","../../workbox-core/_private/logger.js","../utils/WorkboxEventTarget.js","../utils/urlsMatch.js","../utils/WorkboxEvent.js","../Workbox.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:window:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport './_version.js';\n/**\n * Sends a data object to a service worker via `postMessage` and resolves with\n * a response (if any).\n *\n * A response can be set in a message handler in the service worker by\n * calling `event.ports[0].postMessage(...)`, which will resolve the promise\n * returned by `messageSW()`. If no response is set, the promise will not\n * resolve.\n *\n * @param {ServiceWorker} sw The service worker to send the message to.\n * @param {Object} data An object to send to the service worker.\n * @return {Promise<Object|undefined>}\n * @memberof module:workbox-window\n */\nfunction messageSW(sw, data) {\n return new Promise((resolve) => {\n const messageChannel = new MessageChannel();\n messageChannel.port1.onmessage = (event) => {\n resolve(event.data);\n };\n sw.postMessage(data, [messageChannel.port2]);\n });\n}\nexport { messageSW };\n","\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:core:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * The Deferred class composes Promises in a way that allows for them to be\n * resolved or rejected from outside the constructor. In most cases promises\n * should be used directly, but Deferreds can be necessary when the logic to\n * resolve a promise must be separate.\n *\n * @private\n */\nclass Deferred {\n /**\n * Creates a promise and exposes its resolve and reject functions as methods.\n */\n constructor() {\n this.promise = new Promise((resolve, reject) => {\n this.resolve = resolve;\n this.reject = reject;\n });\n }\n}\nexport { Deferred };\n","/*\n Copyright 2019 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A helper function that prevents a promise from being flagged as unused.\n *\n * @private\n **/\nexport function dontWaitFor(promise) {\n // Effective no-op.\n promise.then(() => { });\n}\n","/*\n Copyright 2019 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst logger = (process.env.NODE_ENV === 'production' ? null : (() => {\n // Don't overwrite this value if it's already set.\n // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923\n if (!('__WB_DISABLE_DEV_LOGS' in self)) {\n self.__WB_DISABLE_DEV_LOGS = false;\n }\n let inGroup = false;\n const methodToColorMap = {\n debug: `#7f8c8d`,\n log: `#2ecc71`,\n warn: `#f39c12`,\n error: `#c0392b`,\n groupCollapsed: `#3498db`,\n groupEnd: null,\n };\n const print = function (method, args) {\n if (self.__WB_DISABLE_DEV_LOGS) {\n return;\n }\n if (method === 'groupCollapsed') {\n // Safari doesn't print all console.groupCollapsed() arguments:\n // https://bugs.webkit.org/show_bug.cgi?id=182754\n if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {\n console[method](...args);\n return;\n }\n }\n const styles = [\n `background: ${methodToColorMap[method]}`,\n `border-radius: 0.5em`,\n `color: white`,\n `font-weight: bold`,\n `padding: 2px 0.5em`,\n ];\n // When in a group, the workbox prefix is not displayed.\n const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];\n console[method](...logPrefix, ...args);\n if (method === 'groupCollapsed') {\n inGroup = true;\n }\n if (method === 'groupEnd') {\n inGroup = false;\n }\n };\n const api = {};\n const loggerMethods = Object.keys(methodToColorMap);\n for (const key of loggerMethods) {\n const method = key;\n api[method] = (...args) => {\n print(method, args);\n };\n }\n return api;\n})());\nexport { logger };\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n/**\n * A minimal `EventTarget` shim.\n * This is necessary because not all browsers support constructable\n * `EventTarget`, so using a real `EventTarget` will error.\n * @private\n */\nexport class WorkboxEventTarget {\n constructor() {\n this._eventListenerRegistry = new Map();\n }\n /**\n * @param {string} type\n * @param {Function} listener\n * @private\n */\n addEventListener(type, listener) {\n const foo = this._getEventListenersByType(type);\n foo.add(listener);\n }\n /**\n * @param {string} type\n * @param {Function} listener\n * @private\n */\n removeEventListener(type, listener) {\n this._getEventListenersByType(type).delete(listener);\n }\n /**\n * @param {Object} event\n * @private\n */\n dispatchEvent(event) {\n event.target = this;\n const listeners = this._getEventListenersByType(event.type);\n for (const listener of listeners) {\n listener(event);\n }\n }\n /**\n * Returns a Set of listeners associated with the passed event type.\n * If no handlers have been registered, an empty Set is returned.\n *\n * @param {string} type The event type.\n * @return {Set<ListenerCallback>} An array of handler functions.\n * @private\n */\n _getEventListenersByType(type) {\n if (!this._eventListenerRegistry.has(type)) {\n this._eventListenerRegistry.set(type, new Set());\n }\n return this._eventListenerRegistry.get(type);\n }\n}\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * Returns true if two URLs have the same `.href` property. The URLS can be\n * relative, and if they are the current location href is used to resolve URLs.\n *\n * @private\n * @param {string} url1\n * @param {string} url2\n * @return {boolean}\n */\nexport function urlsMatch(url1, url2) {\n const { href } = location;\n return new URL(url1, href).href === new URL(url2, href).href;\n}\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A minimal `Event` subclass shim.\n * This doesn't *actually* subclass `Event` because not all browsers support\n * constructable `EventTarget`, and using a real `Event` will error.\n * @private\n */\nexport class WorkboxEvent {\n constructor(type, props) {\n this.type = type;\n Object.assign(this, props);\n }\n}\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport { dontWaitFor } from 'workbox-core/_private/dontWaitFor.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { messageSW } from './messageSW.js';\nimport { WorkboxEventTarget } from './utils/WorkboxEventTarget.js';\nimport { urlsMatch } from './utils/urlsMatch.js';\nimport { WorkboxEvent } from './utils/WorkboxEvent.js';\nimport './_version.js';\n// The time a SW must be in the waiting phase before we can conclude\n// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically\n// chosen, but it seems to avoid false positives in my testing.\nconst WAITING_TIMEOUT_DURATION = 200;\n// The amount of time after a registration that we can reasonably conclude\n// that the registration didn't trigger an update.\nconst REGISTRATION_TIMEOUT_DURATION = 60000;\n/**\n * A class to aid in handling service worker registration, updates, and\n * reacting to service worker lifecycle events.\n *\n * @fires [message]{@link module:workbox-window.Workbox#message}\n * @fires [installed]{@link module:workbox-window.Workbox#installed}\n * @fires [waiting]{@link module:workbox-window.Workbox#waiting}\n * @fires [controlling]{@link module:workbox-window.Workbox#controlling}\n * @fires [activated]{@link module:workbox-window.Workbox#activated}\n * @fires [redundant]{@link module:workbox-window.Workbox#redundant}\n * @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}\n * @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}\n * @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}\n * @memberof module:workbox-window\n */\nclass Workbox extends WorkboxEventTarget {\n /**\n * Creates a new Workbox instance with a script URL and service worker\n * options. The script URL and options are the same as those used when\n * calling `navigator.serviceWorker.register(scriptURL, options)`. See:\n * https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register\n *\n * @param {string} scriptURL The service worker script associated with this\n * instance.\n * @param {Object} [registerOptions] The service worker options associated\n * with this instance.\n */\n constructor(scriptURL, registerOptions = {}) {\n super();\n this._registerOptions = {};\n this._updateFoundCount = 0;\n // Deferreds we can resolve later.\n this._swDeferred = new Deferred();\n this._activeDeferred = new Deferred();\n this._controllingDeferred = new Deferred();\n this._registrationTime = 0;\n this._ownSWs = new Set();\n /**\n * @private\n */\n this._onUpdateFound = () => {\n // `this._registration` will never be `undefined` after an update is found.\n const registration = this._registration;\n const installingSW = registration.installing;\n // If the script URL passed to `navigator.serviceWorker.register()` is\n // different from the current controlling SW's script URL, we know any\n // successful registration calls will trigger an `updatefound` event.\n // But if the registered script URL is the same as the current controlling\n // SW's script URL, we'll only get an `updatefound` event if the file\n // changed since it was last registered. This can be a problem if the user\n // opens up the same page in a different tab, and that page registers\n // a SW that triggers an update. It's a problem because this page has no\n // good way of knowing whether the `updatefound` event came from the SW\n // script it registered or from a registration attempt made by a newer\n // version of the page running in another tab.\n // To minimize the possibility of a false positive, we use the logic here:\n const updateLikelyTriggeredExternally = \n // Since we enforce only calling `register()` once, and since we don't\n // add the `updatefound` event listener until the `register()` call, if\n // `_updateFoundCount` is > 0 then it means this method has already\n // been called, thus this SW must be external\n this._updateFoundCount > 0 ||\n // If the script URL of the installing SW is different from this\n // instance's script URL, we know it's definitely not from our\n // registration.\n !urlsMatch(installingSW.scriptURL, this._scriptURL) ||\n // If all of the above are false, then we use a time-based heuristic:\n // Any `updatefound` event that occurs long after our registration is\n // assumed to be external.\n (performance.now() >\n this._registrationTime + REGISTRATION_TIMEOUT_DURATION) ?\n // If any of the above are not true, we assume the update was\n // triggered by this instance.\n true : false;\n if (updateLikelyTriggeredExternally) {\n this._externalSW = installingSW;\n registration.removeEventListener('updatefound', this._onUpdateFound);\n }\n else {\n // If the update was not triggered externally we know the installing\n // SW is the one we registered, so we set it.\n this._sw = installingSW;\n this._ownSWs.add(installingSW);\n this._swDeferred.resolve(installingSW);\n // The `installing` state isn't something we have a dedicated\n // callback for, but we do log messages for it in development.\n if (process.env.NODE_ENV !== 'production') {\n if (navigator.serviceWorker.controller) {\n logger.log('Updated service worker found. Installing now...');\n }\n else {\n logger.log('Service worker is installing...');\n }\n }\n }\n // Increment the `updatefound` count, so future invocations of this\n // method can be sure they were triggered externally.\n ++this._updateFoundCount;\n // Add a `statechange` listener regardless of whether this update was\n // triggered externally, since we have callbacks for both.\n installingSW.addEventListener('statechange', this._onStateChange);\n };\n /**\n * @private\n * @param {Event} originalEvent\n */\n this._onStateChange = (originalEvent) => {\n // `this._registration` will never be `undefined` after an update is found.\n const registration = this._registration;\n const sw = originalEvent.target;\n const { state } = sw;\n const isExternal = sw === this._externalSW;\n const eventPrefix = isExternal ? 'external' : '';\n const eventProps = {\n sw,\n originalEvent\n };\n if (!isExternal && this._isUpdate) {\n eventProps.isUpdate = true;\n }\n this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));\n if (state === 'installed') {\n // This timeout is used to ignore cases where the service worker calls\n // `skipWaiting()` in the install event, thus moving it directly in the\n // activating state. (Since all service workers *must* go through the\n // waiting phase, the only way to detect `skipWaiting()` called in the\n // install event is to observe that the time spent in the waiting phase\n // is very short.)\n // NOTE: we don't need separate timeouts for the own and external SWs\n // since they can't go through these phases at the same time.\n this._waitingTimeout = self.setTimeout(() => {\n // Ensure the SW is still waiting (it may now be redundant).\n if (state === 'installed' && registration.waiting === sw) {\n this.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));\n if (process.env.NODE_ENV !== 'production') {\n if (isExternal) {\n logger.warn('An external service worker has installed but is ' +\n 'waiting for this client to close before activating...');\n }\n else {\n logger.warn('The service worker has installed but is waiting ' +\n 'for existing clients to close before activating...');\n }\n }\n }\n }, WAITING_TIMEOUT_DURATION);\n }\n else if (state === 'activating') {\n clearTimeout(this._waitingTimeout);\n if (!isExternal) {\n this._activeDeferred.resolve(sw);\n }\n }\n if (process.env.NODE_ENV !== 'production') {\n switch (state) {\n case 'installed':\n if (isExternal) {\n logger.warn('An external service worker has installed. ' +\n 'You may want to suggest users reload this page.');\n }\n else {\n logger.log('Registered service worker installed.');\n }\n break;\n case 'activated':\n if (isExternal) {\n logger.warn('An external service worker has activated.');\n }\n else {\n logger.log('Registered service worker activated.');\n if (sw !== navigator.serviceWorker.controller) {\n logger.warn('The registered service worker is active but ' +\n 'not yet controlling the page. Reload or run ' +\n '`clients.claim()` in the service worker.');\n }\n }\n break;\n case 'redundant':\n if (sw === this._compatibleControllingSW) {\n logger.log('Previously controlling service worker now redundant!');\n }\n else if (!isExternal) {\n logger.log('Registered service worker now redundant!');\n }\n break;\n }\n }\n };\n /**\n * @private\n * @param {Event} originalEvent\n */\n this._onControllerChange = (originalEvent) => {\n const sw = this._sw;\n if (sw === navigator.serviceWorker.controller) {\n this.dispatchEvent(new WorkboxEvent('controlling', {\n sw,\n originalEvent,\n isUpdate: this._isUpdate,\n }));\n if (process.env.NODE_ENV !== 'production') {\n logger.log('Registered service worker now controlling this page.');\n }\n this._controllingDeferred.resolve(sw);\n }\n };\n /**\n * @private\n * @param {Event} originalEvent\n */\n this._onMessage = async (originalEvent) => {\n const { data, source } = originalEvent;\n // Wait until there's an \"own\" service worker. This is used to buffer\n // `message` events that may be received prior to calling `register()`.\n await this.getSW();\n // If the service worker that sent the message is in the list of own\n // service workers for this instance, dispatch a `message` event.\n // NOTE: we check for all previously owned service workers rather than\n // just the current one because some messages (e.g. cache updates) use\n // a timeout when sent and may be delayed long enough for a service worker\n // update to be found.\n if (this._ownSWs.has(source)) {\n this.dispatchEvent(new WorkboxEvent('message', {\n data,\n sw: source,\n originalEvent,\n }));\n }\n };\n this._scriptURL = scriptURL;\n this._registerOptions = registerOptions;\n // Add a message listener immediately since messages received during\n // page load are buffered only until the DOMContentLoaded event:\n // https://github.com/GoogleChrome/workbox/issues/2202\n navigator.serviceWorker.addEventListener('message', this._onMessage);\n }\n /**\n * Registers a service worker for this instances script URL and service\n * worker options. By default this method delays registration until after\n * the window has loaded.\n *\n * @param {Object} [options]\n * @param {Function} [options.immediate=false] Setting this to true will\n * register the service worker immediately, even if the window has\n * not loaded (not recommended).\n */\n async register({ immediate = false } = {}) {\n if (process.env.NODE_ENV !== 'production') {\n if (this._registrationTime) {\n logger.error('Cannot re-register a Workbox instance after it has ' +\n 'been registered. Create a new instance instead.');\n return;\n }\n }\n if (!immediate && document.readyState !== 'complete') {\n await new Promise((res) => window.addEventListener('load', res));\n }\n // Set this flag to true if any service worker was controlling the page\n // at registration time.\n this._isUpdate = Boolean(navigator.serviceWorker.controller);\n // Before registering, attempt to determine if a SW is already controlling\n // the page, and if that SW script (and version, if specified) matches this\n // instance's script.\n this._compatibleControllingSW = this._getControllingSWIfCompatible();\n this._registration = await this._registerScript();\n // If we have a compatible controller, store the controller as the \"own\"\n // SW, resolve active/controlling deferreds and add necessary listeners.\n if (this._compatibleControllingSW) {\n this._sw = this._compatibleControllingSW;\n this._activeDeferred.resolve(this._compatibleControllingSW);\n this._controllingDeferred.resolve(this._compatibleControllingSW);\n this._compatibleControllingSW.addEventListener('statechange', this._onStateChange, { once: true });\n }\n // If there's a waiting service worker with a matching URL before the\n // `updatefound` event fires, it likely means that this site is open\n // in another tab, or the user refreshed the page (and thus the previous\n // page wasn't fully unloaded before this page started loading).\n // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting\n const waitingSW = this._registration.waiting;\n if (waitingSW && urlsMatch(waitingSW.scriptURL, this._scriptURL)) {\n // Store the waiting SW as the \"own\" Sw, even if it means overwriting\n // a compatible controller.\n this._sw = waitingSW;\n // Run this in the next microtask, so any code that adds an event\n // listener after awaiting `register()` will get this event.\n dontWaitFor(Promise.resolve().then(() => {\n this.dispatchEvent(new WorkboxEvent('waiting', {\n sw: waitingSW,\n wasWaitingBeforeRegister: true,\n }));\n if (process.env.NODE_ENV !== 'production') {\n logger.warn('A service worker was already waiting to activate ' +\n 'before this script was registered...');\n }\n }));\n }\n // If an \"own\" SW is already set, resolve the deferred.\n if (this._sw) {\n this._swDeferred.resolve(this._sw);\n this._ownSWs.add(this._sw);\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log('Successfully registered service worker.', this._scriptURL);\n if (navigator.serviceWorker.controller) {\n if (this._compatibleControllingSW) {\n logger.debug('A service worker with the same script URL ' +\n 'is already controlling this page.');\n }\n else {\n logger.debug('A service worker with a different script URL is ' +\n 'currently controlling the page. The browser is now fetching ' +\n 'the new script now...');\n }\n }\n const currentPageIsOutOfScope = () => {\n const scopeURL = new URL(this._registerOptions.scope || this._scriptURL, document.baseURI);\n const scopeURLBasePath = new URL('./', scopeURL.href).pathname;\n return !location.pathname.startsWith(scopeURLBasePath);\n };\n if (currentPageIsOutOfScope()) {\n logger.warn('The current page is not in scope for the registered ' +\n 'service worker. Was this a mistake?');\n }\n }\n this._registration.addEventListener('updatefound', this._onUpdateFound);\n navigator.serviceWorker.addEventListener('controllerchange', this._onControllerChange, { once: true });\n return this._registration;\n }\n /**\n * Checks for updates of the registered service worker.\n */\n async update() {\n if (!this._registration) {\n if (process.env.NODE_ENV !== 'production') {\n logger.error('Cannot update a Workbox instance without ' +\n 'being registered. Register the Workbox instance first.');\n }\n return;\n }\n // Try to update registration\n await this._registration.update();\n }\n /**\n * Resolves to the service worker registered by this instance as soon as it\n * is active. If a service worker was already controlling at registration\n * time then it will resolve to that if the script URLs (and optionally\n * script versions) match, otherwise it will wait until an update is found\n * and activates.\n *\n * @return {Promise<ServiceWorker>}\n */\n get active() {\n return this._activeDeferred.promise;\n }\n /**\n * Resolves to the service worker registered by this instance as soon as it\n * is controlling the page. If a service worker was already controlling at\n * registration time then it will resolve to that if the script URLs (and\n * optionally script versions) match, otherwise it will wait until an update\n * is found and starts controlling the page.\n * Note: the first time a service worker is installed it will active but\n * not start controlling the page unless `clients.claim()` is called in the\n * service worker.\n *\n * @return {Promise<ServiceWorker>}\n */\n get controlling() {\n return this._controllingDeferred.promise;\n }\n /**\n * Resolves with a reference to a service worker that matches the script URL\n * of this instance, as soon as it's available.\n *\n * If, at registration time, there's already an active or waiting service\n * worker with a matching script URL, it will be used (with the waiting\n * service worker taking precedence over the active service worker if both\n * match, since the waiting service worker would have been registered more\n * recently).\n * If there's no matching active or waiting service worker at registration\n * time then the promise will not resolve until an update is found and starts\n * installing, at which point the installing service worker is used.\n *\n * @return {Promise<ServiceWorker>}\n */\n async getSW() {\n // If `this._sw` is set, resolve with that as we want `getSW()` to\n // return the correct (new) service worker if an update is found.\n return this._sw !== undefined ? this._sw : this._swDeferred.promise;\n }\n /**\n * Sends the passed data object to the service worker registered by this\n * instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves\n * with a response (if any).\n *\n * A response can be set in a message handler in the service worker by\n * calling `event.ports[0].postMessage(...)`, which will resolve the promise\n * returned by `messageSW()`. If no response is set, the promise will never\n * resolve.\n *\n * @param {Object} data An object to send to the service worker\n * @return {Promise<Object>}\n */\n async messageSW(data) {\n const sw = await this.getSW();\n return messageSW(sw, data);\n }\n /**\n * Checks for a service worker already controlling the page and returns\n * it if its script URL matches.\n *\n * @private\n * @return {ServiceWorker|undefined}\n */\n _getControllingSWIfCompatible() {\n const controller = navigator.serviceWorker.controller;\n if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {\n return controller;\n }\n else {\n return undefined;\n }\n }\n /**\n * Registers a service worker for this instances script URL and register\n * options and tracks the time registration was complete.\n *\n * @private\n */\n async _registerScript() {\n try {\n const reg = await navigator.serviceWorker.register(this._scriptURL, this._registerOptions);\n // Keep track of when registration happened, so it can be used in the\n // `this._onUpdateFound` heuristic. Also use the presence of this\n // property as a way to see if `.register()` has been called.\n this._registrationTime = performance.now();\n return reg;\n }\n catch (error) {\n if (process.env.NODE_ENV !== 'production') {\n logger.error(error);\n }\n // Re-throw the error.\n throw error;\n }\n }\n}\nexport { Workbox };\n// The jsdoc comments below outline the events this instance may dispatch:\n// -----------------------------------------------------------------------\n/**\n * The `message` event is dispatched any time a `postMessage` is received.\n *\n * @event module:workbox-window.Workbox#message\n * @type {WorkboxEvent}\n * @property {*} data The `data` property from the original `message` event.\n * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}\n * event.\n * @property {string} type `message`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `installed` event is dispatched if the state of a\n * [`Workbox`]{@link module:workbox-window.Workbox} instance's\n * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}\n * changes to `installed`.\n *\n * Then can happen either the very first time a service worker is installed,\n * or after an update to the current service worker is found. In the case\n * of an update being found, the event's `isUpdate` property will be `true`.\n *\n * @event module:workbox-window.Workbox#installed\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {boolean|undefined} isUpdate True if a service worker was already\n * controlling when this `Workbox` instance called `register()`.\n * @property {string} type `installed`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `waiting` event is dispatched if the state of a\n * [`Workbox`]{@link module:workbox-window.Workbox} instance's\n * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}\n * changes to `installed` and then doesn't immediately change to `activating`.\n * It may also be dispatched if a service worker with the same\n * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}\n * was already waiting when the [`register()`]{@link module:workbox-window.Workbox#register}\n * method was called.\n *\n * @event module:workbox-window.Workbox#waiting\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event|undefined} originalEvent The original\n * [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event, or `undefined` in the case where the service worker was waiting\n * to before `.register()` was called.\n * @property {boolean|undefined} isUpdate True if a service worker was already\n * controlling when this `Workbox` instance called `register()`.\n * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with\n * a matching `scriptURL` was already waiting when this `Workbox`\n * instance called `register()`.\n * @property {string} type `waiting`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `controlling` event is dispatched if a\n * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}\n * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}\n * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}\n * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}\n * matches the `scriptURL` of the `Workbox` instance's\n * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.\n *\n * @event module:workbox-window.Workbox#controlling\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}\n * event.\n * @property {boolean|undefined} isUpdate True if a service worker was already\n * controlling when this service worker was registered.\n * @property {string} type `controlling`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `activated` event is dispatched if the state of a\n * [`Workbox`]{@link module:workbox-window.Workbox} instance's\n * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}\n * changes to `activated`.\n *\n * @event module:workbox-window.Workbox#activated\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {boolean|undefined} isUpdate True if a service worker was already\n * controlling when this `Workbox` instance called `register()`.\n * @property {string} type `activated`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `redundant` event is dispatched if the state of a\n * [`Workbox`]{@link module:workbox-window.Workbox} instance's\n * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}\n * changes to `redundant`.\n *\n * @event module:workbox-window.Workbox#redundant\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {boolean|undefined} isUpdate True if a service worker was already\n * controlling when this `Workbox` instance called `register()`.\n * @property {string} type `redundant`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `externalinstalled` event is dispatched if the state of an\n * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}\n * changes to `installed`.\n *\n * @event module:workbox-window.Workbox#externalinstalled\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {string} type `externalinstalled`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `externalwaiting` event is dispatched if the state of an\n * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}\n * changes to `waiting`.\n *\n * @event module:workbox-window.Workbox#externalwaiting\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {string} type `externalwaiting`.\n * @property {Workbox} target The `Workbox` instance.\n */\n/**\n * The `externalactivated` event is dispatched if the state of an\n * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}\n * changes to `activated`.\n *\n * @event module:workbox-window.Workbox#externalactivated\n * @type {WorkboxEvent}\n * @property {ServiceWorker} sw The service worker instance.\n * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}\n * event.\n * @property {string} type `externalactivated`.\n * @property {Workbox} target The `Workbox` instance.\n */\n"],"names":["self","_","e","messageSW","sw","data","Promise","resolve","messageChannel","MessageChannel","port1","onmessage","event","postMessage","port2","Deferred","constructor","promise","reject","dontWaitFor","then","logger","process","__WB_DISABLE_DEV_LOGS","inGroup","methodToColorMap","debug","log","warn","error","groupCollapsed","groupEnd","print","method","args","test","navigator","userAgent","console","styles","logPrefix","join","api","loggerMethods","Object","keys","key","WorkboxEventTarget","_eventListenerRegistry","Map","addEventListener","type","listener","foo","_getEventListenersByType","add","removeEventListener","delete","dispatchEvent","target","listeners","has","set","Set","get","urlsMatch","url1","url2","href","location","URL","WorkboxEvent","props","assign","WAITING_TIMEOUT_DURATION","REGISTRATION_TIMEOUT_DURATION","Workbox","scriptURL","registerOptions","_registerOptions","_updateFoundCount","_swDeferred","_activeDeferred","_controllingDeferred","_registrationTime","_ownSWs","_onUpdateFound","registration","_registration","installingSW","installing","updateLikelyTriggeredExternally","_scriptURL","performance","now","_externalSW","_sw","serviceWorker","controller","_onStateChange","originalEvent","state","isExternal","eventPrefix","eventProps","_isUpdate","isUpdate","_waitingTimeout","setTimeout","waiting","clearTimeout","_compatibleControllingSW","_onControllerChange","_onMessage","source","getSW","register","immediate","document","readyState","res","window","Boolean","_getControllingSWIfCompatible","_registerScript","once","waitingSW","wasWaitingBeforeRegister","currentPageIsOutOfScope","scopeURL","scope","baseURI","scopeURLBasePath","pathname","startsWith","update","active","controlling","undefined","reg"],"mappings":"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"}

data/lib/vendor/{workbox-v5.0.0 → workbox-v5.1.4}/workbox-window.dev.umd.js RENAMED

@@ -1,1086 +1,1136 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global.workbox = {}));
-}(this, function (exports) { 'use strict';
-    try {
-      self['workbox:window:5.0.0'] && _();
-    } catch (e) {}
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * Sends a data object to a service worker via `postMessage` and resolves with
-     * a response (if any).
-     *
-     * A response can be set in a message handler in the service worker by
-     * calling `event.ports[0].postMessage(...)`, which will resolve the promise
-     * returned by `messageSW()`. If no response is set, the promise will not
-     * resolve.
-     *
-     * @param {ServiceWorker} sw The service worker to send the message to.
-     * @param {Object} data An object to send to the service worker.
-     * @return {Promise<Object|undefined>}
-     * @memberof module:workbox-window
-     */
-    function messageSW(sw, data) {
-      return new Promise(function (resolve) {
-        var messageChannel = new MessageChannel();
-        messageChannel.port1.onmessage = function (event) {
-          resolve(event.data);
-        };
-        sw.postMessage(data, [messageChannel.port2]);
-      });
-    }
-    function _defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-      }
-    }
-    function _createClass(Constructor, protoProps, staticProps) {
-      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) _defineProperties(Constructor, staticProps);
-      return Constructor;
-    }
-    function _inheritsLoose(subClass, superClass) {
-      subClass.prototype = Object.create(superClass.prototype);
-      subClass.prototype.constructor = subClass;
-      subClass.__proto__ = superClass;
-    }
-    try {
-      self['workbox:core:5.0.0'] && _();
-    } catch (e) {}
-    /*
-      Copyright 2018 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * The Deferred class composes Promises in a way that allows for them to be
-     * resolved or rejected from outside the constructor. In most cases promises
-     * should be used directly, but Deferreds can be necessary when the logic to
-     * resolve a promise must be separate.
-     *
-     * @private
-     */
-    var Deferred =
-    /**
-     * Creates a promise and exposes its resolve and reject functions as methods.
-     */
-    function Deferred() {
-      var _this = this;
-      this.promise = new Promise(function (resolve, reject) {
-        _this.resolve = resolve;
-        _this.reject = reject;
-      });
-    };
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * A helper function that prevents a promise from being flagged as unused.
-     *
-     * @private
-     **/
-    function dontWaitFor(promise) {
-      // Effective no-op.
-      promise.then(function () {});
-    }
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    var logger =  function () {
-      // Don't overwrite this value if it's already set.
-      // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923
-      if (!('__WB_DISABLE_DEV_LOGS' in self)) {
-        self.__WB_DISABLE_DEV_LOGS = false;
-      }
-      var inGroup = false;
-      var methodToColorMap = {
-        debug: "#7f8c8d",
-        log: "#2ecc71",
-        warn: "#f39c12",
-        error: "#c0392b",
-        groupCollapsed: "#3498db",
-        groupEnd: null
-      };
-      var print = function print(method, args) {
-        var _console2;
-        if (self.__WB_DISABLE_DEV_LOGS) {
-          return;
-        }
-        if (method === 'groupCollapsed') {
-          // Safari doesn't print all console.groupCollapsed() arguments:
-          // https://bugs.webkit.org/show_bug.cgi?id=182754
-          if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
-            var _console;
-            (_console = console)[method].apply(_console, args);
-            return;
-          }
-        }
-        var styles = ["background: " + methodToColorMap[method], "border-radius: 0.5em", "color: white", "font-weight: bold", "padding: 2px 0.5em"]; // When in a group, the workbox prefix is not displayed.
-        var logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
-        (_console2 = console)[method].apply(_console2, logPrefix.concat(args));
-        if (method === 'groupCollapsed') {
-          inGroup = true;
-        }
-        if (method === 'groupEnd') {
-          inGroup = false;
-        }
-      };
-      var api = {};
-      var loggerMethods = Object.keys(methodToColorMap);
-      var _loop = function _loop() {
-        var key = _loggerMethods[_i];
-        var method = key;
-        api[method] = function () {
-          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-          }
-          print(method, args);
-        };
-      };
-      for (var _i = 0, _loggerMethods = loggerMethods; _i < _loggerMethods.length; _i++) {
-        _loop();
-      }
-      return api;
-    }();
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * A minimal `EventTarget` shim.
-     * This is necessary because not all browsers support constructable
-     * `EventTarget`, so using a real `EventTarget` will error.
-     * @private
-     */
-    var WorkboxEventTarget =
-    /*#__PURE__*/
-    function () {
-      function WorkboxEventTarget() {
-        this._eventListenerRegistry = new Map();
-      }
-      /**
-       * @param {string} type
-       * @param {Function} listener
-       * @private
-       */
-      var _proto = WorkboxEventTarget.prototype;
-      _proto.addEventListener = function addEventListener(type, listener) {
-        var foo = this._getEventListenersByType(type);
-        foo.add(listener);
-      }
-      /**
-       * @param {string} type
-       * @param {Function} listener
-       * @private
-       */
-      ;
-      _proto.removeEventListener = function removeEventListener(type, listener) {
-        this._getEventListenersByType(type).delete(listener);
-      }
-      /**
-       * @param {Object} event
-       * @private
-       */
-      ;
-      _proto.dispatchEvent = function dispatchEvent(event) {
-        event.target = this;
-        var listeners = this._getEventListenersByType(event.type);
-        for (var _iterator = listeners, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-          var _ref;
-          if (_isArray) {
-            if (_i >= _iterator.length) break;
-            _ref = _iterator[_i++];
-          } else {
-            _i = _iterator.next();
-            if (_i.done) break;
-            _ref = _i.value;
-          }
-          var listener = _ref;
-          listener(event);
-        }
-      }
-      /**
-       * Returns a Set of listeners associated with the passed event type.
-       * If no handlers have been registered, an empty Set is returned.
-       *
-       * @param {string} type The event type.
-       * @return {Set<ListenerCallback>} An array of handler functions.
-       * @private
-       */
-      ;
-      _proto._getEventListenersByType = function _getEventListenersByType(type) {
-        if (!this._eventListenerRegistry.has(type)) {
-          this._eventListenerRegistry.set(type, new Set());
-        }
-        return this._eventListenerRegistry.get(type);
-      };
-      return WorkboxEventTarget;
-    }();
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * Returns true if two URLs have the same `.href` property. The URLS can be
-     * relative, and if they are the current location href is used to resolve URLs.
-     *
-     * @private
-     * @param {string} url1
-     * @param {string} url2
-     * @return {boolean}
-     */
-    function urlsMatch(url1, url2) {
-      var _location = location,
-          href = _location.href;
-      return new URL(url1, href).href === new URL(url2, href).href;
-    }
-    /*
-      Copyright 2019 Google LLC
-      Use of this source code is governed by an MIT-style
-      license that can be found in the LICENSE file or at
-      https://opensource.org/licenses/MIT.
-    */
-    /**
-     * A minimal `Event` subclass shim.
-     * This doesn't *actually* subclass `Event` because not all browsers support
-     * constructable `EventTarget`, and using a real `Event` will error.
-     * @private
-     */
-    var WorkboxEvent = function WorkboxEvent(type, props) {
-      this.type = type;
-      Object.assign(this, props);
-    };
-    // `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
-    // chosen, but it seems to avoid false positives in my testing.
-    function _await(value, then, direct) {
-      if (direct) {
-        return then ? then(value) : value;
-      }
-      if (!value || !value.then) {
-        value = Promise.resolve(value);
-      }
-      return then ? value.then(then) : value;
-    }
-    var WAITING_TIMEOUT_DURATION = 200; // The amount of time after a registration that we can reasonably conclude
-    // that the registration didn't trigger an update.
-    function _async(f) {
-      return function () {
-        for (var args = [], i = 0; i < arguments.length; i++) {
-          args[i] = arguments[i];
-        }
-        try {
-          return Promise.resolve(f.apply(this, args));
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
-    }
-    var REGISTRATION_TIMEOUT_DURATION = 60000;
-    /**
-     * A class to aid in handling service worker registration, updates, and
-     * reacting to service worker lifecycle events.
-     *
-     * @fires [message]{@link module:workbox-window.Workbox#message}
-     * @fires [installed]{@link module:workbox-window.Workbox#installed}
-     * @fires [waiting]{@link module:workbox-window.Workbox#waiting}
-     * @fires [controlling]{@link module:workbox-window.Workbox#controlling}
-     * @fires [activated]{@link module:workbox-window.Workbox#activated}
-     * @fires [redundant]{@link module:workbox-window.Workbox#redundant}
-     * @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}
-     * @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}
-     * @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}
-     * @memberof module:workbox-window
-     */
-    function _empty() {}
-    var Workbox =
-    /*#__PURE__*/
-    function (_WorkboxEventTarget) {
-      _inheritsLoose(Workbox, _WorkboxEventTarget);
-      /**
-       * Creates a new Workbox instance with a script URL and service worker
-       * options. The script URL and options are the same as those used when
-       * calling `navigator.serviceWorker.register(scriptURL, options)`. See:
-       * https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register
-       *
-       * @param {string} scriptURL The service worker script associated with this
-       *     instance.
-       * @param {Object} [registerOptions] The service worker options associated
-       *     with this instance.
-       */
-      function Workbox(scriptURL, registerOptions) {
-        var _this;
-        if (registerOptions === void 0) {
-          registerOptions = {};
-        }
-        _this = _WorkboxEventTarget.call(this) || this;
-        _this._registerOptions = {};
-        _this._updateFoundCount = 0; // Deferreds we can resolve later.
-        _this._swDeferred = new Deferred();
-        _this._activeDeferred = new Deferred();
-        _this._controllingDeferred = new Deferred();
-        _this._registrationTime = 0;
-        _this._ownSWs = new Set();
-        /**
-         * @private
-         */
-        _this._onUpdateFound = function () {
-          // `this._registration` will never be `undefined` after an update is found.
-          var registration = _this._registration;
-          var installingSW = registration.installing; // If the script URL passed to `navigator.serviceWorker.register()` is
-          // different from the current controlling SW's script URL, we know any
-          // successful registration calls will trigger an `updatefound` event.
-          // But if the registered script URL is the same as the current controlling
-          // SW's script URL, we'll only get an `updatefound` event if the file
-          // changed since it was last registered. This can be a problem if the user
-          // opens up the same page in a different tab, and that page registers
-          // a SW that triggers an update. It's a problem because this page has no
-          // good way of knowing whether the `updatefound` event came from the SW
-          // script it registered or from a registration attempt made by a newer
-          // version of the page running in another tab.
-          // To minimize the possibility of a false positive, we use the logic here:
-          var updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
-          // add the `updatefound` event listener until the `register()` call, if
-          // `_updateFoundCount` is > 0 then it means this method has already
-          // been called, thus this SW must be external
-          _this._updateFoundCount > 0 || // If the script URL of the installing SW is different from this
-          // instance's script URL, we know it's definitely not from our
-          // registration.
-          !urlsMatch(installingSW.scriptURL, _this._scriptURL) || // If all of the above are false, then we use a time-based heuristic:
-          // Any `updatefound` event that occurs long after our registration is
-          // assumed to be external.
-          performance.now() > _this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // If any of the above are not true, we assume the update was
-          // triggered by this instance.
-          true : false;
-          if (updateLikelyTriggeredExternally) {
-            _this._externalSW = installingSW;
-            registration.removeEventListener('updatefound', _this._onUpdateFound);
-          } else {
-            // If the update was not triggered externally we know the installing
-            // SW is the one we registered, so we set it.
-            _this._sw = installingSW;
-            _this._ownSWs.add(installingSW);
-            _this._swDeferred.resolve(installingSW); // The `installing` state isn't something we have a dedicated
-            // callback for, but we do log messages for it in development.
-            {
-              if (navigator.serviceWorker.controller) {
-                logger.log('Updated service worker found. Installing now...');
-              } else {
-                logger.log('Service worker is installing...');
-              }
-            }
-          } // Increment the `updatefound` count, so future invocations of this
-          // method can be sure they were triggered externally.
-          ++_this._updateFoundCount; // Add a `statechange` listener regardless of whether this update was
-          // triggered externally, since we have callbacks for both.
-          installingSW.addEventListener('statechange', _this._onStateChange);
-        };
-        /**
-         * @private
-         * @param {Event} originalEvent
-         */
-        _this._onStateChange = function (originalEvent) {
-          // `this._registration` will never be `undefined` after an update is found.
-          var registration = _this._registration;
-          var sw = originalEvent.target;
-          var state = sw.state;
-          var isExternal = sw === _this._externalSW;
-          var eventPrefix = isExternal ? 'external' : '';
-          var eventProps = {
-            sw: sw,
-            originalEvent: originalEvent
-          };
-          if (!isExternal && _this._isUpdate) {
-            eventProps.isUpdate = true;
-          }
-          _this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));
-          if (state === 'installed') {
-            // This timeout is used to ignore cases where the service worker calls
-            // `skipWaiting()` in the install event, thus moving it directly in the
-            // activating state. (Since all service workers *must* go through the
-            // waiting phase, the only way to detect `skipWaiting()` called in the
-            // install event is to observe that the time spent in the waiting phase
-            // is very short.)
-            // NOTE: we don't need separate timeouts for the own and external SWs
-            // since they can't go through these phases at the same time.
-            _this._waitingTimeout = self.setTimeout(function () {
-              // Ensure the SW is still waiting (it may now be redundant).
-              if (state === 'installed' && registration.waiting === sw) {
-                _this.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));
-                {
-                  if (isExternal) {
-                    logger.warn('An external service worker has installed but is ' + 'waiting for this client to close before activating...');
-                  } else {
-                    logger.warn('The service worker has installed but is waiting ' + 'for existing clients to close before activating...');
-                  }
-                }
-              }
-            }, WAITING_TIMEOUT_DURATION);
-          } else if (state === 'activating') {
-            clearTimeout(_this._waitingTimeout);
-            if (!isExternal) {
-              _this._activeDeferred.resolve(sw);
-            }
-          }
-          {
-            switch (state) {
-              case 'installed':
-                if (isExternal) {
-                  logger.warn('An external service worker has installed. ' + 'You may want to suggest users reload this page.');
-                } else {
-                  logger.log('Registered service worker installed.');
-                }
-                break;
-              case 'activated':
-                if (isExternal) {
-                  logger.warn('An external service worker has activated.');
-                } else {
-                  logger.log('Registered service worker activated.');
-                  if (sw !== navigator.serviceWorker.controller) {
-                    logger.warn('The registered service worker is active but ' + 'not yet controlling the page. Reload or run ' + '`clients.claim()` in the service worker.');
-                  }
-                }
-                break;
-              case 'redundant':
-                if (sw === _this._compatibleControllingSW) {
-                  logger.log('Previously controlling service worker now redundant!');
-                } else if (!isExternal) {
-                  logger.log('Registered service worker now redundant!');
-                }
-                break;
-            }
-          }
-        };
-        /**
-         * @private
-         * @param {Event} originalEvent
-         */
-        _this._onControllerChange = function (originalEvent) {
-          var sw = _this._sw;
-          if (sw === navigator.serviceWorker.controller) {
-            _this.dispatchEvent(new WorkboxEvent('controlling', {
-              sw: sw,
-              originalEvent: originalEvent,
-              isUpdate: _this._isUpdate
-            }));
-            {
-              logger.log('Registered service worker now controlling this page.');
-            }
-            _this._controllingDeferred.resolve(sw);
-          }
-        };
-        /**
-         * @private
-         * @param {Event} originalEvent
-         */
-        _this._onMessage = _async(function (originalEvent) {
-          var data = originalEvent.data,
-              source = originalEvent.source; // Wait until there's an "own" service worker. This is used to buffer
-          // `message` events that may be received prior to calling `register()`.
-          return _await(_this.getSW(), function () {
-            if (_this._ownSWs.has(source)) {
-              _this.dispatchEvent(new WorkboxEvent('message', {
-                data: data,
-                sw: source,
-                originalEvent: originalEvent
-              }));
-            }
-          }); // If the service worker that sent the message is in the list of own
-          // service workers for this instance, dispatch a `message` event.
-          // NOTE: we check for all previously owned service workers rather than
-          // just the current one because some messages (e.g. cache updates) use
-          // a timeout when sent and may be delayed long enough for a service worker
-          // update to be found.
-        });
-        _this._scriptURL = scriptURL;
-        _this._registerOptions = registerOptions; // Add a message listener immediately since messages received during
-        // page load are buffered only until the DOMContentLoaded event:
-        // https://github.com/GoogleChrome/workbox/issues/2202
-        navigator.serviceWorker.addEventListener('message', _this._onMessage);
-        return _this;
-      }
-      /**
-       * Registers a service worker for this instances script URL and service
-       * worker options. By default this method delays registration until after
-       * the window has loaded.
-       *
-       * @param {Object} [options]
-       * @param {Function} [options.immediate=false] Setting this to true will
-       *     register the service worker immediately, even if the window has
-       *     not loaded (not recommended).
-       */
-      var _proto = Workbox.prototype;
-      _proto.register = _async(function (_temp) {
-        var _this2 = this;
-        var _ref = _temp === void 0 ? {} : _temp,
-            _ref$immediate = _ref.immediate,
-            immediate = _ref$immediate === void 0 ? false : _ref$immediate;
-        {
-          if (_this2._registrationTime) {
-            logger.error('Cannot re-register a Workbox instance after it has ' + 'been registered. Create a new instance instead.');
-            return;
-          }
-        }
-        return _invoke(function () {
-          if (!immediate && document.readyState !== 'complete') {
-            return _awaitIgnored(new Promise(function (res) {
-              return window.addEventListener('load', res);
-            }));
-          }
-        }, function () {
-          // Set this flag to true if any service worker was controlling the page
-          // at registration time.
-          _this2._isUpdate = Boolean(navigator.serviceWorker.controller); // Before registering, attempt to determine if a SW is already controlling
-          // the page, and if that SW script (and version, if specified) matches this
-          // instance's script.
-          _this2._compatibleControllingSW = _this2._getControllingSWIfCompatible();
-          return _await(_this2._registerScript(), function (_this2$_registerScrip) {
-            _this2._registration = _this2$_registerScrip;
-            // If we have a compatible controller, store the controller as the "own"
-            // SW, resolve active/controlling deferreds and add necessary listeners.
-            if (_this2._compatibleControllingSW) {
-              _this2._sw = _this2._compatibleControllingSW;
-              _this2._activeDeferred.resolve(_this2._compatibleControllingSW);
-              _this2._controllingDeferred.resolve(_this2._compatibleControllingSW);
-              _this2._compatibleControllingSW.addEventListener('statechange', _this2._onStateChange, {
-                once: true
-              });
-            } // If there's a waiting service worker with a matching URL before the
-            // `updatefound` event fires, it likely means that this site is open
-            // in another tab, or the user refreshed the page (and thus the previous
-            // page wasn't fully unloaded before this page started loading).
-            // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
-            var waitingSW = _this2._registration.waiting;
-            if (waitingSW && urlsMatch(waitingSW.scriptURL, _this2._scriptURL)) {
-              // Store the waiting SW as the "own" Sw, even if it means overwriting
-              // a compatible controller.
-              _this2._sw = waitingSW; // Run this in the next microtask, so any code that adds an event
-              // listener after awaiting `register()` will get this event.
-              dontWaitFor(Promise.resolve().then(function () {
-                _this2.dispatchEvent(new WorkboxEvent('waiting', {
-                  sw: waitingSW,
-                  wasWaitingBeforeRegister: true
-                }));
-                {
-                  logger.warn('A service worker was already waiting to activate ' + 'before this script was registered...');
-                }
-              }));
-            } // If an "own" SW is already set, resolve the deferred.
-            if (_this2._sw) {
-              _this2._swDeferred.resolve(_this2._sw);
-              _this2._ownSWs.add(_this2._sw);
-            }
-            {
-              logger.log('Successfully registered service worker.', _this2._scriptURL);
-              if (navigator.serviceWorker.controller) {
-                if (_this2._compatibleControllingSW) {
-                  logger.debug('A service worker with the same script URL ' + 'is already controlling this page.');
-                } else {
-                  logger.debug('A service worker with a different script URL is ' + 'currently controlling the page. The browser is now fetching ' + 'the new script now...');
-                }
-              }
-              var currentPageIsOutOfScope = function currentPageIsOutOfScope() {
-                var scopeURL = new URL(_this2._registerOptions.scope || _this2._scriptURL, document.baseURI);
-                var scopeURLBasePath = new URL('./', scopeURL.href).pathname;
-                return !location.pathname.startsWith(scopeURLBasePath);
-              };
-              if (currentPageIsOutOfScope()) {
-                logger.warn('The current page is not in scope for the registered ' + 'service worker. Was this a mistake?');
-              }
-            }
-            _this2._registration.addEventListener('updatefound', _this2._onUpdateFound);
-            navigator.serviceWorker.addEventListener('controllerchange', _this2._onControllerChange, {
-              once: true
-            });
-            return _this2._registration;
-          });
-        });
-      })
-      /**
-       * Checks for updates of the registered service worker.
-       */
-      ;
-      _proto.update = _async(function () {
-        var _this3 = this;
-        if (!_this3._registration) {
-          {
-            logger.error('Cannot update a Workbox instance without ' + 'being registered. Register the Workbox instance first.');
-          }
-          return;
-        } // Try to update registration
-        return _awaitIgnored(_this3._registration.update());
-      })
-      /**
-       * Resolves to the service worker registered by this instance as soon as it
-       * is active. If a service worker was already controlling at registration
-       * time then it will resolve to that if the script URLs (and optionally
-       * script versions) match, otherwise it will wait until an update is found
-       * and activates.
-       *
-       * @return {Promise<ServiceWorker>}
-       */
-      ;
-      /**
-       * Resolves with a reference to a service worker that matches the script URL
-       * of this instance, as soon as it's available.
-       *
-       * If, at registration time, there's already an active or waiting service
-       * worker with a matching script URL, it will be used (with the waiting
-       * service worker taking precedence over the active service worker if both
-       * match, since the waiting service worker would have been registered more
-       * recently).
-       * If there's no matching active or waiting service worker at registration
-       * time then the promise will not resolve until an update is found and starts
-       * installing, at which point the installing service worker is used.
-       *
-       * @return {Promise<ServiceWorker>}
-       */
-      _proto.getSW = _async(function () {
-        var _this4 = this;
-        // If `this._sw` is set, resolve with that as we want `getSW()` to
-        // return the correct (new) service worker if an update is found.
-        return _this4._sw !== undefined ? _this4._sw : _this4._swDeferred.promise;
-      })
-      /**
-       * Sends the passed data object to the service worker registered by this
-       * instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves
-       * with a response (if any).
-       *
-       * A response can be set in a message handler in the service worker by
-       * calling `event.ports[0].postMessage(...)`, which will resolve the promise
-       * returned by `messageSW()`. If no response is set, the promise will never
-       * resolve.
-       *
-       * @param {Object} data An object to send to the service worker
-       * @return {Promise<Object>}
-       */
-      ;
-      _proto.messageSW = _async(function (data) {
-        var _this5 = this;
-        return _await(_this5.getSW(), function (sw) {
-          return messageSW(sw, data);
-        });
-      })
-      /**
-       * Checks for a service worker already controlling the page and returns
-       * it if its script URL matches.
-       *
-       * @private
-       * @return {ServiceWorker|undefined}
-       */
-      ;
-      _proto._getControllingSWIfCompatible = function _getControllingSWIfCompatible() {
-        var controller = navigator.serviceWorker.controller;
-        if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {
-          return controller;
-        } else {
-          return undefined;
-        }
-      }
-      /**
-       * Registers a service worker for this instances script URL and register
-       * options and tracks the time registration was complete.
-       *
-       * @private
-       */
-      ;
-      _proto._registerScript = _async(function () {
-        var _this6 = this;
-        return _catch(function () {
-          return _await(navigator.serviceWorker.register(_this6._scriptURL, _this6._registerOptions), function (reg) {
-            // Keep track of when registration happened, so it can be used in the
-            // `this._onUpdateFound` heuristic. Also use the presence of this
-            // property as a way to see if `.register()` has been called.
-            _this6._registrationTime = performance.now();
-            return reg;
-          });
-        }, function (error) {
-          {
-            logger.error(error);
-          } // Re-throw the error.
-          throw error;
-        });
-      });
-      _createClass(Workbox, [{
-        key: "active",
-        get: function get() {
-          return this._activeDeferred.promise;
-        }
-        /**
-         * Resolves to the service worker registered by this instance as soon as it
-         * is controlling the page. If a service worker was already controlling at
-         * registration time then it will resolve to that if the script URLs (and
-         * optionally script versions) match, otherwise it will wait until an update
-         * is found and starts controlling the page.
-         * Note: the first time a service worker is installed it will active but
-         * not start controlling the page unless `clients.claim()` is called in the
-         * service worker.
-         *
-         * @return {Promise<ServiceWorker>}
-         */
-      }, {
-        key: "controlling",
-        get: function get() {
-          return this._controllingDeferred.promise;
-        }
-      }]);
-      return Workbox;
-    }(WorkboxEventTarget);
-    function _awaitIgnored(value, direct) {
-      if (!direct) {
-        return value && value.then ? value.then(_empty) : Promise.resolve();
-      }
-    } // The jsdoc comments below outline the events this instance may dispatch:
-    // -----------------------------------------------------------------------
-    /**
-     * The `message` event is dispatched any time a `postMessage` is received.
-     *
-     * @event module:workbox-window.Workbox#message
-     * @type {WorkboxEvent}
-     * @property {*} data The `data` property from the original `message` event.
-     * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
-     *     event.
-     * @property {string} type `message`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `installed` event is dispatched if the state of a
-     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
-     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
-     * changes to `installed`.
-     *
-     * Then can happen either the very first time a service worker is installed,
-     * or after an update to the current service worker is found. In the case
-     * of an update being found, the event's `isUpdate` property will be `true`.
-     *
-     * @event module:workbox-window.Workbox#installed
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {boolean|undefined} isUpdate True if a service worker was already
-     *     controlling when this `Workbox` instance called `register()`.
-     * @property {string} type `installed`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `waiting` event is dispatched if the state of a
-     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
-     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
-     * changes to `installed` and then doesn't immediately change to `activating`.
-     * It may also be dispatched if a service worker with the same
-     * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
-     * was already waiting when the [`register()`]{@link module:workbox-window.Workbox#register}
-     * method was called.
-     *
-     * @event module:workbox-window.Workbox#waiting
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event|undefined} originalEvent The original
-     *    [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event, or `undefined` in the case where the service worker was waiting
-     *     to before `.register()` was called.
-     * @property {boolean|undefined} isUpdate True if a service worker was already
-     *     controlling when this `Workbox` instance called `register()`.
-     * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with
-     *     a matching `scriptURL` was already waiting when this `Workbox`
-     *     instance called `register()`.
-     * @property {string} type `waiting`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `controlling` event is dispatched if a
-     * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
-     * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}
-     * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
-     * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}
-     * matches the `scriptURL` of the `Workbox` instance's
-     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.
-     *
-     * @event module:workbox-window.Workbox#controlling
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
-     *     event.
-     * @property {boolean|undefined} isUpdate True if a service worker was already
-     *     controlling when this service worker was registered.
-     * @property {string} type `controlling`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `activated` event is dispatched if the state of a
-     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
-     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
-     * changes to `activated`.
-     *
-     * @event module:workbox-window.Workbox#activated
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {boolean|undefined} isUpdate True if a service worker was already
-     *     controlling when this `Workbox` instance called `register()`.
-     * @property {string} type `activated`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `redundant` event is dispatched if the state of a
-     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
-     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
-     * changes to `redundant`.
-     *
-     * @event module:workbox-window.Workbox#redundant
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {boolean|undefined} isUpdate True if a service worker was already
-     *     controlling when this `Workbox` instance called `register()`.
-     * @property {string} type `redundant`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `externalinstalled` event is dispatched if the state of an
-     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
-     * changes to `installed`.
-     *
-     * @event module:workbox-window.Workbox#externalinstalled
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {string} type `externalinstalled`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `externalwaiting` event is dispatched if the state of an
-     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
-     * changes to `waiting`.
-     *
-     * @event module:workbox-window.Workbox#externalwaiting
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {string} type `externalwaiting`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    /**
-     * The `externalactivated` event is dispatched if the state of an
-     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
-     * changes to `activated`.
-     *
-     * @event module:workbox-window.Workbox#externalactivated
-     * @type {WorkboxEvent}
-     * @property {ServiceWorker} sw The service worker instance.
-     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
-     *     event.
-     * @property {string} type `externalactivated`.
-     * @property {Workbox} target The `Workbox` instance.
-     */
-    function _invoke(body, then) {
-      var result = body();
-      if (result && result.then) {
-        return result.then(then);
-      }
-      return then(result);
-    }
-    function _catch(body, recover) {
-      try {
-        var result = body();
-      } catch (e) {
-        return recover(e);
-      }
-      if (result && result.then) {
-        return result.then(void 0, recover);
-      }
-      return result;
-    }
-    exports.Workbox = Workbox;
-    exports.messageSW = messageSW;
-    Object.defineProperty(exports, '__esModule', { value: true });
-}));
-//# sourceMappingURL=workbox-window.dev.umd.js.map
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = global || self, factory(global.workbox = {}));
+}(this, (function (exports) { 'use strict';
+    try {
+      self['workbox:window:5.1.4'] && _();
+    } catch (e) {}
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * Sends a data object to a service worker via `postMessage` and resolves with
+     * a response (if any).
+     *
+     * A response can be set in a message handler in the service worker by
+     * calling `event.ports[0].postMessage(...)`, which will resolve the promise
+     * returned by `messageSW()`. If no response is set, the promise will not
+     * resolve.
+     *
+     * @param {ServiceWorker} sw The service worker to send the message to.
+     * @param {Object} data An object to send to the service worker.
+     * @return {Promise<Object|undefined>}
+     * @memberof module:workbox-window
+     */
+    function messageSW(sw, data) {
+      return new Promise(function (resolve) {
+        var messageChannel = new MessageChannel();
+        messageChannel.port1.onmessage = function (event) {
+          resolve(event.data);
+        };
+        sw.postMessage(data, [messageChannel.port2]);
+      });
+    }
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      return Constructor;
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      subClass.__proto__ = superClass;
+    }
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+    }
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+      return arr2;
+    }
+    function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+      var it;
+      if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+          if (it) o = it;
+          var i = 0;
+          return function () {
+            if (i >= o.length) return {
+              done: true
+            };
+            return {
+              done: false,
+              value: o[i++]
+            };
+          };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+      }
+      it = o[Symbol.iterator]();
+      return it.next.bind(it);
+    }
+    try {
+      self['workbox:core:5.1.4'] && _();
+    } catch (e) {}
+    /*
+      Copyright 2018 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * The Deferred class composes Promises in a way that allows for them to be
+     * resolved or rejected from outside the constructor. In most cases promises
+     * should be used directly, but Deferreds can be necessary when the logic to
+     * resolve a promise must be separate.
+     *
+     * @private
+     */
+    var Deferred =
+    /**
+     * Creates a promise and exposes its resolve and reject functions as methods.
+     */
+    function Deferred() {
+      var _this = this;
+      this.promise = new Promise(function (resolve, reject) {
+        _this.resolve = resolve;
+        _this.reject = reject;
+      });
+    };
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * A helper function that prevents a promise from being flagged as unused.
+     *
+     * @private
+     **/
+    function dontWaitFor(promise) {
+      // Effective no-op.
+      promise.then(function () {});
+    }
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    var logger =  function () {
+      // Don't overwrite this value if it's already set.
+      // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923
+      if (!('__WB_DISABLE_DEV_LOGS' in self)) {
+        self.__WB_DISABLE_DEV_LOGS = false;
+      }
+      var inGroup = false;
+      var methodToColorMap = {
+        debug: "#7f8c8d",
+        log: "#2ecc71",
+        warn: "#f39c12",
+        error: "#c0392b",
+        groupCollapsed: "#3498db",
+        groupEnd: null
+      };
+      var print = function print(method, args) {
+        var _console2;
+        if (self.__WB_DISABLE_DEV_LOGS) {
+          return;
+        }
+        if (method === 'groupCollapsed') {
+          // Safari doesn't print all console.groupCollapsed() arguments:
+          // https://bugs.webkit.org/show_bug.cgi?id=182754
+          if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+            var _console;
+            (_console = console)[method].apply(_console, args);
+            return;
+          }
+        }
+        var styles = ["background: " + methodToColorMap[method], "border-radius: 0.5em", "color: white", "font-weight: bold", "padding: 2px 0.5em"]; // When in a group, the workbox prefix is not displayed.
+        var logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
+        (_console2 = console)[method].apply(_console2, logPrefix.concat(args));
+        if (method === 'groupCollapsed') {
+          inGroup = true;
+        }
+        if (method === 'groupEnd') {
+          inGroup = false;
+        }
+      };
+      var api = {};
+      var loggerMethods = Object.keys(methodToColorMap);
+      var _loop = function _loop() {
+        var key = _loggerMethods[_i];
+        var method = key;
+        api[method] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          print(method, args);
+        };
+      };
+      for (var _i = 0, _loggerMethods = loggerMethods; _i < _loggerMethods.length; _i++) {
+        _loop();
+      }
+      return api;
+    }();
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * A minimal `EventTarget` shim.
+     * This is necessary because not all browsers support constructable
+     * `EventTarget`, so using a real `EventTarget` will error.
+     * @private
+     */
+    var WorkboxEventTarget = /*#__PURE__*/function () {
+      function WorkboxEventTarget() {
+        this._eventListenerRegistry = new Map();
+      }
+      /**
+       * @param {string} type
+       * @param {Function} listener
+       * @private
+       */
+      var _proto = WorkboxEventTarget.prototype;
+      _proto.addEventListener = function addEventListener(type, listener) {
+        var foo = this._getEventListenersByType(type);
+        foo.add(listener);
+      }
+      /**
+       * @param {string} type
+       * @param {Function} listener
+       * @private
+       */
+      ;
+      _proto.removeEventListener = function removeEventListener(type, listener) {
+        this._getEventListenersByType(type).delete(listener);
+      }
+      /**
+       * @param {Object} event
+       * @private
+       */
+      ;
+      _proto.dispatchEvent = function dispatchEvent(event) {
+        event.target = this;
+        var listeners = this._getEventListenersByType(event.type);
+        for (var _iterator = _createForOfIteratorHelperLoose(listeners), _step; !(_step = _iterator()).done;) {
+          var listener = _step.value;
+          listener(event);
+        }
+      }
+      /**
+       * Returns a Set of listeners associated with the passed event type.
+       * If no handlers have been registered, an empty Set is returned.
+       *
+       * @param {string} type The event type.
+       * @return {Set<ListenerCallback>} An array of handler functions.
+       * @private
+       */
+      ;
+      _proto._getEventListenersByType = function _getEventListenersByType(type) {
+        if (!this._eventListenerRegistry.has(type)) {
+          this._eventListenerRegistry.set(type, new Set());
+        }
+        return this._eventListenerRegistry.get(type);
+      };
+      return WorkboxEventTarget;
+    }();
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * Returns true if two URLs have the same `.href` property. The URLS can be
+     * relative, and if they are the current location href is used to resolve URLs.
+     *
+     * @private
+     * @param {string} url1
+     * @param {string} url2
+     * @return {boolean}
+     */
+    function urlsMatch(url1, url2) {
+      var _location = location,
+          href = _location.href;
+      return new URL(url1, href).href === new URL(url2, href).href;
+    }
+    /*
+      Copyright 2019 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * A minimal `Event` subclass shim.
+     * This doesn't *actually* subclass `Event` because not all browsers support
+     * constructable `EventTarget`, and using a real `Event` will error.
+     * @private
+     */
+    var WorkboxEvent = function WorkboxEvent(type, props) {
+      this.type = type;
+      Object.assign(this, props);
+    };
+    // `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
+    // chosen, but it seems to avoid false positives in my testing.
+    function _await(value, then, direct) {
+      if (direct) {
+        return then ? then(value) : value;
+      }
+      if (!value || !value.then) {
+        value = Promise.resolve(value);
+      }
+      return then ? value.then(then) : value;
+    }
+    var WAITING_TIMEOUT_DURATION = 200; // The amount of time after a registration that we can reasonably conclude
+    // that the registration didn't trigger an update.
+    function _async(f) {
+      return function () {
+        for (var args = [], i = 0; i < arguments.length; i++) {
+          args[i] = arguments[i];
+        }
+        try {
+          return Promise.resolve(f.apply(this, args));
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+    }
+    var REGISTRATION_TIMEOUT_DURATION = 60000;
+    /**
+     * A class to aid in handling service worker registration, updates, and
+     * reacting to service worker lifecycle events.
+     *
+     * @fires [message]{@link module:workbox-window.Workbox#message}
+     * @fires [installed]{@link module:workbox-window.Workbox#installed}
+     * @fires [waiting]{@link module:workbox-window.Workbox#waiting}
+     * @fires [controlling]{@link module:workbox-window.Workbox#controlling}
+     * @fires [activated]{@link module:workbox-window.Workbox#activated}
+     * @fires [redundant]{@link module:workbox-window.Workbox#redundant}
+     * @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}
+     * @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}
+     * @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}
+     * @memberof module:workbox-window
+     */
+    function _empty() {}
+    var Workbox = /*#__PURE__*/function (_WorkboxEventTarget) {
+      _inheritsLoose(Workbox, _WorkboxEventTarget);
+      /**
+       * Creates a new Workbox instance with a script URL and service worker
+       * options. The script URL and options are the same as those used when
+       * calling `navigator.serviceWorker.register(scriptURL, options)`. See:
+       * https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register
+       *
+       * @param {string} scriptURL The service worker script associated with this
+       *     instance.
+       * @param {Object} [registerOptions] The service worker options associated
+       *     with this instance.
+       */
+      function Workbox(scriptURL, registerOptions) {
+        var _this;
+        if (registerOptions === void 0) {
+          registerOptions = {};
+        }
+        _this = _WorkboxEventTarget.call(this) || this;
+        _this._registerOptions = {};
+        _this._updateFoundCount = 0; // Deferreds we can resolve later.
+        _this._swDeferred = new Deferred();
+        _this._activeDeferred = new Deferred();
+        _this._controllingDeferred = new Deferred();
+        _this._registrationTime = 0;
+        _this._ownSWs = new Set();
+        /**
+         * @private
+         */
+        _this._onUpdateFound = function () {
+          // `this._registration` will never be `undefined` after an update is found.
+          var registration = _this._registration;
+          var installingSW = registration.installing; // If the script URL passed to `navigator.serviceWorker.register()` is
+          // different from the current controlling SW's script URL, we know any
+          // successful registration calls will trigger an `updatefound` event.
+          // But if the registered script URL is the same as the current controlling
+          // SW's script URL, we'll only get an `updatefound` event if the file
+          // changed since it was last registered. This can be a problem if the user
+          // opens up the same page in a different tab, and that page registers
+          // a SW that triggers an update. It's a problem because this page has no
+          // good way of knowing whether the `updatefound` event came from the SW
+          // script it registered or from a registration attempt made by a newer
+          // version of the page running in another tab.
+          // To minimize the possibility of a false positive, we use the logic here:
+          var updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
+          // add the `updatefound` event listener until the `register()` call, if
+          // `_updateFoundCount` is > 0 then it means this method has already
+          // been called, thus this SW must be external
+          _this._updateFoundCount > 0 || // If the script URL of the installing SW is different from this
+          // instance's script URL, we know it's definitely not from our
+          // registration.
+          !urlsMatch(installingSW.scriptURL, _this._scriptURL) || // If all of the above are false, then we use a time-based heuristic:
+          // Any `updatefound` event that occurs long after our registration is
+          // assumed to be external.
+          performance.now() > _this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // If any of the above are not true, we assume the update was
+          // triggered by this instance.
+          true : false;
+          if (updateLikelyTriggeredExternally) {
+            _this._externalSW = installingSW;
+            registration.removeEventListener('updatefound', _this._onUpdateFound);
+          } else {
+            // If the update was not triggered externally we know the installing
+            // SW is the one we registered, so we set it.
+            _this._sw = installingSW;
+            _this._ownSWs.add(installingSW);
+            _this._swDeferred.resolve(installingSW); // The `installing` state isn't something we have a dedicated
+            // callback for, but we do log messages for it in development.
+            {
+              if (navigator.serviceWorker.controller) {
+                logger.log('Updated service worker found. Installing now...');
+              } else {
+                logger.log('Service worker is installing...');
+              }
+            }
+          } // Increment the `updatefound` count, so future invocations of this
+          // method can be sure they were triggered externally.
+          ++_this._updateFoundCount; // Add a `statechange` listener regardless of whether this update was
+          // triggered externally, since we have callbacks for both.
+          installingSW.addEventListener('statechange', _this._onStateChange);
+        };
+        /**
+         * @private
+         * @param {Event} originalEvent
+         */
+        _this._onStateChange = function (originalEvent) {
+          // `this._registration` will never be `undefined` after an update is found.
+          var registration = _this._registration;
+          var sw = originalEvent.target;
+          var state = sw.state;
+          var isExternal = sw === _this._externalSW;
+          var eventPrefix = isExternal ? 'external' : '';
+          var eventProps = {
+            sw: sw,
+            originalEvent: originalEvent
+          };
+          if (!isExternal && _this._isUpdate) {
+            eventProps.isUpdate = true;
+          }
+          _this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));
+          if (state === 'installed') {
+            // This timeout is used to ignore cases where the service worker calls
+            // `skipWaiting()` in the install event, thus moving it directly in the
+            // activating state. (Since all service workers *must* go through the
+            // waiting phase, the only way to detect `skipWaiting()` called in the
+            // install event is to observe that the time spent in the waiting phase
+            // is very short.)
+            // NOTE: we don't need separate timeouts for the own and external SWs
+            // since they can't go through these phases at the same time.
+            _this._waitingTimeout = self.setTimeout(function () {
+              // Ensure the SW is still waiting (it may now be redundant).
+              if (state === 'installed' && registration.waiting === sw) {
+                _this.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));
+                {
+                  if (isExternal) {
+                    logger.warn('An external service worker has installed but is ' + 'waiting for this client to close before activating...');
+                  } else {
+                    logger.warn('The service worker has installed but is waiting ' + 'for existing clients to close before activating...');
+                  }
+                }
+              }
+            }, WAITING_TIMEOUT_DURATION);
+          } else if (state === 'activating') {
+            clearTimeout(_this._waitingTimeout);
+            if (!isExternal) {
+              _this._activeDeferred.resolve(sw);
+            }
+          }
+          {
+            switch (state) {
+              case 'installed':
+                if (isExternal) {
+                  logger.warn('An external service worker has installed. ' + 'You may want to suggest users reload this page.');
+                } else {
+                  logger.log('Registered service worker installed.');
+                }
+                break;
+              case 'activated':
+                if (isExternal) {
+                  logger.warn('An external service worker has activated.');
+                } else {
+                  logger.log('Registered service worker activated.');
+                  if (sw !== navigator.serviceWorker.controller) {
+                    logger.warn('The registered service worker is active but ' + 'not yet controlling the page. Reload or run ' + '`clients.claim()` in the service worker.');
+                  }
+                }
+                break;
+              case 'redundant':
+                if (sw === _this._compatibleControllingSW) {
+                  logger.log('Previously controlling service worker now redundant!');
+                } else if (!isExternal) {
+                  logger.log('Registered service worker now redundant!');
+                }
+                break;
+            }
+          }
+        };
+        /**
+         * @private
+         * @param {Event} originalEvent
+         */
+        _this._onControllerChange = function (originalEvent) {
+          var sw = _this._sw;
+          if (sw === navigator.serviceWorker.controller) {
+            _this.dispatchEvent(new WorkboxEvent('controlling', {
+              sw: sw,
+              originalEvent: originalEvent,
+              isUpdate: _this._isUpdate
+            }));
+            {
+              logger.log('Registered service worker now controlling this page.');
+            }
+            _this._controllingDeferred.resolve(sw);
+          }
+        };
+        /**
+         * @private
+         * @param {Event} originalEvent
+         */
+        _this._onMessage = _async(function (originalEvent) {
+          var data = originalEvent.data,
+              source = originalEvent.source; // Wait until there's an "own" service worker. This is used to buffer
+          // `message` events that may be received prior to calling `register()`.
+          return _await(_this.getSW(), function () {
+            if (_this._ownSWs.has(source)) {
+              _this.dispatchEvent(new WorkboxEvent('message', {
+                data: data,
+                sw: source,
+                originalEvent: originalEvent
+              }));
+            }
+          }); // If the service worker that sent the message is in the list of own
+          // service workers for this instance, dispatch a `message` event.
+          // NOTE: we check for all previously owned service workers rather than
+          // just the current one because some messages (e.g. cache updates) use
+          // a timeout when sent and may be delayed long enough for a service worker
+          // update to be found.
+        });
+        _this._scriptURL = scriptURL;
+        _this._registerOptions = registerOptions; // Add a message listener immediately since messages received during
+        // page load are buffered only until the DOMContentLoaded event:
+        // https://github.com/GoogleChrome/workbox/issues/2202
+        navigator.serviceWorker.addEventListener('message', _this._onMessage);
+        return _this;
+      }
+      /**
+       * Registers a service worker for this instances script URL and service
+       * worker options. By default this method delays registration until after
+       * the window has loaded.
+       *
+       * @param {Object} [options]
+       * @param {Function} [options.immediate=false] Setting this to true will
+       *     register the service worker immediately, even if the window has
+       *     not loaded (not recommended).
+       */
+      var _proto = Workbox.prototype;
+      _proto.register = function register(_temp) {
+        var _ref = _temp === void 0 ? {} : _temp,
+            _ref$immediate = _ref.immediate,
+            immediate = _ref$immediate === void 0 ? false : _ref$immediate;
+        try {
+          var _this3 = this;
+          if ("dev" !== 'production') {
+            if (_this3._registrationTime) {
+              logger.error('Cannot re-register a Workbox instance after it has ' + 'been registered. Create a new instance instead.');
+              return;
+            }
+          }
+          return _invoke(function () {
+            if (!immediate && document.readyState !== 'complete') {
+              return _awaitIgnored(new Promise(function (res) {
+                return window.addEventListener('load', res);
+              }));
+            }
+          }, function () {
+            // Set this flag to true if any service worker was controlling the page
+            // at registration time.
+            _this3._isUpdate = Boolean(navigator.serviceWorker.controller); // Before registering, attempt to determine if a SW is already controlling
+            // the page, and if that SW script (and version, if specified) matches this
+            // instance's script.
+            _this3._compatibleControllingSW = _this3._getControllingSWIfCompatible();
+            return _await(_this3._registerScript(), function (_this2$_registerScrip) {
+              _this3._registration = _this2$_registerScrip;
+              // If we have a compatible controller, store the controller as the "own"
+              // SW, resolve active/controlling deferreds and add necessary listeners.
+              if (_this3._compatibleControllingSW) {
+                _this3._sw = _this3._compatibleControllingSW;
+                _this3._activeDeferred.resolve(_this3._compatibleControllingSW);
+                _this3._controllingDeferred.resolve(_this3._compatibleControllingSW);
+                _this3._compatibleControllingSW.addEventListener('statechange', _this3._onStateChange, {
+                  once: true
+                });
+              } // If there's a waiting service worker with a matching URL before the
+              // `updatefound` event fires, it likely means that this site is open
+              // in another tab, or the user refreshed the page (and thus the previous
+              // page wasn't fully unloaded before this page started loading).
+              // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
+              var waitingSW = _this3._registration.waiting;
+              if (waitingSW && urlsMatch(waitingSW.scriptURL, _this3._scriptURL)) {
+                // Store the waiting SW as the "own" Sw, even if it means overwriting
+                // a compatible controller.
+                _this3._sw = waitingSW; // Run this in the next microtask, so any code that adds an event
+                // listener after awaiting `register()` will get this event.
+                dontWaitFor(Promise.resolve().then(function () {
+                  _this3.dispatchEvent(new WorkboxEvent('waiting', {
+                    sw: waitingSW,
+                    wasWaitingBeforeRegister: true
+                  }));
+                  if ("dev" !== 'production') {
+                    logger.warn('A service worker was already waiting to activate ' + 'before this script was registered...');
+                  }
+                }));
+              } // If an "own" SW is already set, resolve the deferred.
+              if (_this3._sw) {
+                _this3._swDeferred.resolve(_this3._sw);
+                _this3._ownSWs.add(_this3._sw);
+              }
+              if ("dev" !== 'production') {
+                logger.log('Successfully registered service worker.', _this3._scriptURL);
+                if (navigator.serviceWorker.controller) {
+                  if (_this3._compatibleControllingSW) {
+                    logger.debug('A service worker with the same script URL ' + 'is already controlling this page.');
+                  } else {
+                    logger.debug('A service worker with a different script URL is ' + 'currently controlling the page. The browser is now fetching ' + 'the new script now...');
+                  }
+                }
+                var currentPageIsOutOfScope = function currentPageIsOutOfScope() {
+                  var scopeURL = new URL(_this3._registerOptions.scope || _this3._scriptURL, document.baseURI);
+                  var scopeURLBasePath = new URL('./', scopeURL.href).pathname;
+                  return !location.pathname.startsWith(scopeURLBasePath);
+                };
+                if (currentPageIsOutOfScope()) {
+                  logger.warn('The current page is not in scope for the registered ' + 'service worker. Was this a mistake?');
+                }
+              }
+              _this3._registration.addEventListener('updatefound', _this3._onUpdateFound);
+              navigator.serviceWorker.addEventListener('controllerchange', _this3._onControllerChange, {
+                once: true
+              });
+              return _this3._registration;
+            });
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      /**
+       * Checks for updates of the registered service worker.
+       */
+      ;
+      _proto.update = function update() {
+        try {
+          var _this5 = this;
+          if (!_this5._registration) {
+            if ("dev" !== 'production') {
+              logger.error('Cannot update a Workbox instance without ' + 'being registered. Register the Workbox instance first.');
+            }
+            return;
+          } // Try to update registration
+          return _awaitIgnored(_this5._registration.update());
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      /**
+       * Resolves to the service worker registered by this instance as soon as it
+       * is active. If a service worker was already controlling at registration
+       * time then it will resolve to that if the script URLs (and optionally
+       * script versions) match, otherwise it will wait until an update is found
+       * and activates.
+       *
+       * @return {Promise<ServiceWorker>}
+       */
+      ;
+      /**
+       * Resolves with a reference to a service worker that matches the script URL
+       * of this instance, as soon as it's available.
+       *
+       * If, at registration time, there's already an active or waiting service
+       * worker with a matching script URL, it will be used (with the waiting
+       * service worker taking precedence over the active service worker if both
+       * match, since the waiting service worker would have been registered more
+       * recently).
+       * If there's no matching active or waiting service worker at registration
+       * time then the promise will not resolve until an update is found and starts
+       * installing, at which point the installing service worker is used.
+       *
+       * @return {Promise<ServiceWorker>}
+       */
+      _proto.getSW = function getSW() {
+        try {
+          var _this7 = this;
+          // If `this._sw` is set, resolve with that as we want `getSW()` to
+          // return the correct (new) service worker if an update is found.
+          return _this7._sw !== undefined ? _this7._sw : _this7._swDeferred.promise;
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      /**
+       * Sends the passed data object to the service worker registered by this
+       * instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves
+       * with a response (if any).
+       *
+       * A response can be set in a message handler in the service worker by
+       * calling `event.ports[0].postMessage(...)`, which will resolve the promise
+       * returned by `messageSW()`. If no response is set, the promise will never
+       * resolve.
+       *
+       * @param {Object} data An object to send to the service worker
+       * @return {Promise<Object>}
+       */
+      ;
+      _proto.messageSW = function messageSW$1(data) {
+        try {
+          var _this9 = this;
+          return _await(_this9.getSW(), function (sw) {
+            return messageSW(sw, data);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      /**
+       * Checks for a service worker already controlling the page and returns
+       * it if its script URL matches.
+       *
+       * @private
+       * @return {ServiceWorker|undefined}
+       */
+      ;
+      _proto._getControllingSWIfCompatible = function _getControllingSWIfCompatible() {
+        var controller = navigator.serviceWorker.controller;
+        if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {
+          return controller;
+        } else {
+          return undefined;
+        }
+      }
+      /**
+       * Registers a service worker for this instances script URL and register
+       * options and tracks the time registration was complete.
+       *
+       * @private
+       */
+      ;
+      _proto._registerScript = function _registerScript() {
+        try {
+          var _this11 = this;
+          return _catch(function () {
+            return _await(navigator.serviceWorker.register(_this11._scriptURL, _this11._registerOptions), function (reg) {
+              // Keep track of when registration happened, so it can be used in the
+              // `this._onUpdateFound` heuristic. Also use the presence of this
+              // property as a way to see if `.register()` has been called.
+              _this11._registrationTime = performance.now();
+              return reg;
+            });
+          }, function (error) {
+            if ("dev" !== 'production') {
+              logger.error(error);
+            } // Re-throw the error.
+            throw error;
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+      _createClass(Workbox, [{
+        key: "active",
+        get: function get() {
+          return this._activeDeferred.promise;
+        }
+        /**
+         * Resolves to the service worker registered by this instance as soon as it
+         * is controlling the page. If a service worker was already controlling at
+         * registration time then it will resolve to that if the script URLs (and
+         * optionally script versions) match, otherwise it will wait until an update
+         * is found and starts controlling the page.
+         * Note: the first time a service worker is installed it will active but
+         * not start controlling the page unless `clients.claim()` is called in the
+         * service worker.
+         *
+         * @return {Promise<ServiceWorker>}
+         */
+      }, {
+        key: "controlling",
+        get: function get() {
+          return this._controllingDeferred.promise;
+        }
+      }]);
+      return Workbox;
+    }(WorkboxEventTarget);
+    function _awaitIgnored(value, direct) {
+      if (!direct) {
+        return value && value.then ? value.then(_empty) : Promise.resolve();
+      }
+    } // The jsdoc comments below outline the events this instance may dispatch:
+    // -----------------------------------------------------------------------
+    /**
+     * The `message` event is dispatched any time a `postMessage` is received.
+     *
+     * @event module:workbox-window.Workbox#message
+     * @type {WorkboxEvent}
+     * @property {*} data The `data` property from the original `message` event.
+     * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
+     *     event.
+     * @property {string} type `message`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `installed` event is dispatched if the state of a
+     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+     * changes to `installed`.
+     *
+     * Then can happen either the very first time a service worker is installed,
+     * or after an update to the current service worker is found. In the case
+     * of an update being found, the event's `isUpdate` property will be `true`.
+     *
+     * @event module:workbox-window.Workbox#installed
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {boolean|undefined} isUpdate True if a service worker was already
+     *     controlling when this `Workbox` instance called `register()`.
+     * @property {string} type `installed`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `waiting` event is dispatched if the state of a
+     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+     * changes to `installed` and then doesn't immediately change to `activating`.
+     * It may also be dispatched if a service worker with the same
+     * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
+     * was already waiting when the [`register()`]{@link module:workbox-window.Workbox#register}
+     * method was called.
+     *
+     * @event module:workbox-window.Workbox#waiting
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event|undefined} originalEvent The original
+     *    [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event, or `undefined` in the case where the service worker was waiting
+     *     to before `.register()` was called.
+     * @property {boolean|undefined} isUpdate True if a service worker was already
+     *     controlling when this `Workbox` instance called `register()`.
+     * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with
+     *     a matching `scriptURL` was already waiting when this `Workbox`
+     *     instance called `register()`.
+     * @property {string} type `waiting`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `controlling` event is dispatched if a
+     * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
+     * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}
+     * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
+     * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}
+     * matches the `scriptURL` of the `Workbox` instance's
+     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.
+     *
+     * @event module:workbox-window.Workbox#controlling
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
+     *     event.
+     * @property {boolean|undefined} isUpdate True if a service worker was already
+     *     controlling when this service worker was registered.
+     * @property {string} type `controlling`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `activated` event is dispatched if the state of a
+     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+     * changes to `activated`.
+     *
+     * @event module:workbox-window.Workbox#activated
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {boolean|undefined} isUpdate True if a service worker was already
+     *     controlling when this `Workbox` instance called `register()`.
+     * @property {string} type `activated`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `redundant` event is dispatched if the state of a
+     * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+     * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+     * changes to `redundant`.
+     *
+     * @event module:workbox-window.Workbox#redundant
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {boolean|undefined} isUpdate True if a service worker was already
+     *     controlling when this `Workbox` instance called `register()`.
+     * @property {string} type `redundant`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `externalinstalled` event is dispatched if the state of an
+     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+     * changes to `installed`.
+     *
+     * @event module:workbox-window.Workbox#externalinstalled
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {string} type `externalinstalled`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `externalwaiting` event is dispatched if the state of an
+     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+     * changes to `waiting`.
+     *
+     * @event module:workbox-window.Workbox#externalwaiting
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {string} type `externalwaiting`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    /**
+     * The `externalactivated` event is dispatched if the state of an
+     * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+     * changes to `activated`.
+     *
+     * @event module:workbox-window.Workbox#externalactivated
+     * @type {WorkboxEvent}
+     * @property {ServiceWorker} sw The service worker instance.
+     * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+     *     event.
+     * @property {string} type `externalactivated`.
+     * @property {Workbox} target The `Workbox` instance.
+     */
+    function _invoke(body, then) {
+      var result = body();
+      if (result && result.then) {
+        return result.then(then);
+      }
+      return then(result);
+    }
+    function _catch(body, recover) {
+      try {
+        var result = body();
+      } catch (e) {
+        return recover(e);
+      }
+      if (result && result.then) {
+        return result.then(void 0, recover);
+      }
+      return result;
+    }
+    exports.Workbox = Workbox;
+    exports.messageSW = messageSW;
+    Object.defineProperty(exports, '__esModule', { value: true });
+})));
+//# sourceMappingURL=workbox-window.dev.umd.js.map