Mail

frontend/node_modules/workbox-webpack-plugin/build/generate-sw.d.ts

@@ -0,0 +1,72 @@
+import webpack from 'webpack';
+import { ManifestEntry, WebpackGenerateSWOptions } from 'workbox-build';
+export interface GenerateSWConfig extends WebpackGenerateSWOptions {
+    manifestEntries?: Array<ManifestEntry>;
+}
+/**
+ * This class supports creating a new, ready-to-use service worker file as
+ * part of the webpack compilation process.
+ *
+ * Use an instance of `GenerateSW` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new GenerateSW({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   navigateFallback: '...',
+ *   runtimeCaching: [{
+ *     // Routing via a matchCallback function:
+ *     urlPattern: ({request, url}) => ...,
+ *     handler: '...',
+ *     options: {
+ *       cacheName: '...',
+ *       expiration: {
+ *         maxEntries: ...,
+ *       },
+ *     },
+ *   }, {
+ *     // Routing via a RegExp:
+ *     urlPattern: new RegExp('...'),
+ *     handler: '...',
+ *     options: {
+ *       cacheName: '...',
+ *       plugins: [..., ...],
+ *     },
+ *   }],
+ *   skipWaiting: ...,
+ * });
+ * ```
+ *
+ * @memberof module:workbox-webpack-plugin
+ */
+declare class GenerateSW {
+    protected config: GenerateSWConfig;
+    private alreadyCalled;
+    /**
+     * Creates an instance of GenerateSW.
+     */
+    constructor(config?: GenerateSWConfig);
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    propagateWebpackConfig(compiler: webpack.Compiler): void;
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    apply(compiler: webpack.Compiler): void;
+    /**
+     * @param {Object} compilation The webpack compilation.
+     *
+     * @private
+     */
+    addAssets(compilation: webpack.Compilation): Promise<void>;
+}
+export { GenerateSW };

frontend/node_modules/workbox-webpack-plugin/build/generate-sw.js

