Upload folder using huggingface_hub (part 53)

tools/ui/node_modules/workbox-build/build/index.d.ts

@@ -0,0 +1,10 @@
+import { copyWorkboxLibraries } from './lib/copy-workbox-libraries';
+import { getModuleURL } from './lib/cdn-utils';
+import { generateSW } from './generate-sw';
+import { getManifest } from './get-manifest';
+import { injectManifest } from './inject-manifest';
+/**
+ * @module workbox-build
+ */
+export { copyWorkboxLibraries, generateSW, getManifest, getModuleURL, injectManifest, };
+export * from './types';

tools/ui/node_modules/workbox-build/build/index.js

@@ -0,0 +1,35 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectManifest = exports.getModuleURL = exports.getManifest = exports.generateSW = exports.copyWorkboxLibraries = void 0;
+const copy_workbox_libraries_1 = require("./lib/copy-workbox-libraries");
+Object.defineProperty(exports, "copyWorkboxLibraries", { enumerable: true, get: function () { return copy_workbox_libraries_1.copyWorkboxLibraries; } });
+const cdn_utils_1 = require("./lib/cdn-utils");
+Object.defineProperty(exports, "getModuleURL", { enumerable: true, get: function () { return cdn_utils_1.getModuleURL; } });
+const generate_sw_1 = require("./generate-sw");
+Object.defineProperty(exports, "generateSW", { enumerable: true, get: function () { return generate_sw_1.generateSW; } });
+const get_manifest_1 = require("./get-manifest");
+Object.defineProperty(exports, "getManifest", { enumerable: true, get: function () { return get_manifest_1.getManifest; } });
+const inject_manifest_1 = require("./inject-manifest");
+Object.defineProperty(exports, "injectManifest", { enumerable: true, get: function () { return inject_manifest_1.injectManifest; } });
+__exportStar(require("./types"), exports);

tools/ui/node_modules/workbox-build/build/inject-manifest.d.ts

@@ -0,0 +1,30 @@
+import { BuildResult, InjectManifestOptions } from './types';
+/**
+ * This method creates a list of URLs to precache, referred to as a "precache
+ * manifest", based on the options you provide.
+ *
+ * The manifest is injected into the `swSrc` file, and the placeholder string
+ * `injectionPoint` determines where in the file the manifest should go.
+ *
+ * The final service worker file, with the manifest injected, is written to
+ * disk at `swDest`.
+ *
+ * This method will not compile or bundle your `swSrc` file; it just handles
+ * injecting the manifest.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * const {count, size, warnings} = await injectManifest({
+ *   dontCacheBustURLsMatching: [new RegExp('...')],
+ *   globDirectory: '...',
+ *   globPatterns: ['...', '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swDest: '...',
+ *   swSrc: '...',
+ * });
+ * ```
+ *
+ * @memberof workbox-build
+ */
+export declare function injectManifest(config: InjectManifestOptions): Promise<BuildResult>;

tools/ui/node_modules/workbox-build/build/inject-manifest.js

@@ -0,0 +1,133 @@
+"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 assert_1 = __importDefault(require("assert"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const upath_1 = __importDefault(require("upath"));
+const errors_1 = require("./lib/errors");
+const escape_regexp_1 = require("./lib/escape-regexp");
+const get_file_manifest_entries_1 = require("./lib/get-file-manifest-entries");
+const get_source_map_url_1 = require("./lib/get-source-map-url");
+const rebase_path_1 = require("./lib/rebase-path");
+const replace_and_update_source_map_1 = require("./lib/replace-and-update-source-map");
+const translate_url_to_sourcemap_paths_1 = require("./lib/translate-url-to-sourcemap-paths");
+const validate_options_1 = require("./lib/validate-options");
+/**
+ * This method creates a list of URLs to precache, referred to as a "precache
+ * manifest", based on the options you provide.
+ *
+ * The manifest is injected into the `swSrc` file, and the placeholder string
+ * `injectionPoint` determines where in the file the manifest should go.
+ *
+ * The final service worker file, with the manifest injected, is written to
+ * disk at `swDest`.
+ *
+ * This method will not compile or bundle your `swSrc` file; it just handles
+ * injecting the manifest.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * const {count, size, warnings} = await injectManifest({
+ *   dontCacheBustURLsMatching: [new RegExp('...')],
+ *   globDirectory: '...',
+ *   globPatterns: ['...', '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swDest: '...',
+ *   swSrc: '...',
+ * });
+ * ```
+ *
+ * @memberof workbox-build
+ */
+async function injectManifest(config) {
+    const options = (0, validate_options_1.validateInjectManifestOptions)(config);
+    // Make sure we leave swSrc and swDest out of the precache manifest.
+    for (const file of [options.swSrc, options.swDest]) {
+        options.globIgnores.push((0, rebase_path_1.rebasePath)({
+            file,
+            baseDirectory: options.globDirectory,
+        }));
+    }
+    const globalRegexp = new RegExp((0, escape_regexp_1.escapeRegExp)(options.injectionPoint), 'g');
+    const { count, size, manifestEntries, warnings } = await (0, get_file_manifest_entries_1.getFileManifestEntries)(options);
+    let swFileContents;
+    try {
+        swFileContents = await fs_extra_1.default.readFile(options.swSrc, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`${errors_1.errors['invalid-sw-src']} ${error instanceof Error && error.message ? error.message : ''}`);
+    }
+    const injectionResults = swFileContents.match(globalRegexp);
+    // See https://github.com/GoogleChrome/workbox/issues/2230
+    const injectionPoint = options.injectionPoint ? options.injectionPoint : '';
+    if (!injectionResults) {
+        if (upath_1.default.resolve(options.swSrc) === upath_1.default.resolve(options.swDest)) {
+            throw new Error(`${errors_1.errors['same-src-and-dest']} ${injectionPoint}`);
+        }
+        throw new Error(`${errors_1.errors['injection-point-not-found']} ${injectionPoint}`);
+    }
+    (0, assert_1.default)(injectionResults.length === 1, `${errors_1.errors['multiple-injection-points']} ${injectionPoint}`);
+    const manifestString = (0, fast_json_stable_stringify_1.default)(manifestEntries);
+    const filesToWrite = {};
+    const url = (0, get_source_map_url_1.getSourceMapURL)(swFileContents);
+    // See https://github.com/GoogleChrome/workbox/issues/2957
+    const { destPath, srcPath, warning } = (0, translate_url_to_sourcemap_paths_1.translateURLToSourcemapPaths)(url, options.swSrc, options.swDest);
+    if (warning) {
+        warnings.push(warning);
+    }
+    // If our swSrc 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
+    // (assuming it's a real file, not a data: URL) at the same time.
+    // See https://github.com/GoogleChrome/workbox/issues/2235
+    // and https://github.com/GoogleChrome/workbox/issues/2648
+    if (srcPath && destPath) {
+        const originalMap = (await fs_extra_1.default.readJSON(srcPath, {
+            encoding: 'utf8',
+        }));
+        const { map, source } = await (0, replace_and_update_source_map_1.replaceAndUpdateSourceMap)({
+            originalMap,
+            jsFilename: upath_1.default.basename(options.swDest),
+            originalSource: swFileContents,
+            replaceString: manifestString,
+            searchString: options.injectionPoint,
+        });
+        filesToWrite[options.swDest] = source;
+        filesToWrite[destPath] = map;
+    }
+    else {
+        // If there's no sourcemap associated with swSrc, a simple string
+        // replacement will suffice.
+        filesToWrite[options.swDest] = swFileContents.replace(globalRegexp, manifestString);
+    }
+    for (const [file, contents] of Object.entries(filesToWrite)) {
+        try {
+            await fs_extra_1.default.mkdirp(upath_1.default.dirname(file));
+        }
+        catch (error) {
+            throw new Error(errors_1.errors['unable-to-make-sw-directory'] +
+                ` '${error instanceof Error && error.message ? error.message : ''}'`);
+        }
+        await fs_extra_1.default.writeFile(file, contents);
+    }
+    return {
+        count,
+        size,
+        warnings,
+        // Use upath.resolve() to make all the paths absolute.
+        filePaths: Object.keys(filesToWrite).map((f) => upath_1.default.resolve(f)),
+    };
+}
+exports.injectManifest = injectManifest;

tools/ui/node_modules/workbox-build/build/lib/additional-manifest-entries-transform.d.ts

