v1.0 with SW PWA enabled

frontend/node_modules/workbox-streams/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2018 Google LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

frontend/node_modules/workbox-streams/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/reference-docs/latest/module-workbox-streams

frontend/node_modules/workbox-streams/_types.d.ts

@@ -0,0 +1,6 @@
+import './_version.js';
+export type StreamSource = Response | ReadableStream | BodyInit;
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox-streams
+ */

frontend/node_modules/workbox-streams/_types.js

@@ -0,0 +1,18 @@
+/*
+  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.
+*/
+import './_version.js';
+// * * * IMPORTANT! * * *
+// ------------------------------------------------------------------------- //
+// jdsoc type definitions cannot be declared above TypeScript definitions or
+// they'll be stripped from the built `.js` files, and they'll only be in the
+// `d.ts` files, which aren't read by the jsdoc generator. As a result we
+// have to put declare them below.
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox-streams
+ */

frontend/node_modules/workbox-streams/_types.mjs

@@ -0,0 +1 @@
+export * from './_types.js';

frontend/node_modules/workbox-streams/_version.js

@@ -0,0 +1,6 @@
+"use strict";
+// @ts-ignore
+try {
+    self['workbox:streams:7.3.0'] && _();
+}
+catch (e) { }

frontend/node_modules/workbox-streams/_version.mjs

@@ -0,0 +1 @@
+try{self['workbox:streams:7.4.0']&&_()}catch(e){}// eslint-disable-line

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

