jekyll-pwa-workbox 5.1.4 → 5.1.41

data/lib/vendor/workbox-v5.1.4/workbox-strategies.prod.js

@@ -1,2 +1,2 @@
-this.workbox=this.workbox||{},this.workbox.strategies=function(t,e,s,i,n){"use strict";try{self["workbox:strategies:5.1.4"]&&_()}catch(t){}const r={cacheWillUpdate:async({response:t})=>200===t.status||0===t.status?t:null};return t.CacheFirst=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));let i,r=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!r)try{r=await this.o(e,t)}catch(t){i=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:i});return r}async o(t,e){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=n.clone(),h=s.cacheWrapper.put({cacheName:this.t,request:t,response:r,event:e,plugins:this.s});if(e)try{e.waitUntil(h)}catch(t){}return n}},t.CacheOnly=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!i)throw new n.WorkboxError("no-response",{url:e.url});return i}},t.NetworkFirst=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.u=t.networkTimeoutSeconds||0,this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){const s=[];"string"==typeof e&&(e=new Request(e));const i=[];let r;if(this.u){const{id:n,promise:h}=this.l({request:e,event:t,logs:s});r=n,i.push(h)}const h=this.p({timeoutId:r,request:e,event:t,logs:s});i.push(h);let o=await Promise.race(i);if(o||(o=await h),!o)throw new n.WorkboxError("no-response",{url:e.url});return o}l({request:t,logs:e,event:s}){let i;return{promise:new Promise(e=>{i=setTimeout(async()=>{e(await this.q({request:t,event:s}))},1e3*this.u)}),id:i}}async p({timeoutId:t,request:e,logs:n,event:r}){let h,o;try{o=await i.fetchWrapper.fetch({request:e,event:r,fetchOptions:this.i,plugins:this.s})}catch(t){h=t}if(t&&clearTimeout(t),h||!o)o=await this.q({request:e,event:r});else{const t=o.clone(),i=s.cacheWrapper.put({cacheName:this.t,request:e,response:t,event:r,plugins:this.s});if(r)try{r.waitUntil(i)}catch(t){}}return o}q({event:t,request:e}){return s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s})}},t.NetworkOnly=class{constructor(t={}){this.s=t.plugins||[],this.i=t.fetchOptions}async handle({event:t,request:e}){let s,r;"string"==typeof e&&(e=new Request(e));try{r=await i.fetchWrapper.fetch({request:e,event:t,fetchOptions:this.i,plugins:this.s})}catch(t){s=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:s});return r}},t.StaleWhileRevalidate=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=this.o({request:e,event:t});let r,h=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(h){if(t)try{t.waitUntil(i)}catch(r){}}else try{h=await i}catch(t){r=t}if(!h)throw new n.WorkboxError("no-response",{url:e.url,error:r});return h}async o({request:t,event:e}){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=s.cacheWrapper.put({cacheName:this.t,request:t,response:n.clone(),event:e,plugins:this.s});if(e)try{e.waitUntil(r)}catch(t){}return n}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
-//# sourceMappingURL=workbox-strategies.prod.js.map
+this.workbox=this.workbox||{},this.workbox.strategies=function(t,e,s,i,n){"use strict";try{self["workbox:strategies:5.1.4"]&&_()}catch(t){}const r={cacheWillUpdate:async({response:t})=>200===t.status||0===t.status?t:null};return t.CacheFirst=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));let i,r=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!r)try{r=await this.o(e,t)}catch(t){i=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:i});return r}async o(t,e){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=n.clone(),h=s.cacheWrapper.put({cacheName:this.t,request:t,response:r,event:e,plugins:this.s});if(e)try{e.waitUntil(h)}catch(t){}return n}},t.CacheOnly=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!i)throw new n.WorkboxError("no-response",{url:e.url});return i}},t.NetworkFirst=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.u=t.networkTimeoutSeconds||0,this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){const s=[];"string"==typeof e&&(e=new Request(e));const i=[];let r;if(this.u){const{id:n,promise:h}=this.l({request:e,event:t,logs:s});r=n,i.push(h)}const h=this.p({timeoutId:r,request:e,event:t,logs:s});i.push(h);let o=await Promise.race(i);if(o||(o=await h),!o)throw new n.WorkboxError("no-response",{url:e.url});return o}l({request:t,logs:e,event:s}){let i;return{promise:new Promise(e=>{i=setTimeout(async()=>{e(await this.q({request:t,event:s}))},1e3*this.u)}),id:i}}async p({timeoutId:t,request:e,logs:n,event:r}){let h,o;try{o=await i.fetchWrapper.fetch({request:e,event:r,fetchOptions:this.i,plugins:this.s})}catch(t){h=t}if(t&&clearTimeout(t),h||!o)o=await this.q({request:e,event:r});else{const t=o.clone(),i=s.cacheWrapper.put({cacheName:this.t,request:e,response:t,event:r,plugins:this.s});if(r)try{r.waitUntil(i)}catch(t){}}return o}q({event:t,request:e}){return s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s})}},t.NetworkOnly=class{constructor(t={}){this.s=t.plugins||[],this.i=t.fetchOptions}async handle({event:t,request:e}){let s,r;"string"==typeof e&&(e=new Request(e));try{r=await i.fetchWrapper.fetch({request:e,event:t,fetchOptions:this.i,plugins:this.s})}catch(t){s=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:s});return r}},t.StaleWhileRevalidate=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=this.o({request:e,event:t});let r,h=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(h){if(t)try{t.waitUntil(i)}catch(r){}}else try{h=await i}catch(t){r=t}if(!h)throw new n.WorkboxError("no-response",{url:e.url,error:r});return h}async o({request:t,event:e}){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=s.cacheWrapper.put({cacheName:this.t,request:t,response:n.clone(),event:e,plugins:this.s});if(e)try{e.waitUntil(r)}catch(t){}return n}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-strategies.prod.js.map

data/lib/vendor/workbox-v5.1.4/workbox-streams.dev.js

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