@@ -0,0 +1,13 @@
+import { ManifestEntry } from '../types';
+type AdditionalManifestEntriesTransform = {
+    (manifest: Array<ManifestEntry & {
+        size: number;
+    }>): {
+        manifest: Array<ManifestEntry & {
+            size: number;
+        }>;
+        warnings: string[];
+    };
+};
+export declare function additionalManifestEntriesTransform(additionalManifestEntries: Array<ManifestEntry | string>): AdditionalManifestEntriesTransform;
+export {};

tools/ui/node_modules/workbox-build/build/lib/additional-manifest-entries-transform.js

@@ -0,0 +1,47 @@
+"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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.additionalManifestEntriesTransform = void 0;
+const errors_1 = require("./errors");
+function additionalManifestEntriesTransform(additionalManifestEntries) {
+    return (manifest) => {
+        const warnings = [];
+        const stringEntries = new Set();
+        for (const additionalEntry of additionalManifestEntries) {
+            // Warn about either a string or an object that lacks a revision property.
+            // (An object with a revision property set to null is okay.)
+            if (typeof additionalEntry === 'string') {
+                stringEntries.add(additionalEntry);
+                manifest.push({
+                    revision: null,
+                    size: 0,
+                    url: additionalEntry,
+                });
+            }
+            else {
+                if (additionalEntry && additionalEntry.revision === undefined) {
+                    stringEntries.add(additionalEntry.url);
+                }
+                manifest.push(Object.assign({ size: 0 }, additionalEntry));
+            }
+        }
+        if (stringEntries.size > 0) {
+            let urls = '\n';
+            for (const stringEntry of stringEntries) {
+                urls += `  - ${stringEntry}\n`;
+            }
+            warnings.push(errors_1.errors['string-entry-warning'] + urls);
+        }
+        return {
+            manifest,
+            warnings,
+        };
+    };
+}
+exports.additionalManifestEntriesTransform = additionalManifestEntriesTransform;

tools/ui/node_modules/workbox-build/build/lib/bundle.d.ts

@@ -0,0 +1,9 @@
+import { GeneratePartial, RequiredSWDestPartial } from '../types';
+interface NameAndContents {
+    contents: string | Uint8Array;
+    name: string;
+}
+export declare function bundle({ babelPresetEnvTargets, inlineWorkboxRuntime, mode, sourcemap, swDest, unbundledCode, }: Omit<GeneratePartial, 'runtimeCaching'> & RequiredSWDestPartial & {
+    unbundledCode: string;
+}): Promise<Array<NameAndContents>>;
+export {};

tools/ui/node_modules/workbox-build/build/lib/bundle.js

@@ -0,0 +1,133 @@
+"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.bundle = void 0;
+const plugin_babel_1 = require("@rollup/plugin-babel");
+const plugin_node_resolve_1 = require("@rollup/plugin-node-resolve");
+const rollup_1 = require("rollup");
+const plugin_terser_1 = __importDefault(require("@rollup/plugin-terser"));
+const fs_extra_1 = require("fs-extra");
+const rollup_plugin_off_main_thread_1 = __importDefault(require("@trickfilm400/rollup-plugin-off-main-thread"));
+const preset_env_1 = __importDefault(require("@babel/preset-env"));
+const plugin_replace_1 = __importDefault(require("@rollup/plugin-replace"));
+const tempy_1 = __importDefault(require("tempy"));
+const upath_1 = __importDefault(require("upath"));
+async function bundle({ babelPresetEnvTargets, inlineWorkboxRuntime, mode, sourcemap, swDest, unbundledCode, }) {
+    // We need to write this to the "real" file system, as Rollup won't read from
+    // a custom file system.
+    const { dir, base } = upath_1.default.parse(swDest);
+    const temporaryFile = tempy_1.default.file({ name: base });
+    await (0, fs_extra_1.writeFile)(temporaryFile, unbundledCode);
+    const plugins = [
+        (0, plugin_node_resolve_1.nodeResolve)(),
+        (0, plugin_replace_1.default)({
+            // See https://github.com/GoogleChrome/workbox/issues/2769
+            'preventAssignment': true,
+            'process.env.NODE_ENV': JSON.stringify(mode),
+        }),
+        (0, plugin_babel_1.babel)({
+            babelHelpers: 'bundled',
+            // Disable the logic that checks for local Babel config files:
+            // https://github.com/GoogleChrome/workbox/issues/2111
+            babelrc: false,
+            configFile: false,
+            presets: [
+                [
+                    preset_env_1.default,
+                    {
+                        targets: {
+                            browsers: babelPresetEnvTargets,
+                        },
+                        loose: true,
+                    },
+                ],
+            ],
+        }),
+    ];
+    if (mode === 'production') {
+        plugins.push((0, plugin_terser_1.default)({
+            mangle: {
+                toplevel: true,
+                properties: {
+                    regex: /(^_|_$)/,
+                },
+            },
+        }));
+    }
+    const rollupConfig = {
+        plugins,
+        input: temporaryFile,
+    };
+    // Rollup will inline the runtime by default. If we don't want that, we need
+    // to add in some additional config.
+    if (!inlineWorkboxRuntime) {
+        // No lint for omt(), library has no types.
+        // eslint-disable-next-line  @typescript-eslint/no-unsafe-call
+        rollupConfig.plugins.unshift((0, rollup_plugin_off_main_thread_1.default)());
+    }
+    const bundle = await (0, rollup_1.rollup)(rollupConfig);
+    const outputOptions = {
+        sourcemap,
+        // Using an external Workbox runtime requires 'amd'.
+        format: inlineWorkboxRuntime ? 'es' : 'amd',
+    };
+    if (!inlineWorkboxRuntime) {
+        outputOptions.manualChunks = (id) => {
+            return id.includes('workbox') ? 'workbox' : undefined;
+        };
+        outputOptions.hashCharacters = 'hex';
+    }
+    const { output } = await bundle.generate(outputOptions);
+    const files = [];
+    for (const chunkOrAsset of output) {
+        if (chunkOrAsset.type === 'asset') {
+            if (!files.some((f) => f.name === chunkOrAsset.fileName)) {
+                files.push({
+                    name: chunkOrAsset.fileName,
+                    contents: chunkOrAsset.source,
+                });
+            }
+        }
+        else {
+            let code = chunkOrAsset.code;
+            if (chunkOrAsset.map) {
+                const sourceMapFile = chunkOrAsset.fileName + '.map';
+                code += `//# sourceMappingURL=${sourceMapFile}\n`;
+                if (!files.some((f) => f.name === sourceMapFile)) {
+                    files.push({
+                        name: sourceMapFile,
+                        contents: chunkOrAsset.map.toString(),
+                    });
+                }
+            }
+            if (!files.some((f) => f.name === chunkOrAsset.fileName)) {
+                files.push({
+                    name: chunkOrAsset.fileName,
+                    contents: code,
+                });
+            }
+        }
+    }
+    // Make sure that if there was a directory portion included in swDest, it's
+    // preprended to all of the generated files.
+    return files.map((file) => {
+        file.name = upath_1.default.format({
+            dir,
+            base: file.name,
+            ext: '',
+            name: '',
+            root: '',
+        });
+        return file;
+    });
+}
+exports.bundle = bundle;

tools/ui/node_modules/workbox-build/build/lib/cdn-utils.d.ts

@@ -0,0 +1,2 @@
+import { BuildType } from '../types';
+export declare function getModuleURL(moduleName: string, buildType: BuildType): string;

tools/ui/node_modules/workbox-build/build/lib/cdn-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+  Copyright 2021 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleURL = void 0;
+const assert_1 = require("assert");
+const errors_1 = require("./errors");
+const cdn = __importStar(require("../cdn-details.json"));
+function getVersionedURL() {
+    return `${getCDNPrefix()}/${cdn.latestVersion}`;
+}
+function getCDNPrefix() {
+    return `${cdn.origin}/${cdn.bucketName}/${cdn.releasesDir}`;
+}
+function getModuleURL(moduleName, buildType) {
+    (0, assert_1.ok)(moduleName, errors_1.errors['no-module-name']);
+    if (buildType) {
+        // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
+        const pkgJson = require(`${moduleName}/package.json`);
+        if (buildType === 'dev' && pkgJson.workbox && pkgJson.workbox.prodOnly) {
+            // This is not due to a public-facing exception, so just throw an Error(),
+            // without creating an entry in errors.js.
+            throw Error(`The 'dev' build of ${moduleName} is not available.`);
+        }
+        return `${getVersionedURL()}/${moduleName}.${buildType.slice(0, 4)}.js`;
+    }
+    return `${getVersionedURL()}/${moduleName}.js`;
+}
+exports.getModuleURL = getModuleURL;