@@ -0,0 +1,303 @@
+this.workbox = this.workbox || {};
+this.workbox.streams = (function (exports, assert_js, Deferred_js, logger_js, WorkboxError_js, canConstructReadableStream_js) {
+    'use strict';
+
+    // @ts-ignore
+    try {
+      self['workbox:streams:7.3.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.
+    */
+    /**
+     * 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 instanceof Response) {
+        // See https://github.com/GoogleChrome/workbox/issues/2998
+        if (source.body) {
+          return source.body.getReader();
+        }
+        throw new WorkboxError_js.WorkboxError('opaque-streams-source', {
+          type: source.type
+        });
+      }
+      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<workbox-streams.StreamSource>>} sourcePromises
+     * @return {Object<{done: Promise, stream: ReadableStream}>}
+     *
+     * @memberof 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 => {
+            if (reader instanceof ReadableStreamDefaultReader) {
+              return reader.read();
+            } else {
+              return;
+            }
+          }).then(result => {
+            if (result === null || result === void 0 ? void 0 : 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 === null || result === void 0 ? void 0 : 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 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.
+    */
+    /**
+     * 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() {
+      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 workbox-routing~handlerCallback}
+     * but that instead 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~handlerCallback}
+     * @memberof 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, workbox.core._private);
+//# sourceMappingURL=workbox-streams.dev.js.map

frontend/node_modules/workbox-streams/build/workbox-streams.prod.js

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

frontend/node_modules/workbox-streams/concatenate.d.ts

@@ -0,0 +1,20 @@
+import { StreamSource } from './_types.js';
+import './_version.js';
+/**
+ * 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
+ */
+declare function concatenate(sourcePromises: Promise<StreamSource>[]): {
+    done: Promise<void>;
+    stream: ReadableStream;
+};
+export { concatenate };

frontend/node_modules/workbox-streams/concatenate.js

@@ -0,0 +1,127 @@
+/*
+  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.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { Deferred } from 'workbox-core/_private/Deferred.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import './_version.js';
+/**
+ * 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 instanceof Response) {
+        // See https://github.com/GoogleChrome/workbox/issues/2998
+        if (source.body) {
+            return source.body.getReader();
+        }
+        throw new WorkboxError('opaque-streams-source', { type: source.type });
+    }
+    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<workbox-streams.StreamSource>>} sourcePromises
+ * @return {Object<{done: Promise, stream: ReadableStream}>}
+ *
+ * @memberof workbox-streams
+ */
+function concatenate(sourcePromises) {
+    if (process.env.NODE_ENV !== 'production') {
+        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();
+    let i = 0;
+    const logMessages = [];
+    const stream = new ReadableStream({
+        pull(controller) {
+            return readerPromises[i]
+                .then((reader) => {
+                if (reader instanceof ReadableStreamDefaultReader) {
+                    return reader.read();
+                }
+                else {
+                    return;
+                }
+            })
+                .then((result) => {
+                if (result === null || result === void 0 ? void 0 : result.done) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        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.
+                        if (process.env.NODE_ENV !== 'production') {
+                            logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+                            for (const message of logMessages) {
+                                if (Array.isArray(message)) {
+                                    logger.log(...message);
+                                }
+                                else {
+                                    logger.log(message);
+                                }
+                            }
+                            logger.log('Finished reading all sources.');
+                            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 === null || result === void 0 ? void 0 : result.value);
+                }
+            })
+                .catch((error) => {
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.error('An error occurred:', error);
+                }
+                streamDeferred.reject(error);
+                throw error;
+            });
+        },
+        cancel() {
+            if (process.env.NODE_ENV !== 'production') {
+                logger.warn('The ReadableStream was cancelled.');
+            }
+            streamDeferred.resolve();
+        },
+    });
+    return { done: streamDeferred.promise, stream };
+}
+export { concatenate };

frontend/node_modules/workbox-streams/concatenate.mjs

@@ -0,0 +1 @@
+export * from './concatenate.js';

frontend/node_modules/workbox-streams/concatenateToResponse.d.ts

@@ -0,0 +1,24 @@
+import { StreamSource } from './_types.js';
+import './_version.js';
+/**
+ * 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
+ */
+declare function concatenateToResponse(sourcePromises: Promise<StreamSource>[], headersInit: HeadersInit): {
+    done: Promise<void>;
+    response: Response;
+};
+export { concatenateToResponse };

frontend/node_modules/workbox-streams/concatenateToResponse.js

@@ -0,0 +1,34 @@
+/*
+  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.
+*/
+import { createHeaders } from './utils/createHeaders.js';
+import { concatenate } from './concatenate.js';
+import './_version.js';
+/**
+ * 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 };
+}
+export { concatenateToResponse };

frontend/node_modules/workbox-streams/concatenateToResponse.mjs

@@ -0,0 +1 @@
+export * from './concatenateToResponse.js';

frontend/node_modules/workbox-streams/index.d.ts

@@ -0,0 +1,10 @@
+import { concatenate } from './concatenate.js';
+import { concatenateToResponse } from './concatenateToResponse.js';
+import { isSupported } from './isSupported.js';
+import { strategy, StreamsHandlerCallback } from './strategy.js';
+import './_version.js';
+/**
+ * @module workbox-streams
+ */
+export { concatenate, concatenateToResponse, isSupported, strategy, StreamsHandlerCallback, };
+export * from './_types.js';

frontend/node_modules/workbox-streams/index.js

@@ -0,0 +1,17 @@
+/*
+  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.
+*/
+import { concatenate } from './concatenate.js';
+import { concatenateToResponse } from './concatenateToResponse.js';
+import { isSupported } from './isSupported.js';
+import { strategy } from './strategy.js';
+import './_version.js';
+/**
+ * @module workbox-streams
+ */
+export { concatenate, concatenateToResponse, isSupported, strategy, };
+export * from './_types.js';

frontend/node_modules/workbox-streams/index.mjs

@@ -0,0 +1 @@
+export * from './index.js';

frontend/node_modules/workbox-streams/isSupported.d.ts

@@ -0,0 +1,14 @@
+import './_version.js';
+/**
+ * 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
+ */
+declare function isSupported(): boolean;
+export { isSupported };

frontend/node_modules/workbox-streams/isSupported.js

@@ -0,0 +1,24 @@
+/*
+  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.
+*/
+import { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';
+import './_version.js';
+/**
+ * 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() {
+    return canConstructReadableStream();
+}
+export { isSupported };

frontend/node_modules/workbox-streams/isSupported.mjs

@@ -0,0 +1 @@
+export * from './isSupported.js';

frontend/node_modules/workbox-streams/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "workbox-streams",
+  "version": "7.4.0",
+  "license": "MIT",
+  "author": "Google's Web DevRel Team and Google's Aurora Team",
+  "description": "A library that makes it easier to work with Streams in the browser.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "bugs": "https://github.com/googlechrome/workbox/issues",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "streams",
+    "readablestream"
+  ],
+  "workbox": {
+    "browserNamespace": "workbox.streams",
+    "packageType": "sw"
+  },
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "dependencies": {
+    "workbox-core": "7.4.0",
+    "workbox-routing": "7.4.0"
+  },
+  "gitHead": "fa702feeddd417fcdfa495cd9428fb4a28632e92"
+}

frontend/node_modules/workbox-streams/src/_types.ts

@@ -0,0 +1,23 @@
+/*
+  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.
+*/
+
+import './_version.js';
+
+export type StreamSource = Response | ReadableStream | BodyInit;
+
+// * * * IMPORTANT! * * *
+// ------------------------------------------------------------------------- //
+// jdsoc type definitions cannot be declared above TypeScript definitions or
+// they'll be stripped from the built `.js` files, and they'll only be in the
+// `d.ts` files, which aren't read by the jsdoc generator. As a result we
+// have to put declare them below.
+
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox-streams
+ */

frontend/node_modules/workbox-streams/src/_version.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+try{self['workbox:streams:7.4.0']&&_()}catch(e){}

frontend/node_modules/workbox-streams/src/concatenate.ts

@@ -0,0 +1,146 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {Deferred} from 'workbox-core/_private/Deferred.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {StreamSource} from './_types.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+
+import './_version.js';
+
+/**
+ * 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: StreamSource,
+): ReadableStreamReader<unknown> {
+  if (source instanceof Response) {
+    // See https://github.com/GoogleChrome/workbox/issues/2998
+    if (source.body) {
+      return source.body.getReader();
+    }
+    throw new WorkboxError('opaque-streams-source', {type: source.type});
+  }
+  if (source instanceof ReadableStream) {
+    return source.getReader();
+  }
+  return new Response(source as BodyInit).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: Promise<StreamSource>[]): {
+  done: Promise<void>;
+  stream: ReadableStream;
+} {
+  if (process.env.NODE_ENV !== 'production') {
+    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: Deferred<void> = new Deferred();
+
+  let i = 0;
+  const logMessages: any[] = [];
+  const stream = new ReadableStream({
+    pull(controller: ReadableStreamDefaultController<any>) {
+      return readerPromises[i]
+        .then((reader) => {
+          if (reader instanceof ReadableStreamDefaultReader) {
+            return reader.read();
+          } else {
+            return;
+          }
+        })
+        .then((result) => {
+          if (result?.done) {
+            if (process.env.NODE_ENV !== 'production') {
+              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.
+              if (process.env.NODE_ENV !== 'production') {
+                logger.groupCollapsed(
+                  `Concatenating ${readerPromises.length} sources.`,
+                );
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger.log(...message);
+                  } else {
+                    logger.log(message);
+                  }
+                }
+                logger.log('Finished reading all sources.');
+                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) => {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.error('An error occurred:', error);
+          }
+          streamDeferred.reject(error);
+          throw error;
+        });
+    },
+
+    cancel() {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.warn('The ReadableStream was cancelled.');
+      }
+
+      streamDeferred.resolve();
+    },
+  });
+
+  return {done: streamDeferred.promise, stream};
+}
+
+export {concatenate};

frontend/node_modules/workbox-streams/src/concatenateToResponse.ts

@@ -0,0 +1,43 @@
+/*
+  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.
+*/
+
+import {createHeaders} from './utils/createHeaders.js';
+import {concatenate} from './concatenate.js';
+import {StreamSource} from './_types.js';
+import './_version.js';
+
+/**
+ * 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: Promise<StreamSource>[],
+  headersInit: HeadersInit,
+): {done: Promise<void>; response: Response} {
+  const {done, stream} = concatenate(sourcePromises);
+
+  const headers = createHeaders(headersInit);
+  const response = new Response(stream, {headers});
+
+  return {done, response};
+}
+
+export {concatenateToResponse};

frontend/node_modules/workbox-streams/src/index.ts

@@ -0,0 +1,28 @@
+/*
+  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.
+*/
+
+import {concatenate} from './concatenate.js';
+import {concatenateToResponse} from './concatenateToResponse.js';
+import {isSupported} from './isSupported.js';
+import {strategy, StreamsHandlerCallback} from './strategy.js';
+
+import './_version.js';
+
+/**
+ * @module workbox-streams
+ */
+
+export {
+  concatenate,
+  concatenateToResponse,
+  isSupported,
+  strategy,
+  StreamsHandlerCallback,
+};
+
+export * from './_types.js';

frontend/node_modules/workbox-streams/src/isSupported.ts

@@ -0,0 +1,27 @@
+/*
+  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.
+*/
+
+import {canConstructReadableStream} from 'workbox-core/_private/canConstructReadableStream.js';
+import './_version.js';
+
+/**
+ * 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(): boolean {
+  return canConstructReadableStream();
+}
+
+export {isSupported};

frontend/node_modules/workbox-streams/src/strategy.ts

@@ -0,0 +1,94 @@
+/*
+  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.
+*/
+
+import {logger} from 'workbox-core/_private/logger.js';
+import {
+  RouteHandlerCallback,
+  RouteHandlerCallbackOptions,
+} from 'workbox-core/types.js';
+import {createHeaders} from './utils/createHeaders.js';
+import {concatenateToResponse} from './concatenateToResponse.js';
+import {isSupported} from './isSupported.js';
+import {StreamSource} from './_types.js';
+import './_version.js';
+
+export interface StreamsHandlerCallback {
+  ({url, request, event, params}: RouteHandlerCallbackOptions):
+    | Promise<StreamSource>
+    | StreamSource;
+}
+
+/**
+ * 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 workbox-routing~handlerCallback}
+ * but that instead 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~handlerCallback}
+ * @memberof workbox-streams
+ */
+function strategy(
+  sourceFunctions: StreamsHandlerCallback[],
+  headersInit: HeadersInit,
+): RouteHandlerCallback {
+  return async ({event, request, url, params}: RouteHandlerCallbackOptions) => {
+    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;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      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});
+  };
+}
+
+export {strategy};

frontend/node_modules/workbox-streams/src/utils/createHeaders.ts

@@ -0,0 +1,34 @@
+/*
+  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.
+*/
+
+import '../_version.js';
+
+/**
+ * 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 workbox-streams
+ */
+function createHeaders(headersInit = {}): Headers {
+  // 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;
+}
+
+export {createHeaders};

frontend/node_modules/workbox-streams/strategy.d.ts

@@ -0,0 +1,24 @@
+import { RouteHandlerCallback, RouteHandlerCallbackOptions } from 'workbox-core/types.js';
+import { StreamSource } from './_types.js';
+import './_version.js';
+export interface StreamsHandlerCallback {
+    ({ url, request, event, params }: RouteHandlerCallbackOptions): Promise<StreamSource> | StreamSource;
+}
+/**
+ * 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 workbox-routing~handlerCallback}
+ * but that instead 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~handlerCallback}
+ * @memberof workbox-streams
+ */
+declare function strategy(sourceFunctions: StreamsHandlerCallback[], headersInit: HeadersInit): RouteHandlerCallback;
+export { strategy };

frontend/node_modules/workbox-streams/strategy.js

@@ -0,0 +1,68 @@
+/*
+  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.
+*/
+import { logger } from 'workbox-core/_private/logger.js';
+import { createHeaders } from './utils/createHeaders.js';
+import { concatenateToResponse } from './concatenateToResponse.js';
+import { isSupported } from './isSupported.js';
+import './_version.js';
+/**
+ * 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 workbox-routing~handlerCallback}
+ * but that instead 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~handlerCallback}
+ * @memberof 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;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            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 });
+    };
+}
+export { strategy };

frontend/node_modules/workbox-streams/strategy.mjs

@@ -0,0 +1 @@
+export * from './strategy.js';

frontend/node_modules/workbox-streams/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "outDir": "./",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./tsconfig.tsbuildinfo"
+  },
+  "include": ["src/**/*.ts"],
+  "references": [{"path": "../workbox-core/"}]
+}

frontend/node_modules/workbox-streams/utils/createHeaders.d.ts

@@ -0,0 +1,17 @@
+import '../_version.js';
+/**
+ * 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 workbox-streams
+ */
+declare function createHeaders(headersInit?: {}): Headers;
+export { createHeaders };

frontend/node_modules/workbox-streams/utils/createHeaders.js

@@ -0,0 +1,31 @@
+/*
+  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.
+*/
+import '../_version.js';
+/**
+ * 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 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;
+}
+export { createHeaders };

frontend/node_modules/workbox-streams/utils/createHeaders.mjs

@@ -0,0 +1 @@
+export * from './createHeaders.js';