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

jekyll-pwa-workbox 0.0.7 → 0.0.8

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.0.0 → workbox-v5.1.1}/workbox-streams.dev.js.map RENAMED

	@@ -1 +1 @@
1	- {"version":3,"file":"workbox-streams.dev.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:streams:5.0.0'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/*\n Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n \n @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n /\nfunction _getReaderFromSource(source) {\n if (source instanceof Response) {\n return source.body.getReader();\n }\n if (source instanceof ReadableStream) {\n return source.getReader();\n }\n return new Response(source).body.getReader();\n}\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n \n Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenate(sourcePromises) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isArray(sourcePromises, {\n moduleName: 'workbox-streams',\n funcName: 'concatenate',\n paramName: 'sourcePromises',\n });\n }\n const readerPromises = sourcePromises.map((sourcePromise) => {\n return Promise.resolve(sourcePromise).then((source) => {\n return _getReaderFromSource(source);\n });\n });\n const streamDeferred = new Deferred();\n let i = 0;\n const logMessages = [];\n const stream = new ReadableStream({\n pull(controller) {\n return readerPromises[i]\n .then((reader) => reader.read())\n .then((result) => {\n if (result.done) {\n if (process.env.NODE_ENV !== 'production') {\n logMessages.push(['Reached the end of source:',\n sourcePromises[i]]);\n }\n i++;\n if (i >= readerPromises.length) {\n // Log all the messages in the group at once in a single group.\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n for (const message of logMessages) {\n if (Array.isArray(message)) {\n logger.log(...message);\n }\n else {\n logger.log(message);\n }\n }\n logger.log('Finished reading all sources.');\n logger.groupEnd();\n }\n controller.close();\n streamDeferred.resolve();\n return;\n }\n // The `pull` method is defined because we're inside it.\n return this.pull(controller);\n }\n else {\n controller.enqueue(result.value);\n }\n }).catch((error) => {\n if (process.env.NODE_ENV !== 'production') {\n logger.error('An error occurred:', error);\n }\n streamDeferred.reject(error);\n throw error;\n });\n },\n cancel() {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn('The ReadableStream was cancelled.');\n }\n streamDeferred.resolve();\n },\n });\n return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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 This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n \n @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction createHeaders(headersInit = {}) {\n // See https://github.com/GoogleChrome/workbox/issues/1461\n const headers = new Headers(headersInit);\n if (!headers.has('content-type')) {\n headers.set('content-type', 'text/html');\n }\n return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n \n Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenateToResponse(sourcePromises, headersInit) {\n const { done, stream } = concatenate(sourcePromises);\n const headers = createHeaders(headersInit);\n const response = new Response(stream, { headers });\n return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/\n This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n \n @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction isSupported() {\n return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/\n A shortcut to create a strategy that could be dropped-in to Workbox's router.\n \n On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n \n @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n return async ({ event, request, url, params }) => {\n const sourcePromises = sourceFunctions.map((fn) => {\n // Ensure the return value of the function is always a promise.\n return Promise.resolve(fn({ event, request, url, params }));\n });\n if (isSupported()) {\n const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n if (event) {\n event.waitUntil(done);\n }\n return response;\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`The current browser doesn't support creating response ` +\n `streams. Falling back to non-streaming response instead.`);\n }\n // Fallback to waiting for everything to finish, and concatenating the\n // responses.\n const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n const source = await sourcePromise;\n if (source instanceof Response) {\n return source.blob();\n }\n else {\n // Technically, a `StreamSource` object can include any valid\n // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n // cannot be passed to the Blob constructor directly, so we have to\n // convert them to actual Blobs first.\n return new Response(source).blob();\n }\n });\n const blobParts = await Promise.all(blobPartsPromises);\n const headers = createHeaders(headersInit);\n // Constructing a new Response from a Blob source is well-supported.\n // So is constructing a new Blob from multiple source Blobs or strings.\n return new Response(new Blob(blobParts), { headers });\n };\n}\nexport { strategy };\n"],"names":["self","_","e","_getReaderFromSource","source","Response","body","getReader","ReadableStream","concatenate","sourcePromises","assert","isArray","moduleName","funcName","paramName","readerPromises","map","sourcePromise","Promise","resolve","then","streamDeferred","Deferred","i","logMessages","stream","pull","controller","reader","read","result","done","push","length","logger","groupCollapsed","message","Array","log","groupEnd","close","enqueue","value","catch","error","reject","cancel","warn","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","strategy","sourceFunctions","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"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"}
1	+ {"version":3,"file":"workbox-streams.dev.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:streams:5.1.1'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/*\n Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n \n @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n /\nfunction _getReaderFromSource(source) {\n if (source instanceof Response) {\n return source.body.getReader();\n }\n if (source instanceof ReadableStream) {\n return source.getReader();\n }\n return new Response(source).body.getReader();\n}\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n \n Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenate(sourcePromises) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isArray(sourcePromises, {\n moduleName: 'workbox-streams',\n funcName: 'concatenate',\n paramName: 'sourcePromises',\n });\n }\n const readerPromises = sourcePromises.map((sourcePromise) => {\n return Promise.resolve(sourcePromise).then((source) => {\n return _getReaderFromSource(source);\n });\n });\n const streamDeferred = new Deferred();\n let i = 0;\n const logMessages = [];\n const stream = new ReadableStream({\n pull(controller) {\n return readerPromises[i]\n .then((reader) => reader.read())\n .then((result) => {\n if (result.done) {\n if (process.env.NODE_ENV !== 'production') {\n logMessages.push(['Reached the end of source:',\n sourcePromises[i]]);\n }\n i++;\n if (i >= readerPromises.length) {\n // Log all the messages in the group at once in a single group.\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n for (const message of logMessages) {\n if (Array.isArray(message)) {\n logger.log(...message);\n }\n else {\n logger.log(message);\n }\n }\n logger.log('Finished reading all sources.');\n logger.groupEnd();\n }\n controller.close();\n streamDeferred.resolve();\n return;\n }\n // The `pull` method is defined because we're inside it.\n return this.pull(controller);\n }\n else {\n controller.enqueue(result.value);\n }\n }).catch((error) => {\n if (process.env.NODE_ENV !== 'production') {\n logger.error('An error occurred:', error);\n }\n streamDeferred.reject(error);\n throw error;\n });\n },\n cancel() {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn('The ReadableStream was cancelled.');\n }\n streamDeferred.resolve();\n },\n });\n return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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 This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n \n @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction createHeaders(headersInit = {}) {\n // See https://github.com/GoogleChrome/workbox/issues/1461\n const headers = new Headers(headersInit);\n if (!headers.has('content-type')) {\n headers.set('content-type', 'text/html');\n }\n return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n \n Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenateToResponse(sourcePromises, headersInit) {\n const { done, stream } = concatenate(sourcePromises);\n const headers = createHeaders(headersInit);\n const response = new Response(stream, { headers });\n return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/\n This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n \n @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction isSupported() {\n return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/\n A shortcut to create a strategy that could be dropped-in to Workbox's router.\n \n On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n \n @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n return async ({ event, request, url, params }) => {\n const sourcePromises = sourceFunctions.map((fn) => {\n // Ensure the return value of the function is always a promise.\n return Promise.resolve(fn({ event, request, url, params }));\n });\n if (isSupported()) {\n const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n if (event) {\n event.waitUntil(done);\n }\n return response;\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`The current browser doesn't support creating response ` +\n `streams. Falling back to non-streaming response instead.`);\n }\n // Fallback to waiting for everything to finish, and concatenating the\n // responses.\n const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n const source = await sourcePromise;\n if (source instanceof Response) {\n return source.blob();\n }\n else {\n // Technically, a `StreamSource` object can include any valid\n // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n // cannot be passed to the Blob constructor directly, so we have to\n // convert them to actual Blobs first.\n return new Response(source).blob();\n }\n });\n const blobParts = await Promise.all(blobPartsPromises);\n const headers = createHeaders(headersInit);\n // Constructing a new Response from a Blob source is well-supported.\n // So is constructing a new Blob from multiple source Blobs or strings.\n return new Response(new Blob(blobParts), { headers });\n };\n}\nexport { strategy };\n"],"names":["self","_","e","_getReaderFromSource","source","Response","body","getReader","ReadableStream","concatenate","sourcePromises","assert","isArray","moduleName","funcName","paramName","readerPromises","map","sourcePromise","Promise","resolve","then","streamDeferred","Deferred","i","logMessages","stream","pull","controller","reader","read","result","done","push","length","logger","groupCollapsed","message","Array","log","groupEnd","close","enqueue","value","catch","error","reject","cancel","warn","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","strategy","sourceFunctions","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"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"}

data/lib/vendor/workbox-v5.1.1/workbox-streams.prod.js ADDED

	@@ -0,0 +1,2 @@
1	+ this.workbox=this.workbox\|\|{},this.workbox.streams=function(e,n,t){"use strict";try{self["workbox:streams:5.1.1"]&&_()}catch(e){}function s(e){const t=e.map(e=>Promise.resolve(e).then(e=>function(e){return e instanceof Response?e.body.getReader():e instanceof ReadableStream?e.getReader():new Response(e).body.getReader()}(e))),s=new n.Deferred;let r=0;const o=new ReadableStream({pull(e){return t[r].then(e=>e.read()).then(n=>{if(n.done)return r++,r>=t.length?(e.close(),void s.resolve()):this.pull(e);e.enqueue(n.value)}).catch(e=>{throw s.reject(e),e})},cancel(){s.resolve()}});return{done:s.promise,stream:o}}function r(e={}){const n=new Headers(e);return n.has("content-type")\|\|n.set("content-type","text/html"),n}function o(e,n){const{done:t,stream:o}=s(e),c=r(n);return{done:t,response:new Response(o,{headers:c})}}function c(){return t.canConstructReadableStream()}return e.concatenate=s,e.concatenateToResponse=o,e.isSupported=c,e.strategy=function(e,n){return async({event:t,request:s,url:a,params:u})=>{const i=e.map(e=>Promise.resolve(e({event:t,request:s,url:a,params:u})));if(c()){const{done:e,response:s}=o(i,n);return t&&t.waitUntil(e),s}const f=i.map(async e=>{const n=await e;return n instanceof Response?n.blob():new Response(n).blob()}),p=await Promise.all(f),w=r(n);return new Response(new Blob(p),{headers:w})}},e}({},workbox.core._private,workbox.core._private);
2	+ //# sourceMappingURL=workbox-streams.prod.js.map

data/lib/vendor/{workbox-v5.0.0 → workbox-v5.1.1}/workbox-streams.prod.js.map RENAMED

	@@ -1 +1 @@
1	- {"version":3,"file":"workbox-streams.prod.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:streams:5.0.0'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/*\n Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n \n @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n /\nfunction _getReaderFromSource(source) {\n if (source instanceof Response) {\n return source.body.getReader();\n }\n if (source instanceof ReadableStream) {\n return source.getReader();\n }\n return new Response(source).body.getReader();\n}\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n \n Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenate(sourcePromises) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isArray(sourcePromises, {\n moduleName: 'workbox-streams',\n funcName: 'concatenate',\n paramName: 'sourcePromises',\n });\n }\n const readerPromises = sourcePromises.map((sourcePromise) => {\n return Promise.resolve(sourcePromise).then((source) => {\n return _getReaderFromSource(source);\n });\n });\n const streamDeferred = new Deferred();\n let i = 0;\n const logMessages = [];\n const stream = new ReadableStream({\n pull(controller) {\n return readerPromises[i]\n .then((reader) => reader.read())\n .then((result) => {\n if (result.done) {\n if (process.env.NODE_ENV !== 'production') {\n logMessages.push(['Reached the end of source:',\n sourcePromises[i]]);\n }\n i++;\n if (i >= readerPromises.length) {\n // Log all the messages in the group at once in a single group.\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n for (const message of logMessages) {\n if (Array.isArray(message)) {\n logger.log(...message);\n }\n else {\n logger.log(message);\n }\n }\n logger.log('Finished reading all sources.');\n logger.groupEnd();\n }\n controller.close();\n streamDeferred.resolve();\n return;\n }\n // The `pull` method is defined because we're inside it.\n return this.pull(controller);\n }\n else {\n controller.enqueue(result.value);\n }\n }).catch((error) => {\n if (process.env.NODE_ENV !== 'production') {\n logger.error('An error occurred:', error);\n }\n streamDeferred.reject(error);\n throw error;\n });\n },\n cancel() {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn('The ReadableStream was cancelled.');\n }\n streamDeferred.resolve();\n },\n });\n return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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 This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n \n @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction createHeaders(headersInit = {}) {\n // See https://github.com/GoogleChrome/workbox/issues/1461\n const headers = new Headers(headersInit);\n if (!headers.has('content-type')) {\n headers.set('content-type', 'text/html');\n }\n return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n \n Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenateToResponse(sourcePromises, headersInit) {\n const { done, stream } = concatenate(sourcePromises);\n const headers = createHeaders(headersInit);\n const response = new Response(stream, { headers });\n return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/\n This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n \n @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction isSupported() {\n return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/\n A shortcut to create a strategy that could be dropped-in to Workbox's router.\n \n On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n \n @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n return async ({ event, request, url, params }) => {\n const sourcePromises = sourceFunctions.map((fn) => {\n // Ensure the return value of the function is always a promise.\n return Promise.resolve(fn({ event, request, url, params }));\n });\n if (isSupported()) {\n const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n if (event) {\n event.waitUntil(done);\n }\n return response;\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`The current browser doesn't support creating response ` +\n `streams. Falling back to non-streaming response instead.`);\n }\n // Fallback to waiting for everything to finish, and concatenating the\n // responses.\n const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n const source = await sourcePromise;\n if (source instanceof Response) {\n return source.blob();\n }\n else {\n // Technically, a `StreamSource` object can include any valid\n // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n // cannot be passed to the Blob constructor directly, so we have to\n // convert them to actual Blobs first.\n return new Response(source).blob();\n }\n });\n const blobParts = await Promise.all(blobPartsPromises);\n const headers = createHeaders(headersInit);\n // Constructing a new Response from a Blob source is well-supported.\n // So is constructing a new Blob from multiple source Blobs or strings.\n return new Response(new Blob(blobParts), { headers });\n };\n}\nexport { strategy };\n"],"names":["self","_","e","concatenate","sourcePromises","readerPromises","map","sourcePromise","Promise","resolve","then","source","Response","body","getReader","ReadableStream","_getReaderFromSource","streamDeferred","Deferred","i","stream","pull","controller","reader","read","result","done","length","close","this","enqueue","value","catch","error","reject","cancel","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","sourceFunctions","async","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"gFAEA,IACIA,KAAK,0BAA4BC,IAErC,MAAOC,ICqCP,SAASC,EAAYC,SAQXC,EAAiBD,EAAeE,IAAKC,GAChCC,QAAQC,QAAQF,GAAeG,KAAMC,IA/BpD,SAA8BA,UACtBA,aAAkBC,SACXD,EAAOE,KAAKC,YAEnBH,aAAkBI,eACXJ,EAAOG,YAEX,IAAIF,SAASD,GAAQE,KAAKC,aAyBlBE,CAAqBL,KAG9BM,EAAiB,IAAIC,eACvBC,EAAI,QAEFC,EAAS,IAAIL,eAAe,CAC9BM,KAAKC,UACMjB,EAAec,GACjBT,KAAMa,GAAWA,EAAOC,QACxBd,KAAMe,OACHA,EAAOC,aAKPP,GACSd,EAAesB,QAepBL,EAAWM,aACXX,EAAeR,WAIZoB,KAAKR,KAAKC,GAGjBA,EAAWQ,QAAQL,EAAOM,SAE/BC,MAAOC,UAINhB,EAAeiB,OAAOD,GAChBA,KAGdE,SAIIlB,EAAeR,mBAGhB,CAAEiB,KAAMT,EAAemB,QAAShB,OAAAA,GCvF3C,SAASiB,EAAcC,EAAc,UAE3BC,EAAU,IAAIC,QAAQF,UACvBC,EAAQE,IAAI,iBACbF,EAAQG,IAAI,eAAgB,aAEzBH,ECDX,SAASI,EAAsBvC,EAAgBkC,SACrCZ,KAAEA,EAAFN,OAAQA,GAAWjB,EAAYC,GAC/BmC,EAAUF,EAAcC,SAEvB,CAAEZ,KAAAA,EAAMkB,SADE,IAAIhC,SAASQ,EAAQ,CAAEmB,QAAAA,KCV5C,SAASM,WACEC,2GCOX,SAAkBC,EAAiBT,UACxBU,OAASC,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,YAC3BhD,EAAiB2C,EAAgBzC,IAAK+C,GAEjC7C,QAAQC,QAAQ4C,EAAG,CAAEJ,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,SAEjDP,IAAe,OACTnB,KAAEA,EAAFkB,SAAQA,GAAaD,EAAsBvC,EAAgBkC,UAC7DW,GACAA,EAAMK,UAAU5B,GAEbkB,QAQLW,EAAoBnD,EAAeE,IAAI0C,MAAAA,UACnCrC,QAAeJ,SACjBI,aAAkBC,SACXD,EAAO6C,OAOP,IAAI5C,SAASD,GAAQ6C,SAG9BC,QAAkBjD,QAAQkD,IAAIH,GAC9BhB,EAAUF,EAAcC,UAGvB,IAAI1B,SAAS,IAAI+C,KAAKF,GAAY,CAAElB,QAAAA"}
1	+ {"version":3,"file":"workbox-streams.prod.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:streams:5.1.1'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/*\n Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n \n @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n /\nfunction _getReaderFromSource(source) {\n if (source instanceof Response) {\n return source.body.getReader();\n }\n if (source instanceof ReadableStream) {\n return source.getReader();\n }\n return new Response(source).body.getReader();\n}\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n \n Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenate(sourcePromises) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isArray(sourcePromises, {\n moduleName: 'workbox-streams',\n funcName: 'concatenate',\n paramName: 'sourcePromises',\n });\n }\n const readerPromises = sourcePromises.map((sourcePromise) => {\n return Promise.resolve(sourcePromise).then((source) => {\n return _getReaderFromSource(source);\n });\n });\n const streamDeferred = new Deferred();\n let i = 0;\n const logMessages = [];\n const stream = new ReadableStream({\n pull(controller) {\n return readerPromises[i]\n .then((reader) => reader.read())\n .then((result) => {\n if (result.done) {\n if (process.env.NODE_ENV !== 'production') {\n logMessages.push(['Reached the end of source:',\n sourcePromises[i]]);\n }\n i++;\n if (i >= readerPromises.length) {\n // Log all the messages in the group at once in a single group.\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n for (const message of logMessages) {\n if (Array.isArray(message)) {\n logger.log(...message);\n }\n else {\n logger.log(message);\n }\n }\n logger.log('Finished reading all sources.');\n logger.groupEnd();\n }\n controller.close();\n streamDeferred.resolve();\n return;\n }\n // The `pull` method is defined because we're inside it.\n return this.pull(controller);\n }\n else {\n controller.enqueue(result.value);\n }\n }).catch((error) => {\n if (process.env.NODE_ENV !== 'production') {\n logger.error('An error occurred:', error);\n }\n streamDeferred.reject(error);\n throw error;\n });\n },\n cancel() {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn('The ReadableStream was cancelled.');\n }\n streamDeferred.resolve();\n },\n });\n return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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 This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n \n @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction createHeaders(headersInit = {}) {\n // See https://github.com/GoogleChrome/workbox/issues/1461\n const headers = new Headers(headersInit);\n if (!headers.has('content-type')) {\n headers.set('content-type', 'text/html');\n }\n return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/\n Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n \n Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n \n @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n \n @memberof module:workbox-streams\n /\nfunction concatenateToResponse(sourcePromises, headersInit) {\n const { done, stream } = concatenate(sourcePromises);\n const headers = createHeaders(headersInit);\n const response = new Response(stream, { headers });\n return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/\n This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n \n @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n \n @memberof module:workbox-streams\n /\nfunction isSupported() {\n return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/\n A shortcut to create a strategy that could be dropped-in to Workbox's router.\n \n On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n \n @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n return async ({ event, request, url, params }) => {\n const sourcePromises = sourceFunctions.map((fn) => {\n // Ensure the return value of the function is always a promise.\n return Promise.resolve(fn({ event, request, url, params }));\n });\n if (isSupported()) {\n const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n if (event) {\n event.waitUntil(done);\n }\n return response;\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`The current browser doesn't support creating response ` +\n `streams. Falling back to non-streaming response instead.`);\n }\n // Fallback to waiting for everything to finish, and concatenating the\n // responses.\n const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n const source = await sourcePromise;\n if (source instanceof Response) {\n return source.blob();\n }\n else {\n // Technically, a `StreamSource` object can include any valid\n // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n // cannot be passed to the Blob constructor directly, so we have to\n // convert them to actual Blobs first.\n return new Response(source).blob();\n }\n });\n const blobParts = await Promise.all(blobPartsPromises);\n const headers = createHeaders(headersInit);\n // Constructing a new Response from a Blob source is well-supported.\n // So is constructing a new Blob from multiple source Blobs or strings.\n return new Response(new Blob(blobParts), { headers });\n };\n}\nexport { strategy };\n"],"names":["self","_","e","concatenate","sourcePromises","readerPromises","map","sourcePromise","Promise","resolve","then","source","Response","body","getReader","ReadableStream","_getReaderFromSource","streamDeferred","Deferred","i","stream","pull","controller","reader","read","result","done","length","close","this","enqueue","value","catch","error","reject","cancel","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","sourceFunctions","async","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"gFAEA,IACIA,KAAK,0BAA4BC,IAErC,MAAOC,ICqCP,SAASC,EAAYC,SAQXC,EAAiBD,EAAeE,IAAKC,GAChCC,QAAQC,QAAQF,GAAeG,KAAMC,GA/BpD,SAA8BA,UACtBA,aAAkBC,SACXD,EAAOE,KAAKC,YAEnBH,aAAkBI,eACXJ,EAAOG,YAEX,IAAIF,SAASD,GAAQE,KAAKC,YAyBlBE,CAAqBL,KAG9BM,EAAiB,IAAIC,eACvBC,EAAI,QAEFC,EAAS,IAAIL,eAAe,CAC9BM,KAAKC,UACMjB,EAAec,GACjBT,KAAMa,GAAWA,EAAOC,QACxBd,KAAMe,OACHA,EAAOC,YAKPP,IACIA,GAAKd,EAAesB,QAepBL,EAAWM,aACXX,EAAeR,WAIZoB,KAAKR,KAAKC,GAGjBA,EAAWQ,QAAQL,EAAOM,SAE/BC,MAAOC,UAINhB,EAAeiB,OAAOD,GAChBA,KAGdE,SAIIlB,EAAeR,mBAGhB,CAAEiB,KAAMT,EAAemB,QAAShB,OAAAA,GCvF3C,SAASiB,EAAcC,EAAc,UAE3BC,EAAU,IAAIC,QAAQF,UACvBC,EAAQE,IAAI,iBACbF,EAAQG,IAAI,eAAgB,aAEzBH,ECDX,SAASI,EAAsBvC,EAAgBkC,SACrCZ,KAAEA,EAAFN,OAAQA,GAAWjB,EAAYC,GAC/BmC,EAAUF,EAAcC,SAEvB,CAAEZ,KAAAA,EAAMkB,SADE,IAAIhC,SAASQ,EAAQ,CAAEmB,QAAAA,KCV5C,SAASM,WACEC,2GCOX,SAAkBC,EAAiBT,UACxBU,OAASC,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,YAC3BhD,EAAiB2C,EAAgBzC,IAAK+C,GAEjC7C,QAAQC,QAAQ4C,EAAG,CAAEJ,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,SAEjDP,IAAe,OACTnB,KAAEA,EAAFkB,SAAQA,GAAaD,EAAsBvC,EAAgBkC,UAC7DW,GACAA,EAAMK,UAAU5B,GAEbkB,QAQLW,EAAoBnD,EAAeE,IAAI0C,MAAAA,UACnCrC,QAAeJ,SACjBI,aAAkBC,SACXD,EAAO6C,OAOP,IAAI5C,SAASD,GAAQ6C,SAG9BC,QAAkBjD,QAAQkD,IAAIH,GAC9BhB,EAAUF,EAAcC,UAGvB,IAAI1B,SAAS,IAAI+C,KAAKF,GAAY,CAAElB,QAAAA"}

data/lib/vendor/workbox-v5.1.1/workbox-sw.js ADDED

	@@ -0,0 +1,2 @@
1	+ !function(){"use strict";try{self["workbox:sw:5.1.1"]&&_()}catch(t){}const t={backgroundSync:"background-sync",broadcastUpdate:"broadcast-update",cacheableResponse:"cacheable-response",core:"core",expiration:"expiration",googleAnalytics:"offline-ga",navigationPreload:"navigation-preload",precaching:"precaching",rangeRequests:"range-requests",routing:"routing",strategies:"strategies",streams:"streams"};self.workbox=new class{constructor(){return this.v={},this.t={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.s=this.t.debug?"dev":"prod",this.o=!1,new Proxy(this,{get(e,s){if(e[s])return e[s];const o=t[s];return o&&e.loadModule(`workbox-${o}`),e[s]}})}setConfig(t={}){if(this.o)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.t,t),this.s=this.t.debug?"dev":"prod"}loadModule(t){const e=this.i(t);try{importScripts(e),this.o=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}i(t){if(this.t.modulePathCb)return this.t.modulePathCb(t,this.t.debug);let e=["https://storage.googleapis.com/workbox-cdn/releases/5.1.1"];const s=`${t}.${this.s}.js`,o=this.t.modulePathPrefix;return o&&(e=o.split("/"),""===e[e.length-1]&&e.splice(e.length-1,1)),e.push(s),e.join("/")}}}();
2	+ //# sourceMappingURL=workbox-sw.js.map

data/lib/vendor/{workbox-v5.0.0 → workbox-v5.1.1}/workbox-sw.js.map RENAMED

	@@ -1 +1 @@
1	- {"version":3,"file":"workbox-sw.js","sources":["../_version.mjs","../controllers/WorkboxSW.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:sw:5.0.0']&&_()}catch(e){}// eslint-disable-line","/\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/\n\nimport '../_version.mjs';\n\nconst CDN_PATH = `WORKBOX_CDN_ROOT_URL`;\n\nconst MODULE_KEY_TO_NAME_MAPPING = {\n /*\n @name backgroundSync\n * @memberof workbox\n * @see module:workbox-background-sync\n /\n backgroundSync: 'background-sync',\n /\n @name broadcastUpdate\n * @memberof workbox\n * @see module:workbox-broadcast-update\n /\n broadcastUpdate: 'broadcast-update',\n /\n @name cacheableResponse\n * @memberof workbox\n * @see module:workbox-cacheable-response\n /\n cacheableResponse: 'cacheable-response',\n /\n @name core\n * @memberof workbox\n * @see module:workbox-core\n /\n core: 'core',\n /\n @name expiration\n * @memberof workbox\n * @see module:workbox-expiration\n /\n expiration: 'expiration',\n /\n @name googleAnalytics\n * @memberof workbox\n * @see module:workbox-google-analytics\n /\n googleAnalytics: 'offline-ga',\n /\n @name navigationPreload\n * @memberof workbox\n * @see module:workbox-navigation-preload\n /\n navigationPreload: 'navigation-preload',\n /\n @name precaching\n * @memberof workbox\n * @see module:workbox-precaching\n /\n precaching: 'precaching',\n /\n @name rangeRequests\n * @memberof workbox\n * @see module:workbox-range-requests\n /\n rangeRequests: 'range-requests',\n /\n @name routing\n * @memberof workbox\n * @see module:workbox-routing\n /\n routing: 'routing',\n /\n @name strategies\n * @memberof workbox\n * @see module:workbox-strategies\n /\n strategies: 'strategies',\n /\n @name streams\n * @memberof workbox\n * @see module:workbox-streams\n /\n streams: 'streams',\n};\n\n/\n This class can be used to make it easy to use the various parts of\n * Workbox.\n \n @private\n /\nexport class WorkboxSW {\n /\n Creates a proxy that automatically loads workbox namespaces on demand.\n \n @private\n /\n constructor() {\n this.v = {};\n this._options = {\n debug: self.location.hostname === 'localhost',\n modulePathPrefix: null,\n modulePathCb: null,\n };\n\n this._env = this._options.debug ? 'dev' : 'prod';\n this._modulesLoaded = false;\n\n return new Proxy(this, {\n get(target, key) {\n if (target[key]) {\n return target[key];\n }\n\n const moduleName = MODULE_KEY_TO_NAME_MAPPING[key];\n if (moduleName) {\n target.loadModule(`workbox-${moduleName}`);\n }\n\n return target[key];\n },\n });\n }\n\n /\n Updates the configuration options. You can specify whether to treat as a\n * debug build and whether to use a CDN or a specific path when importing\n * other workbox-modules\n \n @param {Object} [options]\n * @param {boolean} [options.debug] If true, `dev` builds are using, otherwise\n * `prod` builds are used. By default, `prod` is used unless on localhost.\n * @param {Function} [options.modulePathPrefix] To avoid using the CDN with\n * `workbox-sw` set the path prefix of where modules should be loaded from.\n * For example `modulePathPrefix: '/third_party/workbox/v3.0.0/'`.\n * @param {workbox~ModulePathCallback} [options.modulePathCb] If defined,\n * this callback will be responsible for determining the path of each\n * workbox module.\n \n @alias workbox.setConfig\n /\n setConfig(options = {}) {\n if (!this._modulesLoaded) {\n Object.assign(this._options, options);\n this._env = this._options.debug ? 'dev' : 'prod';\n } else {\n throw new Error('Config must be set before accessing workbox. modules');\n }\n }\n\n /*\n Load a Workbox module by passing in the appropriate module name.\n \n This is not generally needed unless you know there are modules that are\n * dynamically used and you want to safe guard use of the module while the\n * user may be offline.\n \n @param {string} moduleName\n \n @alias workbox.loadModule\n /\n loadModule(moduleName) {\n const modulePath = this._getImportPath(moduleName);\n try {\n importScripts(modulePath);\n this._modulesLoaded = true;\n } catch (err) {\n // TODO Add context of this error if using the CDN vs the local file.\n\n // We can't rely on workbox-core being loaded so using console\n // eslint-disable-next-line\n console.error(\n `Unable to import module '${moduleName}' from '${modulePath}'.`);\n throw err;\n }\n }\n\n /\n This method will get the path / CDN URL to be used for importScript calls.\n \n @param {string} moduleName\n * @return {string} URL to the desired module.\n \n @private\n /\n _getImportPath(moduleName) {\n if (this._options.modulePathCb) {\n return this._options.modulePathCb(moduleName, this._options.debug);\n }\n\n // TODO: This needs to be dynamic some how.\n let pathParts = [CDN_PATH];\n\n const fileName = `${moduleName}.${this._env}.js`;\n\n const pathPrefix = this._options.modulePathPrefix;\n if (pathPrefix) {\n // Split to avoid issues with developers ending / not ending with slash\n pathParts = pathPrefix.split('/');\n\n // We don't need a slash at the end as we will be adding\n // a filename regardless\n if (pathParts[pathParts.length - 1] === '') {\n pathParts.splice(pathParts.length - 1, 1);\n }\n }\n\n pathParts.push(fileName);\n\n return pathParts.join('/');\n }\n}\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/\n\nimport {WorkboxSW} from './controllers/WorkboxSW.mjs';\nimport './_version.mjs';\n\n/\n @namespace workbox\n */\n\n// Don't export anything, just expose a global.\nself.workbox = new WorkboxSW();\n"],"names":["self","_","e","~~CDN_PATH","~~MODULE_KEY_TO_NAME_MAPPING","backgroundSync","broadcastUpdate","cacheableResponse","core","expiration","googleAnalytics","navigationPreload","precaching","rangeRequests","routing","strategies","streams","workbox","constructor","v","_options","debug","location","hostname","modulePathPrefix","modulePathCb","_env","this","_modulesLoaded","Proxy","get","target","key","moduleName","loadModule","setConfig","options","Error","Object","assign","modulePath","_getImportPath","importScripts","err","console","error","pathParts","fileName","pathPrefix","split","length","splice","push","join"],"mappings":"yBAAA,IAAIA,KAAK,qBAAqBC,IAAI,MAAMC,ICUxC,~~MAAMC~~,~~EAAY,4DAEZC,~~EAA6B,CAMjCC,eAAgB,kBAMhBC,gBAAiB,mBAMjBC,kBAAmB,qBAMnBC,KAAM,OAMNC,WAAY,aAMZC,gBAAiB,aAMjBC,kBAAmB,qBAMnBC,WAAY,aAMZC,cAAe,iBAMfC,QAAS,UAMTC,WAAY,aAMZC,QAAS,~~WCpEXhB~~,~~KAAKiB~~,QAAU,ID6ER,MAMLC,0BACOC,EAAI,QACJC,EAAW,CACdC,MAAkC,~~cAA3BrB~~,~~KAAKsB~~,SAASC,SACrBC,iBAAkB,KAClBC,aAAc,WAGXC,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,YACrCO,GAAiB,EAEf,IAAIC,MAAMF,KAAM,CACrBG,IAAIC,EAAQC,MACND,EAAOC,UACFD,EAAOC,SAGVC,EAAa7B,EAA2B4B,UAC1CC,GACFF,EAAOG,~~sBAAsBD~~,KAGxBF,EAAOC,MAsBpBG,UAAUC,EAAU,OACbT,KAAKC,QAIF,IAAIS,MAAM,yDAHhBC,OAAOC,OAAOZ,KAAKP,EAAUgB,QACxBV,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,OAiB9Ca,WAAWD,SACHO,EAAab,KAAKc,EAAeR,OAErCS,cAAcF,QACTZ,GAAiB,EACtB,MAAOe,SAKPC,QAAQC,~~kCACwBZ~~,YAAqBO,OAC/CG,GAYVF,EAAeR,MACTN,KAAKP,EAASK,oBACTE,KAAKP,EAASK,aAAaQ,EAAYN,KAAKP,EAASC,WAI1DyB,EAAY,~~CAAC3C~~,~~SAEX4C~~,~~KAAcd~~,KAAcN,KAAKD,OAEjCsB,EAAarB,KAAKP,EAASI,wBAC7BwB,~~GAMsC~~,~~MAJxCF,~~EAAYE,EAAWC,MAAM,~~MAIfH~~,EAAUI,OAAS,IAC/BJ,EAAUK,OAAOL,EAAUI,OAAS,EAAG,~~GAI3CJ~~,EAAUM,KAAKL,GAERD,EAAUO,KAAK"}
1	+ {"version":3,"file":"workbox-sw.js","sources":["../_version.mjs","../controllers/WorkboxSW.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:sw:5.1.1']&&_()}catch(e){}// eslint-disable-line","/\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/\n\nimport '../_version.mjs';\n\nconst CDN_PATH = `WORKBOX_CDN_ROOT_URL`;\n\nconst MODULE_KEY_TO_NAME_MAPPING = {\n /*\n @name backgroundSync\n * @memberof workbox\n * @see module:workbox-background-sync\n /\n backgroundSync: 'background-sync',\n /\n @name broadcastUpdate\n * @memberof workbox\n * @see module:workbox-broadcast-update\n /\n broadcastUpdate: 'broadcast-update',\n /\n @name cacheableResponse\n * @memberof workbox\n * @see module:workbox-cacheable-response\n /\n cacheableResponse: 'cacheable-response',\n /\n @name core\n * @memberof workbox\n * @see module:workbox-core\n /\n core: 'core',\n /\n @name expiration\n * @memberof workbox\n * @see module:workbox-expiration\n /\n expiration: 'expiration',\n /\n @name googleAnalytics\n * @memberof workbox\n * @see module:workbox-google-analytics\n /\n googleAnalytics: 'offline-ga',\n /\n @name navigationPreload\n * @memberof workbox\n * @see module:workbox-navigation-preload\n /\n navigationPreload: 'navigation-preload',\n /\n @name precaching\n * @memberof workbox\n * @see module:workbox-precaching\n /\n precaching: 'precaching',\n /\n @name rangeRequests\n * @memberof workbox\n * @see module:workbox-range-requests\n /\n rangeRequests: 'range-requests',\n /\n @name routing\n * @memberof workbox\n * @see module:workbox-routing\n /\n routing: 'routing',\n /\n @name strategies\n * @memberof workbox\n * @see module:workbox-strategies\n /\n strategies: 'strategies',\n /\n @name streams\n * @memberof workbox\n * @see module:workbox-streams\n /\n streams: 'streams',\n};\n\n/\n This class can be used to make it easy to use the various parts of\n * Workbox.\n \n @private\n /\nexport class WorkboxSW {\n /\n Creates a proxy that automatically loads workbox namespaces on demand.\n \n @private\n /\n constructor() {\n this.v = {};\n this._options = {\n debug: self.location.hostname === 'localhost',\n modulePathPrefix: null,\n modulePathCb: null,\n };\n\n this._env = this._options.debug ? 'dev' : 'prod';\n this._modulesLoaded = false;\n\n return new Proxy(this, {\n get(target, key) {\n if (target[key]) {\n return target[key];\n }\n\n const moduleName = MODULE_KEY_TO_NAME_MAPPING[key];\n if (moduleName) {\n target.loadModule(`workbox-${moduleName}`);\n }\n\n return target[key];\n },\n });\n }\n\n /\n Updates the configuration options. You can specify whether to treat as a\n * debug build and whether to use a CDN or a specific path when importing\n * other workbox-modules\n \n @param {Object} [options]\n * @param {boolean} [options.debug] If true, `dev` builds are using, otherwise\n * `prod` builds are used. By default, `prod` is used unless on localhost.\n * @param {Function} [options.modulePathPrefix] To avoid using the CDN with\n * `workbox-sw` set the path prefix of where modules should be loaded from.\n * For example `modulePathPrefix: '/third_party/workbox/v3.0.0/'`.\n * @param {workbox~ModulePathCallback} [options.modulePathCb] If defined,\n * this callback will be responsible for determining the path of each\n * workbox module.\n \n @alias workbox.setConfig\n /\n setConfig(options = {}) {\n if (!this._modulesLoaded) {\n Object.assign(this._options, options);\n this._env = this._options.debug ? 'dev' : 'prod';\n } else {\n throw new Error('Config must be set before accessing workbox. modules');\n }\n }\n\n /*\n Load a Workbox module by passing in the appropriate module name.\n \n This is not generally needed unless you know there are modules that are\n * dynamically used and you want to safe guard use of the module while the\n * user may be offline.\n \n @param {string} moduleName\n \n @alias workbox.loadModule\n /\n loadModule(moduleName) {\n const modulePath = this._getImportPath(moduleName);\n try {\n importScripts(modulePath);\n this._modulesLoaded = true;\n } catch (err) {\n // TODO Add context of this error if using the CDN vs the local file.\n\n // We can't rely on workbox-core being loaded so using console\n // eslint-disable-next-line\n console.error(\n `Unable to import module '${moduleName}' from '${modulePath}'.`);\n throw err;\n }\n }\n\n /\n This method will get the path / CDN URL to be used for importScript calls.\n \n @param {string} moduleName\n * @return {string} URL to the desired module.\n \n @private\n /\n _getImportPath(moduleName) {\n if (this._options.modulePathCb) {\n return this._options.modulePathCb(moduleName, this._options.debug);\n }\n\n // TODO: This needs to be dynamic some how.\n let pathParts = [CDN_PATH];\n\n const fileName = `${moduleName}.${this._env}.js`;\n\n const pathPrefix = this._options.modulePathPrefix;\n if (pathPrefix) {\n // Split to avoid issues with developers ending / not ending with slash\n pathParts = pathPrefix.split('/');\n\n // We don't need a slash at the end as we will be adding\n // a filename regardless\n if (pathParts[pathParts.length - 1] === '') {\n pathParts.splice(pathParts.length - 1, 1);\n }\n }\n\n pathParts.push(fileName);\n\n return pathParts.join('/');\n }\n}\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/\n\nimport {WorkboxSW} from './controllers/WorkboxSW.mjs';\nimport './_version.mjs';\n\n/\n @namespace workbox\n */\n\n// Don't export anything, just expose a global.\nself.workbox = new WorkboxSW();\n"],"names":["self","_","e","MODULE_KEY_TO_NAME_MAPPING","backgroundSync","broadcastUpdate","cacheableResponse","core","expiration","googleAnalytics","navigationPreload","precaching","rangeRequests","routing","strategies","streams","workbox","constructor","v","_options","debug","location","hostname","modulePathPrefix","modulePathCb","_env","this","_modulesLoaded","Proxy","get","target","key","moduleName","loadModule","setConfig","options","Error","Object","assign","modulePath","_getImportPath","importScripts","err","console","error","pathParts","fileName","pathPrefix","split","length","splice","push","join"],"mappings":"yBAAA,IAAIA,KAAK,qBAAqBC,IAAI,MAAMC,ICUxC,MAEMC,EAA6B,CAMjCC,eAAgB,kBAMhBC,gBAAiB,mBAMjBC,kBAAmB,qBAMnBC,KAAM,OAMNC,WAAY,aAMZC,gBAAiB,aAMjBC,kBAAmB,qBAMnBC,WAAY,aAMZC,cAAe,iBAMfC,QAAS,UAMTC,WAAY,aAMZC,QAAS,WCpEXf,KAAKgB,QAAU,ID6ER,MAMLC,0BACOC,EAAI,QACJC,EAAW,CACdC,MAAkC,cAA3BpB,KAAKqB,SAASC,SACrBC,iBAAkB,KAClBC,aAAc,WAGXC,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,YACrCO,GAAiB,EAEf,IAAIC,MAAMF,KAAM,CACrBG,IAAIC,EAAQC,MACND,EAAOC,UACFD,EAAOC,SAGVC,EAAa7B,EAA2B4B,UAC1CC,GACFF,EAAOG,WAAY,WAAUD,KAGxBF,EAAOC,MAsBpBG,UAAUC,EAAU,OACbT,KAAKC,QAIF,IAAIS,MAAM,yDAHhBC,OAAOC,OAAOZ,KAAKP,EAAUgB,QACxBV,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,OAiB9Ca,WAAWD,SACHO,EAAab,KAAKc,EAAeR,OAErCS,cAAcF,QACTZ,GAAiB,EACtB,MAAOe,SAKPC,QAAQC,MACH,4BAA2BZ,YAAqBO,OAC/CG,GAYVF,EAAeR,MACTN,KAAKP,EAASK,oBACTE,KAAKP,EAASK,aAAaQ,EAAYN,KAAKP,EAASC,WAI1DyB,EAAY,CAvLF,mEAyLRC,EAAY,GAAEd,KAAcN,KAAKD,OAEjCsB,EAAarB,KAAKP,EAASI,wBAC7BwB,IAEFF,EAAYE,EAAWC,MAAM,KAIW,KAApCH,EAAUA,EAAUI,OAAS,IAC/BJ,EAAUK,OAAOL,EAAUI,OAAS,EAAG,IAI3CJ,EAAUM,KAAKL,GAERD,EAAUO,KAAK"}

data/lib/vendor/{workbox-v5.0.0 → workbox-v5.1.1}/workbox-window.dev.es5.mjs RENAMED

@@ -1,1075 +1,1094 @@
-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;
-}
-export { Workbox, messageSW };
-//# sourceMappingURL=workbox-window.dev.es5.mjs.map
+try {
+  self['workbox:window:5.1.1'] && _();
+} 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.1.1'] && _();
+} 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 = 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;
+}
+export { Workbox, messageSW };
+//# sourceMappingURL=workbox-window.dev.es5.mjs.map