1 files changed, 337 insertions, 0 deletions
diff --git a/public/workbox-v4.3.1/workbox-streams.dev.js b/public/workbox-v4.3.1/workbox-streams.dev.js
new file mode 100644
index 0000000..c90b3dc
--- /dev/null
+++ b/public/workbox-v4.3.1/workbox-streams.dev.js
@@ -0,0 +1,337 @@
+this.workbox = this.workbox || {};
+this.workbox.streams = (function (exports, logger_mjs, assert_mjs) {
+  'use strict';
+
+  try {
+    self['workbox:streams:4.3.1'] && _();
+  } catch (e) {} // eslint-disable-line
+
+  /*
+    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 {workbox.streams.StreamSource} source
+   * @return {ReadableStreamReader}
+   * @private
+   */
+
+  function _getReaderFromSource(source) {
+    if (source.body && source.body.getReader) {
+      return source.body.getReader();
+    }
+
+    if (source.getReader) {
+      return source.getReader();
+    } // TODO: This should be possible to do by constructing a ReadableStream, but
+    // I can't get it to work. As a hack, construct a new Response, and use the
+    // reader associated with its body.
+
+
+    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<workbox.streams.StreamSource>>} sourcePromises
+   * @return {Object<{done: Promise, stream: ReadableStream}>}
+   *
+   * @memberof workbox.streams
+   */
+
+
+  function concatenate(sourcePromises) {
+    {
+      assert_mjs.assert.isArray(sourcePromises, {
+        moduleName: 'workbox-streams',
+        funcName: 'concatenate',
+        paramName: 'sourcePromises'
+      });
+    }
+
+    const readerPromises = sourcePromises.map(sourcePromise => {
+      return Promise.resolve(sourcePromise).then(source => {
+        return _getReaderFromSource(source);
+      });
+    });
+    let fullyStreamedResolve;
+    let fullyStreamedReject;
+    const done = new Promise((resolve, reject) => {
+      fullyStreamedResolve = resolve;
+      fullyStreamedReject = reject;
+    });
+    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_mjs.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger_mjs.logger.log(...message);
+                  } else {
+                    logger_mjs.logger.log(message);
+                  }
+                }
+
+                logger_mjs.logger.log('Finished reading all sources.');
+                logger_mjs.logger.groupEnd();
+              }
+
+              controller.close();
+              fullyStreamedResolve();
+              return;
+            }
+
+            return this.pull(controller);
+          } else {
+            controller.enqueue(result.value);
+          }
+        }).catch(error => {
+          {
+            logger_mjs.logger.error('An error occurred:', error);
+          }
+
+          fullyStreamedReject(error);
+          throw error;
+        });
+      },
+
+      cancel() {
+        {
+          logger_mjs.logger.warn('The ReadableStream was cancelled.');
+        }
+
+        fullyStreamedResolve();
+      }
+
+    });
+    return {
+      done,
+      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.
+   *
+   * @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 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<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 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.
+  */
+  let cachedIsSupported = undefined;
+  /**
+   * 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 workbox.streams
+   */
+
+  function isSupported() {
+    if (cachedIsSupported === undefined) {
+      // See https://github.com/GoogleChrome/workbox/issues/1473
+      try {
+        new ReadableStream({
+          start() {}
+
+        });
+        cachedIsSupported = true;
+      } catch (error) {
+        cachedIsSupported = false;
+      }
+    }
+
+    return cachedIsSupported;
+  }
+
+  /*
+    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(workbox.routing.Route~handlerCallback)>} sourceFunctions
+   * Each function should return a {@link 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 {workbox.routing.Route~handlerCallback}
+   *
+   * @memberof workbox.streams
+   */
+
+  function strategy(sourceFunctions, headersInit) {
+    return async ({
+      event,
+      url,
+      params
+    }) => {
+      if (isSupported()) {
+        const {
+          done,
+          response
+        } = concatenateToResponse(sourceFunctions.map(fn => fn({
+          event,
+          url,
+          params
+        })), headersInit);
+        event.waitUntil(done);
+        return response;
+      }
+
+      {
+        logger_mjs.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 parts = await Promise.all(sourceFunctions.map(sourceFunction => sourceFunction({
+        event,
+        url,
+        params
+      })).map(async responsePromise => {
+        const response = await responsePromise;
+
+        if (response instanceof Response) {
+          return response.blob();
+        } // Otherwise, assume it's something like a string which can be used
+        // as-is when constructing the final composite blob.
+
+
+        return response;
+      }));
+      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(parts), {
+        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.
+  */
+
+  exports.concatenate = concatenate;
+  exports.concatenateToResponse = concatenateToResponse;
+  exports.isSupported = isSupported;
+  exports.strategy = strategy;
+
+  return exports;
+
+}({}, workbox.core._private, workbox.core._private));
+//# sourceMappingURL=workbox-streams.dev.js.map