tools/ui/node_modules/workbox-build/build/lib/copy-workbox-libraries.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This copies over a set of runtime libraries used by Workbox into a
+ * local directory, which should be deployed alongside your service worker file.
+ *
+ * As an alternative to deploying these local copies, you could instead use
+ * Workbox from its official CDN URL.
+ *
+ * This method is exposed for the benefit of developers using
+ * {@link workbox-build.injectManifest} who would
+ * prefer not to use the CDN copies of Workbox. Developers using
+ * {@link workbox-build.generateSW} don't need to
+ * explicitly call this method.
+ *
+ * @param {string} destDirectory The path to the parent directory under which
+ * the new directory of libraries will be created.
+ * @return {Promise<string>} The name of the newly created directory.
+ *
+ * @alias workbox-build.copyWorkboxLibraries
+ */
+export declare function copyWorkboxLibraries(destDirectory: string): Promise<string>;

tools/ui/node_modules/workbox-build/build/lib/copy-workbox-libraries.js

@@ -0,0 +1,69 @@
+"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.copyWorkboxLibraries = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const upath_1 = __importDefault(require("upath"));
+const errors_1 = require("./errors");
+// Used to filter the libraries to copy based on our package.json dependencies.
+const WORKBOX_PREFIX = 'workbox-';
+// The directory within each package containing the final bundles.
+const BUILD_DIR = 'build';
+/**
+ * This copies over a set of runtime libraries used by Workbox into a
+ * local directory, which should be deployed alongside your service worker file.
+ *
+ * As an alternative to deploying these local copies, you could instead use
+ * Workbox from its official CDN URL.
+ *
+ * This method is exposed for the benefit of developers using
+ * {@link workbox-build.injectManifest} who would
+ * prefer not to use the CDN copies of Workbox. Developers using
+ * {@link workbox-build.generateSW} don't need to
+ * explicitly call this method.
+ *
+ * @param {string} destDirectory The path to the parent directory under which
+ * the new directory of libraries will be created.
+ * @return {Promise<string>} The name of the newly created directory.
+ *
+ * @alias workbox-build.copyWorkboxLibraries
+ */
+async function copyWorkboxLibraries(destDirectory) {
+    // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
+    const thisPkg = require('../../package.json');
+    // Use the version string from workbox-build in the name of the parent
+    // directory. This should be safe, because lerna will bump workbox-build's
+    // pkg.version whenever one of the dependent libraries gets bumped, and we
+    // care about versioning the dependent libraries.
+    const workboxDirectoryName = `workbox-v${thisPkg.version ? thisPkg.version : ''}`;
+    const workboxDirectoryPath = upath_1.default.join(destDirectory, workboxDirectoryName);
+    await fs_extra_1.default.ensureDir(workboxDirectoryPath);
+    const copyPromises = [];
+    const librariesToCopy = Object.keys(thisPkg.dependencies || {}).filter((dependency) => dependency.startsWith(WORKBOX_PREFIX));
+    for (const library of librariesToCopy) {
+        // Get the path to the package on the user's filesystem by require-ing
+        // the package's `package.json` file via the node resolution algorithm.
+        const libraryPath = upath_1.default.dirname(require.resolve(`${library}/package.json`));
+        const buildPath = upath_1.default.join(libraryPath, BUILD_DIR);
+        // fse.copy() copies all the files in a directory, not the directory itself.
+        // See https://github.com/jprichardson/node-fs-extra/blob/master/docs/copy.md#copysrc-dest-options-callback
+        copyPromises.push(fs_extra_1.default.copy(buildPath, workboxDirectoryPath));
+    }
+    try {
+        await Promise.all(copyPromises);
+        return workboxDirectoryName;
+    }
+    catch (error) {
+        throw Error(`${errors_1.errors['unable-to-copy-workbox-libraries']} ${error instanceof Error ? error.toString() : ''}`);
+    }
+}
+exports.copyWorkboxLibraries = copyWorkboxLibraries;

tools/ui/node_modules/workbox-build/build/lib/errors.d.ts

@@ -0,0 +1,61 @@
+export declare const errors: {
+    'unable-to-get-rootdir': string;
+    'no-extension': string;
+    'invalid-file-manifest-name': string;
+    'unable-to-get-file-manifest-name': string;
+    'invalid-sw-dest': string;
+    'unable-to-get-sw-name': string;
+    'unable-to-get-save-config': string;
+    'unable-to-get-file-hash': string;
+    'unable-to-get-file-size': string;
+    'unable-to-glob-files': string;
+    'unable-to-make-manifest-directory': string;
+    'read-manifest-template-failure': string;
+    'populating-manifest-tmpl-failed': string;
+    'manifest-file-write-failure': string;
+    'unable-to-make-sw-directory': string;
+    'read-sw-template-failure': string;
+    'sw-write-failure': string;
+    'sw-write-failure-directory': string;
+    'unable-to-copy-workbox-libraries': string;
+    'invalid-generate-sw-input': string;
+    'invalid-glob-directory': string;
+    'invalid-dont-cache-bust': string;
+    'invalid-exclude-files': string;
+    'invalid-get-manifest-entries-input': string;
+    'invalid-manifest-path': string;
+    'invalid-manifest-entries': string;
+    'invalid-manifest-format': string;
+    'invalid-static-file-globs': string;
+    'invalid-templated-urls': string;
+    'templated-url-matches-glob': string;
+    'invalid-glob-ignores': string;
+    'manifest-entry-bad-url': string;
+    'modify-url-prefix-bad-prefixes': string;
+    'invalid-inject-manifest-arg': string;
+    'injection-point-not-found': string;
+    'multiple-injection-points': string;
+    'populating-sw-tmpl-failed': string;
+    'useless-glob-pattern': string;
+    'bad-template-urls-asset': string;
+    'invalid-runtime-caching': string;
+    'static-file-globs-deprecated': string;
+    'dynamic-url-deprecated': string;
+    'urlPattern-is-required': string;
+    'handler-is-required': string;
+    'invalid-generate-file-manifest-arg': string;
+    'invalid-sw-src': string;
+    'same-src-and-dest': string;
+    'only-regexp-routes-supported': string;
+    'bad-runtime-caching-config': string;
+    'invalid-network-timeout-seconds': string;
+    'no-module-name': string;
+    'bad-manifest-transforms-return-value': string;
+    'string-entry-warning': string;
+    'no-manifest-entries-or-runtime-caching': string;
+    'cant-find-sourcemap': string;
+    'nav-preload-runtime-caching': string;
+    'cache-name-required': string;
+    'manifest-transforms': string;
+    'invalid-handler-string': string;
+};

tools/ui/node_modules/workbox-build/build/lib/errors.js

