myapp/node_modules/workbox-streams/build/workbox-streams.dev.js

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