chore: autopublish 2023-12-24T04:59:21Z

1 files changed, 0 insertions, 337 deletions

diff --git a/public/workbox-v4.3.1/workbox-streams.dev.js b/public/workbox-v4.3.1/workbox-streams.dev.js
deleted file mode 100644
index c90b3dc..0000000
--- a/public/workbox-v4.3.1/workbox-streams.dev.js
+++ /dev/null
@@ -1,337 +0,0 @@
-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