@@ -0,0 +1,125 @@
+"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.errors = void 0;
+const common_tags_1 = require("common-tags");
+exports.errors = {
+    'unable-to-get-rootdir': `Unable to get the root directory of your web app.`,
+    'no-extension': (0, common_tags_1.oneLine) `Unable to detect a usable extension for a file in your web
+    app directory.`,
+    'invalid-file-manifest-name': (0, common_tags_1.oneLine) `The File Manifest Name must have at least one
+    character.`,
+    'unable-to-get-file-manifest-name': 'Unable to get a file manifest name.',
+    'invalid-sw-dest': `The 'swDest' value must be a valid path.`,
+    'unable-to-get-sw-name': 'Unable to get a service worker file name.',
+    'unable-to-get-save-config': (0, common_tags_1.oneLine) `An error occurred when asking to save details
+    in a config file.`,
+    'unable-to-get-file-hash': (0, common_tags_1.oneLine) `An error occurred when attempting to create a
+    file hash.`,
+    'unable-to-get-file-size': (0, common_tags_1.oneLine) `An error occurred when attempting to get a file
+    size.`,
+    'unable-to-glob-files': 'An error occurred when globbing for files.',
+    'unable-to-make-manifest-directory': (0, common_tags_1.oneLine) `Unable to make output directory for
+    file manifest.`,
+    'read-manifest-template-failure': 'Unable to read template for file manifest',
+    'populating-manifest-tmpl-failed': (0, common_tags_1.oneLine) `An error occurred when populating the
+    file manifest template.`,
+    'manifest-file-write-failure': 'Unable to write the file manifest.',
+    'unable-to-make-sw-directory': (0, common_tags_1.oneLine) `Unable to make the directories to output
+    the service worker path.`,
+    'read-sw-template-failure': (0, common_tags_1.oneLine) `Unable to read the service worker template
+    file.`,
+    'sw-write-failure': 'Unable to write the service worker file.',
+    'sw-write-failure-directory': (0, common_tags_1.oneLine) `Unable to write the service worker file;
+    'swDest' should be a full path to the file, not a path to a directory.`,
+    'unable-to-copy-workbox-libraries': (0, common_tags_1.oneLine) `One or more of the Workbox libraries
+    could not be copied over to the destination directory: `,
+    'invalid-generate-sw-input': (0, common_tags_1.oneLine) `The input to generateSW() must be an object.`,
+    'invalid-glob-directory': (0, common_tags_1.oneLine) `The supplied globDirectory must be a path as a
+    string.`,
+    'invalid-dont-cache-bust': (0, common_tags_1.oneLine) `The supplied 'dontCacheBustURLsMatching'
+    parameter must be a RegExp.`,
+    'invalid-exclude-files': 'The excluded files should be an array of strings.',
+    'invalid-get-manifest-entries-input': (0, common_tags_1.oneLine) `The input to
+    'getFileManifestEntries()' must be an object.`,
+    'invalid-manifest-path': (0, common_tags_1.oneLine) `The supplied manifest path is not a string with
+    at least one character.`,
+    'invalid-manifest-entries': (0, common_tags_1.oneLine) `The manifest entries must be an array of
+    strings or JavaScript objects containing a url parameter.`,
+    'invalid-manifest-format': (0, common_tags_1.oneLine) `The value of the 'format' option passed to
+    generateFileManifest() must be either 'iife' (the default) or 'es'.`,
+    'invalid-static-file-globs': (0, common_tags_1.oneLine) `The 'globPatterns' value must be an array
+    of strings.`,
+    'invalid-templated-urls': (0, common_tags_1.oneLine) `The 'templatedURLs' value should be an object
+    that maps URLs to either a string, or to an array of glob patterns.`,
+    'templated-url-matches-glob': (0, common_tags_1.oneLine) `One of the 'templatedURLs' URLs is already
+    being tracked via 'globPatterns': `,
+    'invalid-glob-ignores': (0, common_tags_1.oneLine) `The 'globIgnores' parameter must be an array of
+    glob pattern strings.`,
+    'manifest-entry-bad-url': (0, common_tags_1.oneLine) `The generated manifest contains an entry without
+    a URL string. This is likely an error with workbox-build.`,
+    'modify-url-prefix-bad-prefixes': (0, common_tags_1.oneLine) `The 'modifyURLPrefix' parameter must be
+    an object with string key value pairs.`,
+    'invalid-inject-manifest-arg': (0, common_tags_1.oneLine) `The input to 'injectManifest()' must be an
+    object.`,
+    'injection-point-not-found': (0, common_tags_1.oneLine) `Unable to find a place to inject the manifest.
+    Please ensure that your service worker file contains the following: `,
+    'multiple-injection-points': (0, common_tags_1.oneLine) `Please ensure that your 'swSrc' file contains
+    only one match for the following: `,
+    'populating-sw-tmpl-failed': (0, common_tags_1.oneLine) `Unable to generate service worker from
+    template.`,
+    'useless-glob-pattern': (0, common_tags_1.oneLine) `One of the glob patterns doesn't match any files.
+    Please remove or fix the following: `,
+    'bad-template-urls-asset': (0, common_tags_1.oneLine) `There was an issue using one of the provided
+    'templatedURLs'.`,
+    'invalid-runtime-caching': (0, common_tags_1.oneLine) `The 'runtimeCaching' parameter must an an
+    array of objects with at least a 'urlPattern' and 'handler'.`,
+    'static-file-globs-deprecated': (0, common_tags_1.oneLine) `'staticFileGlobs' is deprecated.
+    Please use 'globPatterns' instead.`,
+    'dynamic-url-deprecated': (0, common_tags_1.oneLine) `'dynamicURLToDependencies' is deprecated.
+    Please use 'templatedURLs' instead.`,
+    'urlPattern-is-required': (0, common_tags_1.oneLine) `The 'urlPattern' option is required when using
+    'runtimeCaching'.`,
+    'handler-is-required': (0, common_tags_1.oneLine) `The 'handler' option is required when using
+    runtimeCaching.`,
+    'invalid-generate-file-manifest-arg': (0, common_tags_1.oneLine) `The input to generateFileManifest()
+    must be an Object.`,
+    'invalid-sw-src': `The 'swSrc' file can't be read.`,
+    'same-src-and-dest': (0, common_tags_1.oneLine) `Unable to find a place to inject the manifest. This is
+    likely because swSrc and swDest are configured to the same file.
+    Please ensure that your swSrc file contains the following:`,
+    'only-regexp-routes-supported': (0, common_tags_1.oneLine) `Please use a regular expression object as
+    the urlPattern parameter. (Express-style routes are not currently
+    supported.)`,
+    'bad-runtime-caching-config': (0, common_tags_1.oneLine) `An unknown configuration option was used
+    with runtimeCaching: `,
+    'invalid-network-timeout-seconds': (0, common_tags_1.oneLine) `When using networkTimeoutSeconds, you
+    must set the handler to 'NetworkFirst'.`,
+    'no-module-name': (0, common_tags_1.oneLine) `You must provide a moduleName parameter when calling
+    getModuleURL().`,
+    'bad-manifest-transforms-return-value': (0, common_tags_1.oneLine) `The return value from a
+    manifestTransform should be an object with 'manifest' and optionally
+    'warnings' properties.`,
+    'string-entry-warning': (0, common_tags_1.oneLine) `Some items were passed to additionalManifestEntries
+    without revisioning info. This is generally NOT safe. Learn more at
+    https://bit.ly/wb-precache.`,
+    'no-manifest-entries-or-runtime-caching': (0, common_tags_1.oneLine) `Couldn't find configuration for
+    either precaching or runtime caching. Please ensure that the various glob
+    options are set to match one or more files, and/or configure the
+    runtimeCaching option.`,
+    'cant-find-sourcemap': (0, common_tags_1.oneLine) `The swSrc file refers to a sourcemap that can't be
+    opened:`,
+    'nav-preload-runtime-caching': (0, common_tags_1.oneLine) `When using navigationPreload, you must also
+    configure a runtimeCaching route that will use the preloaded response.`,
+    'cache-name-required': (0, common_tags_1.oneLine) `When using cache expiration, you must also
+    configure a custom cacheName.`,
+    'manifest-transforms': (0, common_tags_1.oneLine) `When using manifestTransforms, you must provide
+    an array of functions.`,
+    'invalid-handler-string': (0, common_tags_1.oneLine) `The handler name provided is not valid: `,
+};

tools/ui/node_modules/workbox-build/build/lib/escape-regexp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(str: string): string;

tools/ui/node_modules/workbox-build/build/lib/escape-regexp.js

@@ -0,0 +1,15 @@
+"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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = void 0;
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+exports.escapeRegExp = escapeRegExp;

tools/ui/node_modules/workbox-build/build/lib/get-composite-details.d.ts

@@ -0,0 +1,2 @@
+import { FileDetails } from '../types';
+export declare function getCompositeDetails(compositeURL: string, dependencyDetails: Array<FileDetails>): FileDetails;

tools/ui/node_modules/workbox-build/build/lib/get-composite-details.js

@@ -0,0 +1,31 @@
+"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.getCompositeDetails = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function getCompositeDetails(compositeURL, dependencyDetails) {
+    let totalSize = 0;
+    let compositeHash = '';
+    for (const fileDetails of dependencyDetails) {
+        totalSize += fileDetails.size;
+        compositeHash += fileDetails.hash;
+    }
+    const md5 = crypto_1.default.createHash('md5');
+    md5.update(compositeHash);
+    const hashOfHashes = md5.digest('hex');
+    return {
+        file: compositeURL,
+        hash: hashOfHashes,
+        size: totalSize,
+    };
+}
+exports.getCompositeDetails = getCompositeDetails;

tools/ui/node_modules/workbox-build/build/lib/get-file-details.d.ts

@@ -0,0 +1,14 @@
+import { GlobPartial } from '../types';
+interface FileDetails {
+    file: string;
+    hash: string;
+    size: number;
+}
+export declare function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern, }: Omit<GlobPartial, 'globDirectory' | 'globPatterns' | 'templatedURLs'> & {
+    globDirectory: string;
+    globPattern: string;
+}): {
+    globbedFileDetails: Array<FileDetails>;
+    warning: string;
+};
+export {};

tools/ui/node_modules/workbox-build/build/lib/get-file-details.js