@@ -0,0 +1,189 @@
+"use strict";
+/*
+  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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateSW = void 0;
+const validate_options_1 = require("workbox-build/build/lib/validate-options");
+const bundle_1 = require("workbox-build/build/lib/bundle");
+const populate_sw_template_1 = require("workbox-build/build/lib/populate-sw-template");
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const webpack_1 = __importDefault(require("webpack"));
+const get_script_files_for_chunks_1 = require("./lib/get-script-files-for-chunks");
+const get_manifest_entries_from_compilation_1 = require("./lib/get-manifest-entries-from-compilation");
+const relative_to_output_path_1 = require("./lib/relative-to-output-path");
+// webpack v4/v5 compatibility:
+// https://github.com/webpack/webpack/issues/11425#issuecomment-686607633
+const { RawSource } = webpack_1.default.sources || require('webpack-sources');
+// Used to keep track of swDest files written by *any* instance of this plugin.
+// See https://github.com/GoogleChrome/workbox/issues/2181
+const _generatedAssetNames = new Set();
+/**
+ * This class supports creating a new, ready-to-use service worker file as
+ * part of the webpack compilation process.
+ *
+ * Use an instance of `GenerateSW` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new GenerateSW({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   navigateFallback: '...',
+ *   runtimeCaching: [{
+ *     // Routing via a matchCallback function:
+ *     urlPattern: ({request, url}) => ...,
+ *     handler: '...',
+ *     options: {
+ *       cacheName: '...',
+ *       expiration: {
+ *         maxEntries: ...,
+ *       },
+ *     },
+ *   }, {
+ *     // Routing via a RegExp:
+ *     urlPattern: new RegExp('...'),
+ *     handler: '...',
+ *     options: {
+ *       cacheName: '...',
+ *       plugins: [..., ...],
+ *     },
+ *   }],
+ *   skipWaiting: ...,
+ * });
+ * ```
+ *
+ * @memberof module:workbox-webpack-plugin
+ */
+class GenerateSW {
+    /**
+     * Creates an instance of GenerateSW.
+     */
+    constructor(config = {}) {
+        this.config = config;
+        this.alreadyCalled = false;
+    }
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    propagateWebpackConfig(compiler) {
+        // Because this.config is listed last, properties that are already set
+        // there take precedence over derived properties from the compiler.
+        this.config = Object.assign({
+            mode: compiler.options.mode,
+            sourcemap: Boolean(compiler.options.devtool),
+        }, this.config);
+    }
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    apply(compiler) {
+        this.propagateWebpackConfig(compiler);
+        // webpack v4/v5 compatibility:
+        // https://github.com/webpack/webpack/issues/11425#issuecomment-690387207
+        if (webpack_1.default.version.startsWith('4.')) {
+            compiler.hooks.emit.tapPromise(this.constructor.name, (compilation) => this.addAssets(compilation).catch((error) => {
+                compilation.errors.push(error);
+            }));
+        }
+        else {
+            const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = webpack_1.default.Compilation;
+            // Specifically hook into thisCompilation, as per
+            // https://github.com/webpack/webpack/issues/11425#issuecomment-690547848
+            compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation) => {
+                compilation.hooks.processAssets.tapPromise({
+                    name: this.constructor.name,
+                    // TODO(jeffposnick): This may need to change eventually.
+                    // See https://github.com/webpack/webpack/issues/11822#issuecomment-726184972
+                    stage: PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 10,
+                }, () => this.addAssets(compilation).catch((error) => {
+                    compilation.errors.push(error);
+                }));
+            });
+        }
+    }
+    /**
+     * @param {Object} compilation The webpack compilation.
+     *
+     * @private
+     */
+    async addAssets(compilation) {
+        var _a;
+        // See https://github.com/GoogleChrome/workbox/issues/1790
+        if (this.alreadyCalled) {
+            const warningMessage = `${this.constructor.name} has been called ` +
+                `multiple times, perhaps due to running webpack in --watch mode. The ` +
+                `precache manifest generated after the first call may be inaccurate! ` +
+                `Please see https://github.com/GoogleChrome/workbox/issues/1790 for ` +
+                `more information.`;
+            if (!compilation.warnings.some((warning) => warning instanceof Error && warning.message === warningMessage)) {
+                compilation.warnings.push(Error(warningMessage));
+            }
+        }
+        else {
+            this.alreadyCalled = true;
+        }
+        let config = {};
+        try {
+            // emit might be called multiple times; instead of modifying this.config,
+            // use a validated copy.
+            // See https://github.com/GoogleChrome/workbox/issues/2158
+            config = (0, validate_options_1.validateWebpackGenerateSWOptions)(this.config);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Please check your ${this.constructor.name} plugin ` +
+                    `configuration:\n${error.message}`);
+            }
+        }
+        // Ensure that we don't precache any of the assets generated by *any*
+        // instance of this plugin.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        config.exclude.push(({ asset }) => _generatedAssetNames.has(asset.name));
+        if (config.importScriptsViaChunks) {
+            // Anything loaded via importScripts() is implicitly cached by the service
+            // worker, and should not be added to the precache manifest.
+            config.excludeChunks = (config.excludeChunks || []).concat(config.importScriptsViaChunks);
+            const scripts = (0, get_script_files_for_chunks_1.getScriptFilesForChunks)(compilation, config.importScriptsViaChunks);
+            config.importScripts = (config.importScripts || []).concat(scripts);
+        }
+        const { size, sortedEntries } = await (0, get_manifest_entries_from_compilation_1.getManifestEntriesFromCompilation)(compilation, config);
+        config.manifestEntries = sortedEntries;
+        const unbundledCode = (0, populate_sw_template_1.populateSWTemplate)(config);
+        const files = await (0, bundle_1.bundle)({
+            babelPresetEnvTargets: config.babelPresetEnvTargets,
+            inlineWorkboxRuntime: config.inlineWorkboxRuntime,
+            mode: config.mode,
+            sourcemap: config.sourcemap,
+            swDest: (0, relative_to_output_path_1.relativeToOutputPath)(compilation, config.swDest),
+            unbundledCode,
+        });
+        for (const file of files) {
+            compilation.emitAsset(file.name, new RawSource(Buffer.from(file.contents)), {
+                // See https://github.com/webpack-contrib/compression-webpack-plugin/issues/218#issuecomment-726196160
+                minimized: config.mode === 'production',
+            });
+            _generatedAssetNames.add(file.name);
+        }
+        if (compilation.getLogger) {
+            const logger = compilation.getLogger(this.constructor.name);
+            logger.info(`The service worker at ${(_a = config.swDest) !== null && _a !== void 0 ? _a : ''} will precache
+        ${config.manifestEntries.length} URLs, totaling ${(0, pretty_bytes_1.default)(size)}.`);
+        }
+    }
+}
+exports.GenerateSW = GenerateSW;

frontend/node_modules/workbox-webpack-plugin/build/index.d.ts

@@ -0,0 +1,11 @@
+import { GenerateSW, GenerateSWConfig } from './generate-sw';
+import { InjectManifest } from './inject-manifest';
+/**
+ * @module workbox-webpack-plugin
+ */
+export { GenerateSW, GenerateSWConfig, InjectManifest };
+declare const _default: {
+    GenerateSW: typeof GenerateSW;
+    InjectManifest: typeof InjectManifest;
+};
+export default _default;

frontend/node_modules/workbox-webpack-plugin/build/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+  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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectManifest = exports.GenerateSW = void 0;
+const generate_sw_1 = require("./generate-sw");
+Object.defineProperty(exports, "GenerateSW", { enumerable: true, get: function () { return generate_sw_1.GenerateSW; } });
+const inject_manifest_1 = require("./inject-manifest");
+Object.defineProperty(exports, "InjectManifest", { enumerable: true, get: function () { return inject_manifest_1.InjectManifest; } });
+// TODO: remove this in v7.
+// See https://github.com/GoogleChrome/workbox/issues/3033
+exports.default = { GenerateSW: generate_sw_1.GenerateSW, InjectManifest: inject_manifest_1.InjectManifest };

frontend/node_modules/workbox-webpack-plugin/build/inject-manifest.d.ts

@@ -0,0 +1,74 @@
+import webpack from 'webpack';
+import { WebpackInjectManifestOptions } from 'workbox-build';
+/**
+ * This class supports compiling a service worker file provided via `swSrc`,
+ * and injecting into that service worker a list of URLs and revision
+ * information for precaching based on the webpack asset pipeline.
+ *
+ * Use an instance of `InjectManifest` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * In addition to injecting the manifest, this plugin will perform a compilation
+ * of the `swSrc` file, using the options from the main webpack configuration.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new InjectManifest({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swSrc: '...',
+ * });
+ * ```
+ *
+ * @memberof module:workbox-webpack-plugin
+ */
+declare class InjectManifest {
+    protected config: WebpackInjectManifestOptions;
+    private alreadyCalled;
+    /**
+     * Creates an instance of InjectManifest.
+     */
+    constructor(config: WebpackInjectManifestOptions);
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    propagateWebpackConfig(compiler: webpack.Compiler): void;
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    apply(compiler: webpack.Compiler): void;
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    addSrcToAssets(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): void;
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    handleMake(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+    /**
+     * @param {Object} compilation The webpack compilation.
+     *
+     * @private
+     */
+    addAssets(compilation: webpack.Compilation): Promise<void>;
+}
+export { InjectManifest };

frontend/node_modules/workbox-webpack-plugin/build/inject-manifest.js

@@ -0,0 +1,270 @@
+"use strict";
+/*
+  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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectManifest = void 0;
+const escape_regexp_1 = require("workbox-build/build/lib/escape-regexp");
+const replace_and_update_source_map_1 = require("workbox-build/build/lib/replace-and-update-source-map");
+const validate_options_1 = require("workbox-build/build/lib/validate-options");
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const upath_1 = __importDefault(require("upath"));
+const webpack_1 = __importDefault(require("webpack"));
+const get_manifest_entries_from_compilation_1 = require("./lib/get-manifest-entries-from-compilation");
+const get_sourcemap_asset_name_1 = require("./lib/get-sourcemap-asset-name");
+const relative_to_output_path_1 = require("./lib/relative-to-output-path");
+// Used to keep track of swDest files written by *any* instance of this plugin.
+// See https://github.com/GoogleChrome/workbox/issues/2181
+const _generatedAssetNames = new Set();
+// SingleEntryPlugin in v4 was renamed to EntryPlugin in v5.
+const SingleEntryPlugin = webpack_1.default.EntryPlugin || webpack_1.default.SingleEntryPlugin;
+// webpack v4/v5 compatibility:
+// https://github.com/webpack/webpack/issues/11425#issuecomment-686607633
+const { RawSource } = webpack_1.default.sources || require('webpack-sources');
+/**
+ * This class supports compiling a service worker file provided via `swSrc`,
+ * and injecting into that service worker a list of URLs and revision
+ * information for precaching based on the webpack asset pipeline.
+ *
+ * Use an instance of `InjectManifest` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * In addition to injecting the manifest, this plugin will perform a compilation
+ * of the `swSrc` file, using the options from the main webpack configuration.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new InjectManifest({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swSrc: '...',
+ * });
+ * ```
+ *
+ * @memberof module:workbox-webpack-plugin
+ */
+class InjectManifest {
+    /**
+     * Creates an instance of InjectManifest.
+     */
+    constructor(config) {
+        this.config = config;
+        this.alreadyCalled = false;
+    }
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    propagateWebpackConfig(compiler) {
+        // Because this.config is listed last, properties that are already set
+        // there take precedence over derived properties from the compiler.
+        this.config = Object.assign({
+            mode: compiler.options.mode,
+            // Use swSrc with a hardcoded .js extension, in case swSrc is a .ts file.
+            swDest: upath_1.default.parse(this.config.swSrc).name + '.js',
+        }, this.config);
+    }
+    /**
+     * @param {Object} [compiler] default compiler object passed from webpack
+     *
+     * @private
+     */
+    apply(compiler) {
+        var _a;
+        this.propagateWebpackConfig(compiler);
+        compiler.hooks.make.tapPromise(this.constructor.name, (compilation) => this.handleMake(compilation, compiler).catch((error) => {
+            compilation.errors.push(error);
+        }));
+        // webpack v4/v5 compatibility:
+        // https://github.com/webpack/webpack/issues/11425#issuecomment-690387207
+        if ((_a = webpack_1.default.version) === null || _a === void 0 ? void 0 : _a.startsWith('4.')) {
+            compiler.hooks.emit.tapPromise(this.constructor.name, (compilation) => this.addAssets(compilation).catch((error) => {
+                compilation.errors.push(error);
+            }));
+        }
+        else {
+            const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = webpack_1.default.Compilation;
+            // Specifically hook into thisCompilation, as per
+            // https://github.com/webpack/webpack/issues/11425#issuecomment-690547848
+            compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation) => {
+                compilation.hooks.processAssets.tapPromise({
+                    name: this.constructor.name,
+                    // TODO(jeffposnick): This may need to change eventually.
+                    // See https://github.com/webpack/webpack/issues/11822#issuecomment-726184972
+                    stage: PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 10,
+                }, () => this.addAssets(compilation).catch((error) => {
+                    compilation.errors.push(error);
+                }));
+            });
+        }
+    }
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    async performChildCompilation(compilation, parentCompiler) {
+        const outputOptions = {
+            path: parentCompiler.options.output.path,
+            filename: this.config.swDest,
+        };
+        const childCompiler = compilation.createChildCompiler(this.constructor.name, outputOptions, []);
+        childCompiler.context = parentCompiler.context;
+        childCompiler.inputFileSystem = parentCompiler.inputFileSystem;
+        childCompiler.outputFileSystem = parentCompiler.outputFileSystem;
+        if (Array.isArray(this.config.webpackCompilationPlugins)) {
+            for (const plugin of this.config.webpackCompilationPlugins) {
+                // plugin has a generic type, eslint complains for an unsafe
+                // assign and unsafe use
+                // eslint-disable-next-line
+                plugin.apply(childCompiler);
+            }
+        }
+        new SingleEntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
+        await new Promise((resolve, reject) => {
+            childCompiler.runAsChild((error, _entries, childCompilation) => {
+                var _a, _b;
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    compilation.warnings = compilation.warnings.concat((_a = childCompilation === null || childCompilation === void 0 ? void 0 : childCompilation.warnings) !== null && _a !== void 0 ? _a : []);
+                    compilation.errors = compilation.errors.concat((_b = childCompilation === null || childCompilation === void 0 ? void 0 : childCompilation.errors) !== null && _b !== void 0 ? _b : []);
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    addSrcToAssets(compilation, parentCompiler) {
+        // eslint-disable-next-line
+        const source = parentCompiler.inputFileSystem.readFileSync(this.config.swSrc);
+        compilation.emitAsset(this.config.swDest, new RawSource(source));
+    }
+    /**
+     * @param {Object} compilation The webpack compilation.
+     * @param {Object} parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    async handleMake(compilation, parentCompiler) {
+        try {
+            this.config = (0, validate_options_1.validateWebpackInjectManifestOptions)(this.config);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Please check your ${this.constructor.name} plugin ` +
+                    `configuration:\n${error.message}`);
+            }
+        }
+        this.config.swDest = (0, relative_to_output_path_1.relativeToOutputPath)(compilation, this.config.swDest);
+        _generatedAssetNames.add(this.config.swDest);
+        if (this.config.compileSrc) {
+            await this.performChildCompilation(compilation, parentCompiler);
+        }
+        else {
+            this.addSrcToAssets(compilation, parentCompiler);
+            // This used to be a fatal error, but just warn at runtime because we
+            // can't validate it easily.
+            if (Array.isArray(this.config.webpackCompilationPlugins) &&
+                this.config.webpackCompilationPlugins.length > 0) {
+                compilation.warnings.push(new Error('compileSrc is false, so the ' +
+                    'webpackCompilationPlugins option will be ignored.'));
+            }
+        }
+    }
+    /**
+     * @param {Object} compilation The webpack compilation.
+     *
+     * @private
+     */
+    async addAssets(compilation) {
+        var _a, _b, _c, _d, _e;
+        // See https://github.com/GoogleChrome/workbox/issues/1790
+        if (this.alreadyCalled) {
+            const warningMessage = `${this.constructor.name} has been called ` +
+                `multiple times, perhaps due to running webpack in --watch mode. The ` +
+                `precache manifest generated after the first call may be inaccurate! ` +
+                `Please see https://github.com/GoogleChrome/workbox/issues/1790 for ` +
+                `more information.`;
+            if (!compilation.warnings.some((warning) => warning instanceof Error && warning.message === warningMessage)) {
+                compilation.warnings.push(new Error(warningMessage));
+            }
+        }
+        else {
+            this.alreadyCalled = true;
+        }
+        const config = Object.assign({}, this.config);
+        // Ensure that we don't precache any of the assets generated by *any*
+        // instance of this plugin.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        config.exclude.push(({ asset }) => _generatedAssetNames.has(asset.name));
+        // See https://webpack.js.org/contribute/plugin-patterns/#monitoring-the-watch-graph
+        const absoluteSwSrc = upath_1.default.resolve(this.config.swSrc);
+        compilation.fileDependencies.add(absoluteSwSrc);
+        const swAsset = compilation.getAsset(config.swDest);
+        const swAssetString = swAsset.source.source().toString();
+        const globalRegexp = new RegExp((0, escape_regexp_1.escapeRegExp)(config.injectionPoint), 'g');
+        const injectionResults = swAssetString.match(globalRegexp);
+        if (!injectionResults) {
+            throw new Error(`Can't find ${(_a = config.injectionPoint) !== null && _a !== void 0 ? _a : ''} in your SW source.`);
+        }
+        if (injectionResults.length !== 1) {
+            throw new Error(`Multiple instances of ${(_b = config.injectionPoint) !== null && _b !== void 0 ? _b : ''} were ` +
+                `found in your SW source. Include it only once. For more info, see ` +
+                `https://github.com/GoogleChrome/workbox/issues/2681`);
+        }
+        const { size, sortedEntries } = await (0, get_manifest_entries_from_compilation_1.getManifestEntriesFromCompilation)(compilation, config);
+        let manifestString = (0, fast_json_stable_stringify_1.default)(sortedEntries);
+        if (this.config.compileSrc &&
+            // See https://github.com/GoogleChrome/workbox/issues/2729
+            !(((_c = compilation.options) === null || _c === void 0 ? void 0 : _c.devtool) === 'eval-cheap-source-map' &&
+                ((_d = compilation.options.optimization) === null || _d === void 0 ? void 0 : _d.minimize))) {
+            // See https://github.com/GoogleChrome/workbox/issues/2263
+            manifestString = manifestString.replace(/"/g, `'`);
+        }
+        const sourcemapAssetName = (0, get_sourcemap_asset_name_1.getSourcemapAssetName)(compilation, swAssetString, config.swDest);
+        if (sourcemapAssetName) {
+            _generatedAssetNames.add(sourcemapAssetName);
+            const sourcemapAsset = compilation.getAsset(sourcemapAssetName);
+            const { source, map } = await (0, replace_and_update_source_map_1.replaceAndUpdateSourceMap)({
+                jsFilename: config.swDest,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                originalMap: JSON.parse(sourcemapAsset.source.source().toString()),
+                originalSource: swAssetString,
+                replaceString: manifestString,
+                searchString: config.injectionPoint,
+            });
+            compilation.updateAsset(sourcemapAssetName, new RawSource(map));
+            compilation.updateAsset(config.swDest, new RawSource(source));
+        }
+        else {
+            // If there's no sourcemap associated with swDest, a simple string
+            // replacement will suffice.
+            compilation.updateAsset(config.swDest, new RawSource(swAssetString.replace(config.injectionPoint, manifestString)));
+        }
+        if (compilation.getLogger) {
+            const logger = compilation.getLogger(this.constructor.name);
+            logger.info(`The service worker at ${(_e = config.swDest) !== null && _e !== void 0 ? _e : ''} will precache
+        ${sortedEntries.length} URLs, totaling ${(0, pretty_bytes_1.default)(size)}.`);
+        }
+    }
+}
+exports.InjectManifest = InjectManifest;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-asset-hash.d.ts

@@ -0,0 +1,8 @@
+import type { Asset } from 'webpack';
+/**
+ * @param {Asset} asset
+ * @return {string} The MD5 hash of the asset's source.
+ *
+ * @private
+ */
+export declare function getAssetHash(asset: Asset): string | null;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-asset-hash.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+  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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * @param {Asset} asset
+ * @return {string} The MD5 hash of the asset's source.
+ *
+ * @private
+ */
+function getAssetHash(asset) {
+    // If webpack has the asset marked as immutable, then we don't need to
+    // use an out-of-band revision for it.
+    // See https://github.com/webpack/webpack/issues/9038
+    if (asset.info && asset.info.immutable) {
+        return null;
+    }
+    return crypto_1.default.createHash('md5')
+        .update(Buffer.from(asset.source.source()))
+        .digest('hex');
+}
+exports.getAssetHash = getAssetHash;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-manifest-entries-from-compilation.d.ts

@@ -0,0 +1,6 @@
+import { Compilation } from 'webpack';
+import { WebpackGenerateSWOptions, WebpackInjectManifestOptions, ManifestEntry } from 'workbox-build';
+export declare function getManifestEntriesFromCompilation(compilation: Compilation, config: WebpackGenerateSWOptions | WebpackInjectManifestOptions): Promise<{
+    size: number;
+    sortedEntries: ManifestEntry[];
+}>;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-manifest-entries-from-compilation.js

@@ -0,0 +1,188 @@
+"use strict";
+/*
+  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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManifestEntriesFromCompilation = void 0;
+const webpack_1 = require("webpack");
+const transform_manifest_1 = require("workbox-build/build/lib/transform-manifest");
+const get_asset_hash_1 = require("./get-asset-hash");
+const resolve_webpack_url_1 = require("./resolve-webpack-url");
+/**
+ * For a given asset, checks whether at least one of the conditions matches.
+ *
+ * @param {Asset} asset The webpack asset in question. This will be passed
+ * to any functions that are listed as conditions.
+ * @param {Compilation} compilation The webpack compilation. This will be passed
+ * to any functions that are listed as conditions.
+ * @param {Array<string|RegExp|Function>} conditions
+ * @return {boolean} Whether or not at least one condition matches.
+ * @private
+ */
+function checkConditions(asset, compilation, conditions = []) {
+    for (const condition of conditions) {
+        if (typeof condition === 'function') {
+            return condition({ asset, compilation });
+            //return compilation !== null;
+        }
+        else {
+            if (webpack_1.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
+                return true;
+            }
+        }
+    }
+    // We'll only get here if none of the conditions applied.
+    return false;
+}
+/**
+ * Returns the names of all the assets in all the chunks in a chunk group,
+ * if provided a chunk group name.
+ * Otherwise, if provided a chunk name, return all the assets in that chunk.
+ * Otherwise, if there isn't a chunk group or chunk with that name, return null.
+ *
+ * @param {Compilation} compilation
+ * @param {string} chunkOrGroup
+ * @return {Array<string>|null}
+ * @private
+ */
+function getNamesOfAssetsInChunkOrGroup(compilation, chunkOrGroup) {
+    const chunkGroup = compilation.namedChunkGroups &&
+        compilation.namedChunkGroups.get(chunkOrGroup);
+    if (chunkGroup) {
+        const assetNames = [];
+        for (const chunk of chunkGroup.chunks) {
+            assetNames.push(...getNamesOfAssetsInChunk(chunk));
+        }
+        return assetNames;
+    }
+    else {
+        const chunk = compilation.namedChunks && compilation.namedChunks.get(chunkOrGroup);
+        if (chunk) {
+            return getNamesOfAssetsInChunk(chunk);
+        }
+    }
+    // If we get here, there's no chunkGroup or chunk with that name.
+    return null;
+}
+/**
+ * Returns the names of all the assets in a chunk.
+ *
+ * @param {Chunk} chunk
+ * @return {Array<string>}
+ * @private
+ */
+function getNamesOfAssetsInChunk(chunk) {
+    const assetNames = [];
+    assetNames.push(...chunk.files);
+    // This only appears to be set in webpack v5.
+    if (chunk.auxiliaryFiles) {
+        assetNames.push(...chunk.auxiliaryFiles);
+    }
+    return assetNames;
+}
+/**
+ * Filters the set of assets out, based on the configuration options provided:
+ * - chunks and excludeChunks, for chunkName-based criteria.
+ * - include and exclude, for more general criteria.
+ *
+ * @param {Compilation} compilation The webpack compilation.
+ * @param {Object} config The validated configuration, obtained from the plugin.
+ * @return {Set<Asset>} The assets that should be included in the manifest,
+ * based on the criteria provided.
+ * @private
+ */
+function filterAssets(compilation, config) {
+    const filteredAssets = new Set();
+    const assets = compilation.getAssets();
+    const allowedAssetNames = new Set();
+    // See https://github.com/GoogleChrome/workbox/issues/1287
+    if (Array.isArray(config.chunks)) {
+        for (const name of config.chunks) {
+            // See https://github.com/GoogleChrome/workbox/issues/2717
+            const assetsInChunkOrGroup = getNamesOfAssetsInChunkOrGroup(compilation, name);
+            if (assetsInChunkOrGroup) {
+                for (const assetName of assetsInChunkOrGroup) {
+                    allowedAssetNames.add(assetName);
+                }
+            }
+            else {
+                compilation.warnings.push(new Error(`The chunk '${name}' was ` +
+                    `provided in your Workbox chunks config, but was not found in the ` +
+                    `compilation.`));
+            }
+        }
+    }
+    const deniedAssetNames = new Set();
+    if (Array.isArray(config.excludeChunks)) {
+        for (const name of config.excludeChunks) {
+            // See https://github.com/GoogleChrome/workbox/issues/2717
+            const assetsInChunkOrGroup = getNamesOfAssetsInChunkOrGroup(compilation, name);
+            if (assetsInChunkOrGroup) {
+                for (const assetName of assetsInChunkOrGroup) {
+                    deniedAssetNames.add(assetName);
+                }
+            } // Don't warn if the chunk group isn't found.
+        }
+    }
+    for (const asset of assets) {
+        // chunk based filtering is funky because:
+        // - Each asset might belong to one or more chunks.
+        // - If *any* of those chunk names match our config.excludeChunks,
+        //   then we skip that asset.
+        // - If the config.chunks is defined *and* there's no match
+        //   between at least one of the chunkNames and one entry, then
+        //   we skip that assets as well.
+        if (deniedAssetNames.has(asset.name)) {
+            continue;
+        }
+        if (Array.isArray(config.chunks) && !allowedAssetNames.has(asset.name)) {
+            continue;
+        }
+        // Next, check asset-level checks via includes/excludes:
+        const isExcluded = checkConditions(asset, compilation, config.exclude);
+        if (isExcluded) {
+            continue;
+        }
+        // Treat an empty config.includes as an implicit inclusion.
+        const isIncluded = !Array.isArray(config.include) ||
+            checkConditions(asset, compilation, config.include);
+        if (!isIncluded) {
+            continue;
+        }
+        // If we've gotten this far, then add the asset.
+        filteredAssets.add(asset);
+    }
+    return filteredAssets;
+}
+async function getManifestEntriesFromCompilation(compilation, config) {
+    const filteredAssets = filterAssets(compilation, config);
+    const { publicPath } = compilation.options.output;
+    const fileDetails = Array.from(filteredAssets).map((asset) => {
+        return {
+            file: (0, resolve_webpack_url_1.resolveWebpackURL)(publicPath, asset.name),
+            hash: (0, get_asset_hash_1.getAssetHash)(asset),
+            size: asset.source.size() || 0,
+        };
+    });
+    const { manifestEntries, size, warnings } = await (0, transform_manifest_1.transformManifest)({
+        fileDetails,
+        additionalManifestEntries: config.additionalManifestEntries,
+        dontCacheBustURLsMatching: config.dontCacheBustURLsMatching,
+        manifestTransforms: config.manifestTransforms,
+        maximumFileSizeToCacheInBytes: config.maximumFileSizeToCacheInBytes,
+        modifyURLPrefix: config.modifyURLPrefix,
+        transformParam: compilation,
+    });
+    // See https://github.com/GoogleChrome/workbox/issues/2790
+    for (const warning of warnings) {
+        compilation.warnings.push(new Error(warning));
+    }
+    // Ensure that the entries are properly sorted by URL.
+    const sortedEntries = manifestEntries.sort((a, b) => a.url === b.url ? 0 : a.url > b.url ? 1 : -1);
+    return { size, sortedEntries };
+}
+exports.getManifestEntriesFromCompilation = getManifestEntriesFromCompilation;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-script-files-for-chunks.d.ts

@@ -0,0 +1,2 @@
+import { Compilation } from 'webpack';
+export declare function getScriptFilesForChunks(compilation: Compilation, chunkNames: Array<string>): Array<string>;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-script-files-for-chunks.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+  Copyright 2019 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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScriptFilesForChunks = void 0;
+const upath_1 = __importDefault(require("upath"));
+const resolve_webpack_url_1 = require("./resolve-webpack-url");
+function getScriptFilesForChunks(compilation, chunkNames) {
+    var _a;
+    const { chunks } = compilation.getStats().toJson({ chunks: true });
+    const { publicPath } = compilation.options.output;
+    const scriptFiles = new Set();
+    for (const chunkName of chunkNames) {
+        const chunk = chunks.find((chunk) => { var _a; return (_a = chunk.names) === null || _a === void 0 ? void 0 : _a.includes(chunkName); });
+        if (chunk) {
+            for (const file of (_a = chunk === null || chunk === void 0 ? void 0 : chunk.files) !== null && _a !== void 0 ? _a : []) {
+                // See https://github.com/GoogleChrome/workbox/issues/2161
+                if (upath_1.default.extname(file) === '.js') {
+                    scriptFiles.add((0, resolve_webpack_url_1.resolveWebpackURL)(publicPath, file));
+                }
+            }
+        }
+        else {
+            compilation.warnings.push(new Error(`${chunkName} was provided to ` +
+                `importScriptsViaChunks, but didn't match any named chunks.`));
+        }
+    }
+    if (scriptFiles.size === 0) {
+        compilation.warnings.push(new Error(`There were no assets matching ` +
+            `importScriptsViaChunks: [${chunkNames.join(' ')}].`));
+    }
+    return Array.from(scriptFiles);
+}
+exports.getScriptFilesForChunks = getScriptFilesForChunks;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-sourcemap-asset-name.d.ts

@@ -0,0 +1,20 @@
+import type { Compilation } from 'webpack';
+/**
+ * If our bundled swDest file contains a sourcemap, we would invalidate that
+ * mapping if we just replaced injectionPoint with the stringified manifest.
+ * Instead, we need to update the swDest contents as well as the sourcemap
+ * at the same time.
+ *
+ * See https://github.com/GoogleChrome/workbox/issues/2235
+ *
+ * @param {Object} compilation The current webpack compilation.
+ * @param {string} swContents The contents of the swSrc file, which may or
+ * may not include a valid sourcemap comment.
+ * @param {string} swDest The configured swDest value.
+ * @return {string|undefined} If the swContents contains a valid sourcemap
+ * comment pointing to an asset present in the compilation, this will return the
+ * name of that asset. Otherwise, it will return undefined.
+ *
+ * @private
+ */
+export declare function getSourcemapAssetName(compilation: Compilation, swContents: string, swDest: string): string | undefined;

frontend/node_modules/workbox-webpack-plugin/build/lib/get-sourcemap-asset-name.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+  Copyright 2019 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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourcemapAssetName = void 0;
+const get_source_map_url_1 = require("workbox-build/build/lib/get-source-map-url");
+const upath_1 = __importDefault(require("upath"));
+/**
+ * If our bundled swDest file contains a sourcemap, we would invalidate that
+ * mapping if we just replaced injectionPoint with the stringified manifest.
+ * Instead, we need to update the swDest contents as well as the sourcemap
+ * at the same time.
+ *
+ * See https://github.com/GoogleChrome/workbox/issues/2235
+ *
+ * @param {Object} compilation The current webpack compilation.
+ * @param {string} swContents The contents of the swSrc file, which may or
+ * may not include a valid sourcemap comment.
+ * @param {string} swDest The configured swDest value.
+ * @return {string|undefined} If the swContents contains a valid sourcemap
+ * comment pointing to an asset present in the compilation, this will return the
+ * name of that asset. Otherwise, it will return undefined.
+ *
+ * @private
+ */
+function getSourcemapAssetName(compilation, swContents, swDest) {
+    const url = (0, get_source_map_url_1.getSourceMapURL)(swContents);
+    if (url) {
+        // Translate the relative URL to what the presumed name for the webpack
+        // asset should be.
+        // This *might* not be a valid asset if the sourcemap URL that was found
+        // was added by another module incidentally.
+        // See https://github.com/GoogleChrome/workbox/issues/2250
+        const swAssetDirname = upath_1.default.dirname(swDest);
+        const sourcemapURLAssetName = upath_1.default.normalize(upath_1.default.join(swAssetDirname, url));
+        // Not sure if there's a better way to check for asset existence?
+        if (compilation.getAsset(sourcemapURLAssetName)) {
+            return sourcemapURLAssetName;
+        }
+    }
+    return undefined;
+}
+exports.getSourcemapAssetName = getSourcemapAssetName;

frontend/node_modules/workbox-webpack-plugin/build/lib/relative-to-output-path.d.ts

@@ -0,0 +1,11 @@
+import type { Compilation } from 'webpack';
+/**
+ * @param {Object} compilation The webpack compilation.
+ * @param {string} swDest The original swDest value.
+ *
+ * @return {string} If swDest was not absolute, the returns swDest as-is.
+ * Otherwise, returns swDest relative to the compilation's output path.
+ *
+ * @private
+ */
+export declare function relativeToOutputPath(compilation: Compilation, swDest: string): string;

frontend/node_modules/workbox-webpack-plugin/build/lib/relative-to-output-path.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+  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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeToOutputPath = void 0;
+const upath_1 = __importDefault(require("upath"));
+/**
+ * @param {Object} compilation The webpack compilation.
+ * @param {string} swDest The original swDest value.
+ *
+ * @return {string} If swDest was not absolute, the returns swDest as-is.
+ * Otherwise, returns swDest relative to the compilation's output path.
+ *
+ * @private
+ */
+function relativeToOutputPath(compilation, swDest) {
+    // See https://github.com/jantimon/html-webpack-plugin/pull/266/files#diff-168726dbe96b3ce427e7fedce31bb0bcR38
+    if (upath_1.default.resolve(swDest) === upath_1.default.normalize(swDest)) {
+        return upath_1.default.relative(compilation.options.output.path, swDest);
+    }
+    // Otherwise, return swDest as-is.
+    return swDest;
+}
+exports.relativeToOutputPath = relativeToOutputPath;

frontend/node_modules/workbox-webpack-plugin/build/lib/resolve-webpack-url.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolves a url in the way that webpack would (with string concatenation)
+ *
+ * Use publicPath + filePath instead of url.resolve(publicPath, filePath) see:
+ * https://webpack.js.org/configuration/output/#output-publicpath
+ *
+ * @function resolveWebpackURL
+ * @param {string} publicPath The publicPath value from webpack's compilation.
+ * @param {Array<string>} paths File paths to join
+ * @return {string} Joined file path
+ *
+ * @private
+ */
+export declare function resolveWebpackURL(publicPath: string, ...paths: Array<string>): string;

frontend/node_modules/workbox-webpack-plugin/build/lib/resolve-webpack-url.js

@@ -0,0 +1,34 @@
+"use strict";
+/*
+  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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWebpackURL = void 0;
+/**
+ * Resolves a url in the way that webpack would (with string concatenation)
+ *
+ * Use publicPath + filePath instead of url.resolve(publicPath, filePath) see:
+ * https://webpack.js.org/configuration/output/#output-publicpath
+ *
+ * @function resolveWebpackURL
+ * @param {string} publicPath The publicPath value from webpack's compilation.
+ * @param {Array<string>} paths File paths to join
+ * @return {string} Joined file path
+ *
+ * @private
+ */
+function resolveWebpackURL(publicPath, ...paths) {
+    // This is a change in webpack v5.
+    // See https://github.com/jantimon/html-webpack-plugin/pull/1516
+    if (publicPath === 'auto') {
+        return paths.join('');
+    }
+    else {
+        return [publicPath, ...paths].join('');
+    }
+}
+exports.resolveWebpackURL = resolveWebpackURL;