@@ -0,0 +1,54 @@
+"use strict";
+/*
+  Copyright 2021 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.getFileDetails = void 0;
+const glob_1 = require("glob");
+const upath_1 = __importDefault(require("upath"));
+const errors_1 = require("./errors");
+const get_file_size_1 = require("./get-file-size");
+const get_file_hash_1 = require("./get-file-hash");
+function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern, }) {
+    let globbedFiles;
+    let warning = '';
+    try {
+        globbedFiles = (0, glob_1.globSync)(globPattern, {
+            cwd: globDirectory,
+            follow: globFollow,
+            ignore: globIgnores,
+        });
+    }
+    catch (err) {
+        throw new Error(errors_1.errors['unable-to-glob-files'] +
+            ` '${err instanceof Error && err.message ? err.message : ''}'`);
+    }
+    if (globbedFiles.length === 0) {
+        warning =
+            errors_1.errors['useless-glob-pattern'] +
+                ' ' +
+                JSON.stringify({ globDirectory, globPattern, globIgnores }, null, 2);
+    }
+    const globbedFileDetails = [];
+    for (const file of globbedFiles) {
+        const fullPath = upath_1.default.join(globDirectory, file);
+        const fileSize = (0, get_file_size_1.getFileSize)(fullPath);
+        if (fileSize !== null) {
+            const fileHash = (0, get_file_hash_1.getFileHash)(fullPath);
+            globbedFileDetails.push({
+                file: `${upath_1.default.relative(globDirectory, fullPath)}`,
+                hash: fileHash,
+                size: fileSize,
+            });
+        }
+    }
+    return { globbedFileDetails, warning };
+}
+exports.getFileDetails = getFileDetails;

tools/ui/node_modules/workbox-build/build/lib/get-file-hash.d.ts

@@ -0,0 +1 @@
+export declare function getFileHash(file: string): string;

tools/ui/node_modules/workbox-build/build/lib/get-file-hash.js

@@ -0,0 +1,27 @@
+"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.getFileHash = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const get_string_hash_1 = require("./get-string-hash");
+const errors_1 = require("./errors");
+function getFileHash(file) {
+    try {
+        const buffer = fs_extra_1.default.readFileSync(file);
+        return (0, get_string_hash_1.getStringHash)(buffer);
+    }
+    catch (err) {
+        throw new Error(errors_1.errors['unable-to-get-file-hash'] +
+            ` '${err instanceof Error && err.message ? err.message : ''}'`);
+    }
+}
+exports.getFileHash = getFileHash;

tools/ui/node_modules/workbox-build/build/lib/get-file-manifest-entries.d.ts

@@ -0,0 +1,2 @@
+import { GetManifestResult, GetManifestOptions } from '../types';
+export declare function getFileManifestEntries({ additionalManifestEntries, dontCacheBustURLsMatching, globDirectory, globFollow, globIgnores, globPatterns, manifestTransforms, maximumFileSizeToCacheInBytes, modifyURLPrefix, templatedURLs, }: GetManifestOptions): Promise<GetManifestResult>;

tools/ui/node_modules/workbox-build/build/lib/get-file-manifest-entries.js

@@ -0,0 +1,96 @@
+"use strict";
+/*
+  Copyright 2021 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.getFileManifestEntries = void 0;
+const assert_1 = __importDefault(require("assert"));
+const errors_1 = require("./errors");
+const get_composite_details_1 = require("./get-composite-details");
+const get_file_details_1 = require("./get-file-details");
+const get_string_details_1 = require("./get-string-details");
+const transform_manifest_1 = require("./transform-manifest");
+async function getFileManifestEntries({ additionalManifestEntries, dontCacheBustURLsMatching, globDirectory, globFollow, globIgnores, globPatterns = [], manifestTransforms, maximumFileSizeToCacheInBytes, modifyURLPrefix, templatedURLs, }) {
+    const warnings = [];
+    const allFileDetails = new Map();
+    try {
+        for (const globPattern of globPatterns) {
+            const { globbedFileDetails, warning } = (0, get_file_details_1.getFileDetails)({
+                globDirectory,
+                globFollow,
+                globIgnores,
+                globPattern,
+            });
+            if (warning) {
+                warnings.push(warning);
+            }
+            for (const details of globbedFileDetails) {
+                if (details && !allFileDetails.has(details.file)) {
+                    allFileDetails.set(details.file, details);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If there's an exception thrown while globbing, then report
+        // it back as a warning, and don't consider it fatal.
+        if (error instanceof Error && error.message) {
+            warnings.push(error.message);
+        }
+    }
+    if (templatedURLs) {
+        for (const url of Object.keys(templatedURLs)) {
+            (0, assert_1.default)(!allFileDetails.has(url), errors_1.errors['templated-url-matches-glob']);
+            const dependencies = templatedURLs[url];
+            if (Array.isArray(dependencies)) {
+                const details = dependencies.reduce((previous, globPattern) => {
+                    try {
+                        const { globbedFileDetails, warning } = (0, get_file_details_1.getFileDetails)({
+                            globDirectory,
+                            globFollow,
+                            globIgnores,
+                            globPattern,
+                        });
+                        if (warning) {
+                            warnings.push(warning);
+                        }
+                        return previous.concat(globbedFileDetails);
+                    }
+                    catch (error) {
+                        const debugObj = {};
+                        debugObj[url] = dependencies;
+                        throw new Error(`${errors_1.errors['bad-template-urls-asset']} ` +
+                            `'${globPattern}' from '${JSON.stringify(debugObj)}':\n` +
+                            `${error instanceof Error ? error.toString() : ''}`);
+                    }
+                }, []);
+                if (details.length === 0) {
+                    throw new Error(`${errors_1.errors['bad-template-urls-asset']} The glob ` +
+                        `pattern '${dependencies.toString()}' did not match anything.`);
+                }
+                allFileDetails.set(url, (0, get_composite_details_1.getCompositeDetails)(url, details));
+            }
+            else if (typeof dependencies === 'string') {
+                allFileDetails.set(url, (0, get_string_details_1.getStringDetails)(url, dependencies));
+            }
+        }
+    }
+    const transformedManifest = await (0, transform_manifest_1.transformManifest)({
+        additionalManifestEntries,
+        dontCacheBustURLsMatching,
+        manifestTransforms,
+        maximumFileSizeToCacheInBytes,
+        modifyURLPrefix,
+        fileDetails: Array.from(allFileDetails.values()),
+    });
+    transformedManifest.warnings.push(...warnings);
+    return transformedManifest;
+}
+exports.getFileManifestEntries = getFileManifestEntries;

tools/ui/node_modules/workbox-build/build/lib/get-file-size.d.ts

@@ -0,0 +1 @@
+export declare function getFileSize(file: string): number | null;

tools/ui/node_modules/workbox-build/build/lib/get-file-size.js

@@ -0,0 +1,29 @@
+"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.getFileSize = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const errors_1 = require("./errors");
+function getFileSize(file) {
+    try {
+        const stat = fs_extra_1.default.statSync(file);
+        if (!stat.isFile()) {
+            return null;
+        }
+        return stat.size;
+    }
+    catch (err) {
+        throw new Error(errors_1.errors['unable-to-get-file-size'] +
+            ` '${err instanceof Error && err.message ? err.message : ''}'`);
+    }
+}
+exports.getFileSize = getFileSize;

tools/ui/node_modules/workbox-build/build/lib/get-source-map-url.d.ts

@@ -0,0 +1 @@
+export declare function getSourceMapURL(srcContents: string): string | null;

tools/ui/node_modules/workbox-build/build/lib/get-source-map-url.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+  Copyright 2022 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.getSourceMapURL = void 0;
+// Adapted from https://github.com/lydell/source-map-url/blob/master/source-map-url.js
+// See https://github.com/GoogleChrome/workbox/issues/3019
+const innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/;
+const regex = RegExp('(?:' +
+    '/\\*' +
+    '(?:\\s*\r?\n(?://)?)?' +
+    '(?:' +
+    innerRegex.source +
+    ')' +
+    '\\s*' +
+    '\\*/' +
+    '|' +
+    '//(?:' +
+    innerRegex.source +
+    ')' +
+    ')' +
+    '\\s*');
+function getSourceMapURL(srcContents) {
+    const match = srcContents.match(regex);
+    return match ? match[1] || match[2] || '' : null;
+}
+exports.getSourceMapURL = getSourceMapURL;

tools/ui/node_modules/workbox-build/build/lib/get-string-details.d.ts

@@ -0,0 +1,2 @@
+import { FileDetails } from '../types';
+export declare function getStringDetails(url: string, str: string): FileDetails;

tools/ui/node_modules/workbox-build/build/lib/get-string-details.js

@@ -0,0 +1,19 @@
+"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.getStringDetails = void 0;
+const get_string_hash_1 = require("./get-string-hash");
+function getStringDetails(url, str) {
+    return {
+        file: url,
+        hash: (0, get_string_hash_1.getStringHash)(str),
+        size: str.length,
+    };
+}
+exports.getStringDetails = getStringDetails;

tools/ui/node_modules/workbox-build/build/lib/get-string-hash.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import crypto from 'crypto';
+export declare function getStringHash(input: crypto.BinaryLike): string;

tools/ui/node_modules/workbox-build/build/lib/get-string-hash.js

@@ -0,0 +1,20 @@
+"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.getStringHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function getStringHash(input) {
+    const md5 = crypto_1.default.createHash('md5');
+    md5.update(input);
+    return md5.digest('hex');
+}
+exports.getStringHash = getStringHash;

tools/ui/node_modules/workbox-build/build/lib/maximum-size-transform.d.ts

@@ -0,0 +1,2 @@
+import { ManifestTransform } from '../types';
+export declare function maximumSizeTransform(maximumFileSizeToCacheInBytes: number): ManifestTransform;

tools/ui/node_modules/workbox-build/build/lib/maximum-size-transform.js

@@ -0,0 +1,30 @@
+"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.maximumSizeTransform = void 0;
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
+    return (originalManifest) => {
+        const warnings = [];
+        const manifest = originalManifest.filter((entry) => {
+            if (entry.size <= maximumFileSizeToCacheInBytes) {
+                return true;
+            }
+            warnings.push(`${entry.url} is ${(0, pretty_bytes_1.default)(entry.size)}, and won't ` +
+                `be precached. Configure maximumFileSizeToCacheInBytes to change ` +
+                `this limit.`);
+            return false;
+        });
+        return { manifest, warnings };
+    };
+}
+exports.maximumSizeTransform = maximumSizeTransform;

tools/ui/node_modules/workbox-build/build/lib/modify-url-prefix-transform.d.ts

@@ -0,0 +1,4 @@
+import { ManifestTransform } from '../types';
+export declare function modifyURLPrefixTransform(modifyURLPrefix: {
+    [key: string]: string;
+}): ManifestTransform;

tools/ui/node_modules/workbox-build/build/lib/modify-url-prefix-transform.js

@@ -0,0 +1,51 @@
+"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.modifyURLPrefixTransform = void 0;
+const errors_1 = require("./errors");
+const escape_regexp_1 = require("./escape-regexp");
+function modifyURLPrefixTransform(modifyURLPrefix) {
+    if (!modifyURLPrefix ||
+        typeof modifyURLPrefix !== 'object' ||
+        Array.isArray(modifyURLPrefix)) {
+        throw new Error(errors_1.errors['modify-url-prefix-bad-prefixes']);
+    }
+    // If there are no entries in modifyURLPrefix, just return an identity
+    // function as a shortcut.
+    if (Object.keys(modifyURLPrefix).length === 0) {
+        return (manifest) => {
+            return { manifest };
+        };
+    }
+    for (const key of Object.keys(modifyURLPrefix)) {
+        if (typeof modifyURLPrefix[key] !== 'string') {
+            throw new Error(errors_1.errors['modify-url-prefix-bad-prefixes']);
+        }
+    }
+    // Escape the user input so it's safe to use in a regex.
+    const safeModifyURLPrefixes = Object.keys(modifyURLPrefix).map(escape_regexp_1.escapeRegExp);
+    // Join all the `modifyURLPrefix` keys so a single regex can be used.
+    const prefixMatchesStrings = safeModifyURLPrefixes.join('|');
+    // Add `^` to the front the prefix matches so it only matches the start of
+    // a string.
+    const modifyRegex = new RegExp(`^(${prefixMatchesStrings})`);
+    return (originalManifest) => {
+        const manifest = originalManifest.map((entry) => {
+            if (typeof entry.url !== 'string') {
+                throw new Error(errors_1.errors['manifest-entry-bad-url']);
+            }
+            entry.url = entry.url.replace(modifyRegex, (match) => {
+                return modifyURLPrefix[match];
+            });
+            return entry;
+        });
+        return { manifest };
+    };
+}
+exports.modifyURLPrefixTransform = modifyURLPrefixTransform;

tools/ui/node_modules/workbox-build/build/lib/module-registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Class for keeping track of which Workbox modules are used by the generated
+ * service worker script.
+ *
+ * @private
+ */
+export declare class ModuleRegistry {
+    private readonly _modulesUsed;
+    /**
+     * @private
+     */
+    constructor();
+    /**
+     * @return {Array<string>} A list of all of the import statements that are
+     * needed for the modules being used.
+     * @private
+     */
+    getImportStatements(): Array<string>;
+    /**
+     * @param {string} pkg The workbox package that the module belongs to.
+     * @param {string} moduleName The name of the module to import.
+     * @return {string} The local variable name that corresponds to that module.
+     * @private
+     */
+    getLocalName(pkg: string, moduleName: string): string;
+    /**
+     * @param {string} pkg The workbox package that the module belongs to.
+     * @param {string} moduleName The name of the module to import.
+     * @return {string} The local variable name that corresponds to that module.
+     * @private
+     */
+    use(pkg: string, moduleName: string): string;
+}

tools/ui/node_modules/workbox-build/build/lib/module-registry.js

@@ -0,0 +1,70 @@
+"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.ModuleRegistry = void 0;
+const common_tags_1 = require("common-tags");
+const upath_1 = __importDefault(require("upath"));
+/**
+ * Class for keeping track of which Workbox modules are used by the generated
+ * service worker script.
+ *
+ * @private
+ */
+class ModuleRegistry {
+    /**
+     * @private
+     */
+    constructor() {
+        this._modulesUsed = new Map();
+    }
+    /**
+     * @return {Array<string>} A list of all of the import statements that are
+     * needed for the modules being used.
+     * @private
+     */
+    getImportStatements() {
+        const workboxModuleImports = [];
+        for (const [localName, { moduleName, pkg }] of this._modulesUsed) {
+            // By default require.resolve returns the resolved path of the 'main'
+            // field, which might be deeper than the package root. To work around
+            // this, we can find the package's root by resolving its package.json and
+            // strip the '/package.json' from the resolved path.
+            const pkgJsonPath = require.resolve(`${pkg}/package.json`);
+            const pkgRoot = upath_1.default.dirname(pkgJsonPath);
+            const importStatement = (0, common_tags_1.oneLine) `import {${moduleName} as ${localName}} from
+        '${pkgRoot}/${moduleName}.mjs';`;
+            workboxModuleImports.push(importStatement);
+        }
+        return workboxModuleImports;
+    }
+    /**
+     * @param {string} pkg The workbox package that the module belongs to.
+     * @param {string} moduleName The name of the module to import.
+     * @return {string} The local variable name that corresponds to that module.
+     * @private
+     */
+    getLocalName(pkg, moduleName) {
+        return `${pkg.replace(/-/g, '_')}_${moduleName}`;
+    }
+    /**
+     * @param {string} pkg The workbox package that the module belongs to.
+     * @param {string} moduleName The name of the module to import.
+     * @return {string} The local variable name that corresponds to that module.
+     * @private
+     */
+    use(pkg, moduleName) {
+        const localName = this.getLocalName(pkg, moduleName);
+        this._modulesUsed.set(localName, { moduleName, pkg });
+        return localName;
+    }
+}
+exports.ModuleRegistry = ModuleRegistry;

tools/ui/node_modules/workbox-build/build/lib/no-revision-for-urls-matching-transform.d.ts

@@ -0,0 +1,2 @@
+import { ManifestTransform } from '../types';
+export declare function noRevisionForURLsMatchingTransform(regexp: RegExp): ManifestTransform;

tools/ui/node_modules/workbox-build/build/lib/no-revision-for-urls-matching-transform.js

@@ -0,0 +1,29 @@
+"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.noRevisionForURLsMatchingTransform = void 0;
+const errors_1 = require("./errors");
+function noRevisionForURLsMatchingTransform(regexp) {
+    if (!(regexp instanceof RegExp)) {
+        throw new Error(errors_1.errors['invalid-dont-cache-bust']);
+    }
+    return (originalManifest) => {
+        const manifest = originalManifest.map((entry) => {
+            if (typeof entry.url !== 'string') {
+                throw new Error(errors_1.errors['manifest-entry-bad-url']);
+            }
+            if (entry.url.match(regexp)) {
+                entry.revision = null;
+            }
+            return entry;
+        });
+        return { manifest };
+    };
+}
+exports.noRevisionForURLsMatchingTransform = noRevisionForURLsMatchingTransform;

tools/ui/node_modules/workbox-build/build/lib/populate-sw-template.d.ts

@@ -0,0 +1,4 @@
+import { GeneratePartial, ManifestEntry } from '../types';
+export declare function populateSWTemplate({ cacheId, cleanupOutdatedCaches, clientsClaim, directoryIndex, disableDevLogs, ignoreURLParametersMatching, importScripts, manifestEntries, navigateFallback, navigateFallbackDenylist, navigateFallbackAllowlist, navigationPreload, offlineGoogleAnalytics, runtimeCaching, skipWaiting, }: GeneratePartial & {
+    manifestEntries?: Array<ManifestEntry>;
+}): string;

tools/ui/node_modules/workbox-build/build/lib/populate-sw-template.js

@@ -0,0 +1,80 @@
+"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.populateSWTemplate = void 0;
+const eta_1 = require("eta");
+const errors_1 = require("./errors");
+const module_registry_1 = require("./module-registry");
+const runtime_caching_converter_1 = require("./runtime-caching-converter");
+const stringify_without_comments_1 = require("./stringify-without-comments");
+const sw_template_1 = require("../templates/sw-template");
+const eta = new eta_1.Eta({
+    useWith: true,
+    autoEscape: false,
+});
+function populateSWTemplate({ cacheId, cleanupOutdatedCaches, clientsClaim, directoryIndex, disableDevLogs, ignoreURLParametersMatching, importScripts, manifestEntries = [], navigateFallback, navigateFallbackDenylist, navigateFallbackAllowlist, navigationPreload, offlineGoogleAnalytics, runtimeCaching = [], skipWaiting, }) {
+    // There needs to be at least something to precache, or else runtime caching.
+    if (!((manifestEntries === null || manifestEntries === void 0 ? void 0 : manifestEntries.length) > 0 || runtimeCaching.length > 0)) {
+        throw new Error(errors_1.errors['no-manifest-entries-or-runtime-caching']);
+    }
+    // These are all options that can be passed to the precacheAndRoute() method.
+    const precacheOptions = {
+        directoryIndex,
+        // An array of RegExp objects can't be serialized by JSON.stringify()'s
+        // default behavior, so if it's given, convert it manually.
+        ignoreURLParametersMatching: ignoreURLParametersMatching
+            ? []
+            : undefined,
+    };
+    let precacheOptionsString = JSON.stringify(precacheOptions, null, 2);
+    if (ignoreURLParametersMatching) {
+        precacheOptionsString = precacheOptionsString.replace(`"ignoreURLParametersMatching": []`, `"ignoreURLParametersMatching": [` +
+            `${ignoreURLParametersMatching.join(', ')}]`);
+    }
+    let offlineAnalyticsConfigString = undefined;
+    if (offlineGoogleAnalytics) {
+        // If offlineGoogleAnalytics is a truthy value, we need to convert it to the
+        // format expected by the template.
+        offlineAnalyticsConfigString =
+            offlineGoogleAnalytics === true
+                ? // If it's the literal value true, then use an empty config string.
+                    '{}'
+                : // Otherwise, convert the config object into a more complex string, taking
+                    // into account the fact that functions might need to be stringified.
+                    (0, stringify_without_comments_1.stringifyWithoutComments)(offlineGoogleAnalytics);
+    }
+    const moduleRegistry = new module_registry_1.ModuleRegistry();
+    try {
+        const populatedTemplate = eta.renderString(sw_template_1.swTemplate, {
+            cacheId,
+            cleanupOutdatedCaches,
+            clientsClaim,
+            disableDevLogs,
+            importScripts,
+            manifestEntries,
+            navigateFallback,
+            navigateFallbackDenylist,
+            navigateFallbackAllowlist,
+            navigationPreload,
+            offlineAnalyticsConfigString,
+            precacheOptionsString,
+            runtimeCaching: (0, runtime_caching_converter_1.runtimeCachingConverter)(moduleRegistry, runtimeCaching),
+            skipWaiting,
+            use: moduleRegistry.use.bind(moduleRegistry),
+        });
+        const workboxImportStatements = moduleRegistry.getImportStatements();
+        // We need the import statements for all of the Workbox runtime modules
+        // prepended, so that the correct bundle can be created.
+        return workboxImportStatements.join('\n') + populatedTemplate;
+    }
+    catch (error) {
+        throw new Error(`${errors_1.errors['populating-sw-tmpl-failed']} '${error instanceof Error && error.message ? error.message : ''}'`);
+    }
+}
+exports.populateSWTemplate = populateSWTemplate;

tools/ui/node_modules/workbox-build/build/lib/rebase-path.d.ts

@@ -0,0 +1,4 @@
+export declare function rebasePath({ baseDirectory, file, }: {
+    baseDirectory: string;
+    file: string;
+}): string;

tools/ui/node_modules/workbox-build/build/lib/rebase-path.js

@@ -0,0 +1,24 @@
+"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.rebasePath = void 0;
+const upath_1 = __importDefault(require("upath"));
+function rebasePath({ baseDirectory, file, }) {
+    // The initial path is relative to the current directory, so make it absolute.
+    const absolutePath = upath_1.default.resolve(file);
+    // Convert the absolute path so that it's relative to the baseDirectory.
+    const relativePath = upath_1.default.relative(baseDirectory, absolutePath);
+    // Remove any leading ./ as it won't work in a glob pattern.
+    const normalizedPath = upath_1.default.normalize(relativePath);
+    return normalizedPath;
+}
+exports.rebasePath = rebasePath;

tools/ui/node_modules/workbox-build/build/lib/replace-and-update-source-map.d.ts

@@ -0,0 +1,30 @@
+import { RawSourceMap } from 'source-map';
+/**
+ * Adapted from https://github.com/nsams/sourcemap-aware-replace, with modern
+ * JavaScript updates, along with additional properties copied from originalMap.
+ *
+ * @param {Object} options
+ * @param {string} options.jsFilename The name for the file whose contents
+ * correspond to originalSource.
+ * @param {Object} options.originalMap The sourcemap for originalSource,
+ * prior to any replacements.
+ * @param {string} options.originalSource The source code, prior to any
+ * replacements.
+ * @param {string} options.replaceString A string to swap in for searchString.
+ * @param {string} options.searchString A string in originalSource to replace.
+ * Only the first occurrence will be replaced.
+ * @return {{source: string, map: string}} An object containing both
+ * originalSource with the replacement applied, and the modified originalMap.
+ *
+ * @private
+ */
+export declare function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString, }: {
+    jsFilename: string;
+    originalMap: RawSourceMap;
+    originalSource: string;
+    replaceString: string;
+    searchString: string;
+}): Promise<{
+    map: string;
+    source: string;
+}>;

tools/ui/node_modules/workbox-build/build/lib/replace-and-update-source-map.js

@@ -0,0 +1,98 @@
+"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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAndUpdateSourceMap = void 0;
+const source_map_1 = require("source-map");
+/**
+ * Adapted from https://github.com/nsams/sourcemap-aware-replace, with modern
+ * JavaScript updates, along with additional properties copied from originalMap.
+ *
+ * @param {Object} options
+ * @param {string} options.jsFilename The name for the file whose contents
+ * correspond to originalSource.
+ * @param {Object} options.originalMap The sourcemap for originalSource,
+ * prior to any replacements.
+ * @param {string} options.originalSource The source code, prior to any
+ * replacements.
+ * @param {string} options.replaceString A string to swap in for searchString.
+ * @param {string} options.searchString A string in originalSource to replace.
+ * Only the first occurrence will be replaced.
+ * @return {{source: string, map: string}} An object containing both
+ * originalSource with the replacement applied, and the modified originalMap.
+ *
+ * @private
+ */
+async function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString, }) {
+    const generator = new source_map_1.SourceMapGenerator({
+        file: jsFilename,
+    });
+    const consumer = await new source_map_1.SourceMapConsumer(originalMap);
+    let pos;
+    let src = originalSource;
+    const replacements = [];
+    let lineNum = 0;
+    let filePos = 0;
+    const lines = src.split('\n');
+    for (let line of lines) {
+        lineNum++;
+        let searchPos = 0;
+        while ((pos = line.indexOf(searchString, searchPos)) !== -1) {
+            src =
+                src.substring(0, filePos + pos) +
+                    replaceString +
+                    src.substring(filePos + pos + searchString.length);
+            line =
+                line.substring(0, pos) +
+                    replaceString +
+                    line.substring(pos + searchString.length);
+            replacements.push({ line: lineNum, column: pos });
+            searchPos = pos + replaceString.length;
+        }
+        filePos += line.length + 1;
+    }
+    replacements.reverse();
+    consumer.eachMapping((mapping) => {
+        for (const replacement of replacements) {
+            if (replacement.line === mapping.generatedLine &&
+                mapping.generatedColumn > replacement.column) {
+                const offset = searchString.length - replaceString.length;
+                mapping.generatedColumn -= offset;
+            }
+        }
+        if (mapping.source) {
+            const newMapping = {
+                generated: {
+                    line: mapping.generatedLine,
+                    column: mapping.generatedColumn,
+                },
+                original: {
+                    line: mapping.originalLine,
+                    column: mapping.originalColumn,
+                },
+                source: mapping.source,
+            };
+            return generator.addMapping(newMapping);
+        }
+        return mapping;
+    });
+    consumer.destroy();
+    // JSON.parse returns any.
+    // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
+    const updatedSourceMap = Object.assign(JSON.parse(generator.toString()), {
+        names: originalMap.names,
+        sourceRoot: originalMap.sourceRoot,
+        sources: originalMap.sources,
+        sourcesContent: originalMap.sourcesContent,
+    });
+    return {
+        map: JSON.stringify(updatedSourceMap),
+        source: src,
+    };
+}
+exports.replaceAndUpdateSourceMap = replaceAndUpdateSourceMap;

tools/ui/node_modules/workbox-build/build/lib/runtime-caching-converter.d.ts

@@ -0,0 +1,3 @@
+import { ModuleRegistry } from './module-registry';
+import { RuntimeCaching } from '../types';
+export declare function runtimeCachingConverter(moduleRegistry: ModuleRegistry, runtimeCaching: Array<RuntimeCaching>): Array<string>;

tools/ui/node_modules/workbox-build/build/lib/runtime-caching-converter.js

@@ -0,0 +1,142 @@
+"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.runtimeCachingConverter = void 0;
+const common_tags_1 = require("common-tags");
+const errors_1 = require("./errors");
+const stringify_without_comments_1 = require("./stringify-without-comments");
+/**
+ * Given a set of options that configures runtime caching behavior, convert it
+ * to the equivalent Workbox method calls.
+ *
+ * @param {ModuleRegistry} moduleRegistry
+ * @param {Object} options See
+ *        https://developers.google.com/web/tools/workbox/modules/workbox-build#generateSW-runtimeCaching
+ * @return {string} A JSON string representing the equivalent options.
+ *
+ * @private
+ */
+function getOptionsString(moduleRegistry, options = {}) {
+    const plugins = [];
+    const handlerOptions = {};
+    for (const optionName of Object.keys(options)) {
+        if (options[optionName] === undefined) {
+            continue;
+        }
+        switch (optionName) {
+            // Using a library here because JSON.stringify won't handle functions.
+            case 'plugins': {
+                plugins.push(...options.plugins.map(stringify_without_comments_1.stringifyWithoutComments));
+                break;
+            }
+            // These are the option properties that we want to pull out, so that
+            // they're passed to the handler constructor.
+            case 'cacheName':
+            case 'networkTimeoutSeconds':
+            case 'fetchOptions':
+            case 'matchOptions': {
+                handlerOptions[optionName] = options[optionName];
+                break;
+            }
+            // The following cases are all shorthands for creating a plugin with a
+            // given configuration.
+            case 'backgroundSync': {
+                const name = options.backgroundSync.name;
+                const plugin = moduleRegistry.use('workbox-background-sync', 'BackgroundSyncPlugin');
+                let pluginCode = `new ${plugin}(${JSON.stringify(name)}`;
+                if (options.backgroundSync.options) {
+                    pluginCode += `, ${(0, stringify_without_comments_1.stringifyWithoutComments)(options.backgroundSync.options)}`;
+                }
+                pluginCode += `)`;
+                plugins.push(pluginCode);
+                break;
+            }
+            case 'broadcastUpdate': {
+                const channelName = options.broadcastUpdate.channelName;
+                const opts = Object.assign({ channelName }, options.broadcastUpdate.options);
+                const plugin = moduleRegistry.use('workbox-broadcast-update', 'BroadcastUpdatePlugin');
+                plugins.push(`new ${plugin}(${(0, stringify_without_comments_1.stringifyWithoutComments)(opts)})`);
+                break;
+            }
+            case 'cacheableResponse': {
+                const plugin = moduleRegistry.use('workbox-cacheable-response', 'CacheableResponsePlugin');
+                plugins.push(`new ${plugin}(${(0, stringify_without_comments_1.stringifyWithoutComments)(options.cacheableResponse)})`);
+                break;
+            }
+            case 'expiration': {
+                const plugin = moduleRegistry.use('workbox-expiration', 'ExpirationPlugin');
+                plugins.push(`new ${plugin}(${(0, stringify_without_comments_1.stringifyWithoutComments)(options.expiration)})`);
+                break;
+            }
+            case 'precacheFallback': {
+                const plugin = moduleRegistry.use('workbox-precaching', 'PrecacheFallbackPlugin');
+                plugins.push(`new ${plugin}(${(0, stringify_without_comments_1.stringifyWithoutComments)(options.precacheFallback)})`);
+                break;
+            }
+            case 'rangeRequests': {
+                const plugin = moduleRegistry.use('workbox-range-requests', 'RangeRequestsPlugin');
+                // There are no configuration options for the constructor.
+                plugins.push(`new ${plugin}()`);
+                break;
+            }
+            default: {
+                throw new Error(
+                // In the default case optionName is typed as 'never'.
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                `${errors_1.errors['bad-runtime-caching-config']} ${optionName}`);
+            }
+        }
+    }
+    if (Object.keys(handlerOptions).length > 0 || plugins.length > 0) {
+        const optionsString = JSON.stringify(handlerOptions).slice(1, -1);
+        return (0, common_tags_1.oneLine) `{
+      ${optionsString ? optionsString + ',' : ''}
+      plugins: [${plugins.join(', ')}]
+    }`;
+    }
+    else {
+        return '';
+    }
+}
+function runtimeCachingConverter(moduleRegistry, runtimeCaching) {
+    return runtimeCaching
+        .map((entry) => {
+        const method = entry.method || 'GET';
+        if (!entry.urlPattern) {
+            throw new Error(errors_1.errors['urlPattern-is-required']);
+        }
+        if (!entry.handler) {
+            throw new Error(errors_1.errors['handler-is-required']);
+        }
+        if (entry.options &&
+            entry.options.networkTimeoutSeconds &&
+            entry.handler !== 'NetworkFirst') {
+            throw new Error(errors_1.errors['invalid-network-timeout-seconds']);
+        }
+        // urlPattern might be a string, a RegExp object, or a function.
+        // If it's a string, it needs to be quoted.
+        const matcher = typeof entry.urlPattern === 'string'
+            ? JSON.stringify(entry.urlPattern)
+            : entry.urlPattern;
+        const registerRoute = moduleRegistry.use('workbox-routing', 'registerRoute');
+        if (typeof entry.handler === 'string') {
+            const optionsString = getOptionsString(moduleRegistry, entry.options);
+            const handler = moduleRegistry.use('workbox-strategies', entry.handler);
+            const strategyString = `new ${handler}(${optionsString})`;
+            return `${registerRoute}(${matcher.toString()}, ${strategyString}, '${method}');\n`;
+        }
+        else if (typeof entry.handler === 'function') {
+            return `${registerRoute}(${matcher.toString()}, ${entry.handler.toString()}, '${method}');\n`;
+        }
+        // '' will be filtered out.
+        return '';
+    })
+        .filter((entry) => Boolean(entry));
+}
+exports.runtimeCachingConverter = runtimeCachingConverter;

tools/ui/node_modules/workbox-build/build/lib/stringify-without-comments.d.ts

@@ -0,0 +1,3 @@
+export declare function stringifyWithoutComments(obj: {
+    [key: string]: any;
+}): string;

tools/ui/node_modules/workbox-build/build/lib/stringify-without-comments.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+  Copyright 2021 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.stringifyWithoutComments = void 0;
+const stringify_object_1 = __importDefault(require("stringify-object"));
+const strip_comments_1 = __importDefault(require("strip-comments"));
+function stringifyWithoutComments(obj) {
+    return (0, stringify_object_1.default)(obj, {
+        // See https://github.com/yeoman/stringify-object#transformobject-property-originalresult
+        transform: (_obj, _prop, str) => {
+            if (typeof _prop !== 'symbol' && typeof _obj[_prop] === 'function') {
+                // Can't typify correctly stripComments
+                return (0, strip_comments_1.default)(str); // eslint-disable-line
+            }
+            return str;
+        },
+    });
+}
+exports.stringifyWithoutComments = stringifyWithoutComments;