@serwist/build 8.0.0

package/dist/index.js

@@ -0,0 +1,1295 @@
+import assert from 'assert';
+import { oneLine } from 'common-tags';
+import crypto from 'crypto';
+import { glob } from 'glob';
+import upath from 'upath';
+import fse from 'fs-extra';
+import prettyBytes from 'pretty-bytes';
+import { betterAjvErrors } from '@apideck/better-ajv-errors';
+import Ajv from 'ajv';
+import stringify from 'fast-json-stable-stringify';
+import { SourceMapGenerator, SourceMapConsumer } from 'source-map';
+
+const errors = {
+    "unable-to-get-rootdir": `Unable to get the root directory of your web app.`,
+    "no-extension": oneLine`Unable to detect a usable extension for a file in your web
+    app directory.`,
+    "invalid-file-manifest-name": 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": oneLine`An error occurred when asking to save details
+    in a config file.`,
+    "unable-to-get-file-hash": oneLine`An error occurred when attempting to create a
+    file hash.`,
+    "unable-to-get-file-size": 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": oneLine`Unable to make output directory for
+    file manifest.`,
+    "read-manifest-template-failure": "Unable to read template for file manifest",
+    "populating-manifest-tmpl-failed": 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": oneLine`Unable to make the directories to output
+    the service worker path.`,
+    "sw-write-failure": "Unable to write the service worker file.",
+    "sw-write-failure-directory": 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-serwist-libraries": oneLine`One or more of the Serwist libraries
+    could not be copied over to the destination directory: `,
+    "invalid-glob-directory": oneLine`The supplied globDirectory must be a path as a
+    string.`,
+    "invalid-dont-cache-bust": 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": oneLine`The input to
+    'getFileManifestEntries()' must be an object.`,
+    "invalid-manifest-path": oneLine`The supplied manifest path is not a string with
+    at least one character.`,
+    "invalid-manifest-entries": oneLine`The manifest entries must be an array of
+    strings or JavaScript objects containing a url parameter.`,
+    "invalid-manifest-format": oneLine`The value of the 'format' option passed to
+    generateFileManifest() must be either 'iife' (the default) or 'es'.`,
+    "invalid-static-file-globs": oneLine`The 'globPatterns' value must be an array
+    of strings.`,
+    "invalid-templated-urls": 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": oneLine`One of the 'templatedURLs' URLs is already
+    being tracked via 'globPatterns': `,
+    "invalid-glob-ignores": oneLine`The 'globIgnores' parameter must be an array of
+    glob pattern strings.`,
+    "manifest-entry-bad-url": oneLine`The generated manifest contains an entry without
+    a URL string. This is likely an error with @serwist/build.`,
+    "modify-url-prefix-bad-prefixes": oneLine`The 'modifyURLPrefix' parameter must be
+    an object with string key value pairs.`,
+    "invalid-inject-manifest-arg": oneLine`The input to 'injectManifest()' must be an
+    object.`,
+    "injection-point-not-found": oneLine`Unable to find a place to inject the manifest.
+    Please ensure that your service worker file contains the following: `,
+    "multiple-injection-points": oneLine`Please ensure that your 'swSrc' file contains
+    only one match for the following: `,
+    "useless-glob-pattern": oneLine`One of the glob patterns doesn't match any files.
+    Please remove or fix the following: `,
+    "bad-template-urls-asset": oneLine`There was an issue using one of the provided
+    'templatedURLs'.`,
+    "invalid-runtime-caching": oneLine`The 'runtimeCaching' parameter must an an
+    array of objects with at least a 'urlPattern' and 'handler'.`,
+    "static-file-globs-deprecated": oneLine`'staticFileGlobs' is deprecated.
+    Please use 'globPatterns' instead.`,
+    "dynamic-url-deprecated": oneLine`'dynamicURLToDependencies' is deprecated.
+    Please use 'templatedURLs' instead.`,
+    "urlPattern-is-required": oneLine`The 'urlPattern' option is required when using
+    'runtimeCaching'.`,
+    "handler-is-required": oneLine`The 'handler' option is required when using
+    runtimeCaching.`,
+    "invalid-generate-file-manifest-arg": oneLine`The input to generateFileManifest()
+    must be an Object.`,
+    "invalid-sw-src": `The 'swSrc' file can't be read.`,
+    "same-src-and-dest": 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:`,
+    "no-module-name": oneLine`You must provide a moduleName parameter when calling
+    getModuleURL().`,
+    "bad-manifest-transforms-return-value": oneLine`The return value from a
+    manifestTransform should be an object with 'manifest' and optionally
+    'warnings' properties.`,
+    "string-entry-warning": oneLine`Some items were passed to additionalPrecacheEntries
+    without revisioning info. This is generally NOT safe. Learn more at
+    https://bit.ly/wb-precache.`,
+    "cant-find-sourcemap": oneLine`The swSrc file refers to a sourcemap that can't be
+    opened:`,
+    "manifest-transforms": oneLine`When using manifestTransforms, you must provide
+    an array of functions.`
+};
+
+function getCompositeDetails(compositeURL, dependencyDetails) {
+    let totalSize = 0;
+    let compositeHash = "";
+    for (const fileDetails of dependencyDetails){
+        totalSize += fileDetails.size;
+        compositeHash += fileDetails.hash;
+    }
+    const md5 = crypto.createHash("md5");
+    md5.update(compositeHash);
+    const hashOfHashes = md5.digest("hex");
+    return {
+        file: compositeURL,
+        hash: hashOfHashes,
+        size: totalSize
+    };
+}
+
+function getStringHash(input) {
+    const md5 = crypto.createHash("md5");
+    md5.update(input);
+    return md5.digest("hex");
+}
+
+function getFileHash(file) {
+    try {
+        const buffer = fse.readFileSync(file);
+        return getStringHash(buffer);
+    } catch (err) {
+        throw new Error(errors["unable-to-get-file-hash"] + ` '${err instanceof Error && err.message ? err.message : ""}'`);
+    }
+}
+
+function getFileSize(file) {
+    try {
+        const stat = fse.statSync(file);
+        if (!stat.isFile()) {
+            return null;
+        }
+        return stat.size;
+    } catch (err) {
+        throw new Error(errors["unable-to-get-file-size"] + ` '${err instanceof Error && err.message ? err.message : ""}'`);
+    }
+}
+
+function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern }) {
+    let globbedFiles;
+    let warning = "";
+    try {
+        globbedFiles = glob.sync(globPattern, {
+            cwd: globDirectory,
+            follow: globFollow,
+            ignore: globIgnores
+        });
+    } catch (err) {
+        throw new Error(errors["unable-to-glob-files"] + ` '${err instanceof Error && err.message ? err.message : ""}'`);
+    }
+    if (globbedFiles.length === 0) {
+        warning = errors["useless-glob-pattern"] + " " + JSON.stringify({
+            globDirectory,
+            globPattern,
+            globIgnores
+        }, null, 2);
+    }
+    const globbedFileDetails = [];
+    for (const file of globbedFiles){
+        const fullPath = upath.join(globDirectory, file);
+        const fileSize = getFileSize(fullPath);
+        if (fileSize !== null) {
+            const fileHash = getFileHash(fullPath);
+            globbedFileDetails.push({
+                file: `${upath.relative(globDirectory, fullPath)}`,
+                hash: fileHash,
+                size: fileSize
+            });
+        }
+    }
+    return {
+        globbedFileDetails,
+        warning
+    };
+}
+
+function getStringDetails(url, str) {
+    return {
+        file: url,
+        hash: getStringHash(str),
+        size: str.length
+    };
+}
+
+function additionalPrecacheEntriesTransform(additionalPrecacheEntries) {
+    return (manifest)=>{
+        const warnings = [];
+        const stringEntries = new Set();
+        for (const additionalEntry of additionalPrecacheEntries){
+            // 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["string-entry-warning"] + urls);
+        }
+        return {
+            manifest,
+            warnings
+        };
+    };
+}
+
+function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
+    return (originalManifest)=>{
+        const warnings = [];
+        const manifest = originalManifest.filter((entry)=>{
+            if (entry.size <= maximumFileSizeToCacheInBytes) {
+                return true;
+            }
+            warnings.push(`${entry.url} is ${prettyBytes(entry.size)}, and won't ` + `be precached. Configure maximumFileSizeToCacheInBytes to change ` + `this limit.`);
+            return false;
+        });
+        return {
+            manifest,
+            warnings
+        };
+    };
+}
+
+/*
+  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.
+*/ // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function modifyURLPrefixTransform(modifyURLPrefix) {
+    if (!modifyURLPrefix || typeof modifyURLPrefix !== "object" || Array.isArray(modifyURLPrefix)) {
+        throw new Error(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["modify-url-prefix-bad-prefixes"]);
+        }
+    }
+    // Escape the user input so it's safe to use in a regex.
+    const safeModifyURLPrefixes = Object.keys(modifyURLPrefix).map(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["manifest-entry-bad-url"]);
+            }
+            entry.url = entry.url.replace(modifyRegex, (match)=>{
+                return modifyURLPrefix[match];
+            });
+            return entry;
+        });
+        return {
+            manifest
+        };
+    };
+}
+
+function noRevisionForURLsMatchingTransform(regexp) {
+    if (!(regexp instanceof RegExp)) {
+        throw new Error(errors["invalid-dont-cache-bust"]);
+    }
+    return (originalManifest)=>{
+        const manifest = originalManifest.map((entry)=>{
+            if (typeof entry.url !== "string") {
+                throw new Error(errors["manifest-entry-bad-url"]);
+            }
+            if (entry.url.match(regexp)) {
+                entry.revision = null;
+            }
+            return entry;
+        });
+        return {
+            manifest
+        };
+    };
+}
+
+async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsMatching, fileDetails, manifestTransforms, maximumFileSizeToCacheInBytes, modifyURLPrefix, transformParam }) {
+    const allWarnings = [];
+    // Take the array of fileDetail objects and convert it into an array of
+    // {url, revision, size} objects, with \ replaced with /.
+    const normalizedManifest = fileDetails.map((fileDetails)=>{
+        return {
+            url: fileDetails.file.replace(/\\/g, "/"),
+            revision: fileDetails.hash,
+            size: fileDetails.size
+        };
+    });
+    const transformsToApply = [];
+    if (maximumFileSizeToCacheInBytes) {
+        transformsToApply.push(maximumSizeTransform(maximumFileSizeToCacheInBytes));
+    }
+    if (modifyURLPrefix) {
+        transformsToApply.push(modifyURLPrefixTransform(modifyURLPrefix));
+    }
+    if (dontCacheBustURLsMatching) {
+        transformsToApply.push(noRevisionForURLsMatchingTransform(dontCacheBustURLsMatching));
+    }
+    // Run any manifestTransforms functions second-to-last.
+    if (manifestTransforms) {
+        transformsToApply.push(...manifestTransforms);
+    }
+    // Run additionalPrecacheEntriesTransform last.
+    if (additionalPrecacheEntries) {
+        transformsToApply.push(additionalPrecacheEntriesTransform(additionalPrecacheEntries));
+    }
+    let transformedManifest = normalizedManifest;
+    for (const transform of transformsToApply){
+        const result = await transform(transformedManifest, transformParam);
+        if (!("manifest" in result)) {
+            throw new Error(errors["bad-manifest-transforms-return-value"]);
+        }
+        transformedManifest = result.manifest;
+        allWarnings.push(...result.warnings || []);
+    }
+    // Generate some metadata about the manifest before we clear out the size
+    // properties from each entry.
+    const count = transformedManifest.length;
+    let size = 0;
+    for (const manifestEntry of transformedManifest){
+        size += manifestEntry.size || 0;
+        delete manifestEntry.size;
+    }
+    return {
+        count,
+        size,
+        manifestEntries: transformedManifest,
+        warnings: allWarnings
+    };
+}
+
+async function getFileManifestEntries({ additionalPrecacheEntries, dontCacheBustURLsMatching, globDirectory, globFollow, globIgnores, globPatterns = [], globStrict, manifestTransforms, maximumFileSizeToCacheInBytes, modifyURLPrefix, templatedURLs }) {
+    const warnings = [];
+    const allFileDetails = new Map();
+    try {
+        for (const globPattern of globPatterns){
+            const { globbedFileDetails, warning } = getFileDetails({
+                globDirectory,
+                globFollow,
+                globIgnores,
+                globPattern,
+                globStrict
+            });
+            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)){
+            assert(!allFileDetails.has(url), errors["templated-url-matches-glob"]);
+            const dependencies = templatedURLs[url];
+            if (Array.isArray(dependencies)) {
+                const details = dependencies.reduce((previous, globPattern)=>{
+                    try {
+                        const { globbedFileDetails, warning } = getFileDetails({
+                            globDirectory,
+                            globFollow,
+                            globIgnores,
+                            globPattern,
+                            globStrict
+                        });
+                        if (warning) {
+                            warnings.push(warning);
+                        }
+                        return previous.concat(globbedFileDetails);
+                    } catch (error) {
+                        const debugObj = {};
+                        debugObj[url] = dependencies;
+                        throw new Error(`${errors["bad-template-urls-asset"]} ` + `'${globPattern}' from '${JSON.stringify(debugObj)}':\n` + `${error instanceof Error ? error.toString() : ""}`);
+                    }
+                }, []);
+                if (details.length === 0) {
+                    throw new Error(`${errors["bad-template-urls-asset"]} The glob ` + `pattern '${dependencies.toString()}' did not match anything.`);
+                }
+                allFileDetails.set(url, getCompositeDetails(url, details));
+            } else if (typeof dependencies === "string") {
+                allFileDetails.set(url, getStringDetails(url, dependencies));
+            }
+        }
+    }
+    const transformedManifest = await transformManifest({
+        additionalPrecacheEntries,
+        dontCacheBustURLsMatching,
+        manifestTransforms,
+        maximumFileSizeToCacheInBytes,
+        modifyURLPrefix,
+        fileDetails: Array.from(allFileDetails.values())
+    });
+    transformedManifest.warnings.push(...warnings);
+    return transformedManifest;
+}
+
+var additionalProperties$2 = false;
+var type$2 = "object";
+var properties$2 = {
+    additionalPrecacheEntries: {
+        description: "A list of entries to be precached, in addition to any entries that are\ngenerated as part of the build configuration.",
+        type: "array",
+        items: {
+            anyOf: [
+                {
+                    $ref: "#/definitions/ManifestEntry"
+                },
+                {
+                    type: "string"
+                }
+            ]
+        }
+    },
+    dontCacheBustURLsMatching: {
+        description: "Assets that match this will be assumed to be uniquely versioned via their\nURL, and exempted from the normal HTTP cache-busting that's done when\npopulating the precache. While not required, it's recommended that if your\nexisting build process already inserts a `[hash]` value into each filename,\nyou provide a RegExp that will detect that, as it will reduce the bandwidth\nconsumed when precaching.",
+        $ref: "#/definitions/RegExp"
+    },
+    manifestTransforms: {
+        description: "One or more functions which will be applied sequentially against the\ngenerated manifest. If `modifyURLPrefix` or `dontCacheBustURLsMatching` are\nalso specified, their corresponding transformations will be applied first.",
+        type: "array",
+        items: {}
+    },
+    maximumFileSizeToCacheInBytes: {
+        description: "This value can be used to determine the maximum size of files that will be\nprecached. This prevents you from inadvertently precaching very large files\nthat might have accidentally matched one of your patterns.",
+        "default": 2097152,
+        type: "number"
+    },
+    modifyURLPrefix: {
+        description: "An object mapping string prefixes to replacement string values. This can be\nused to, e.g., remove or add a path prefix from a manifest entry if your\nweb hosting setup doesn't match your local filesystem setup. As an\nalternative with more flexibility, you can use the `manifestTransforms`\noption and provide a function that modifies the entries in the manifest\nusing whatever logic you provide.\n\nExample usage:\n\n```\n// Replace a '/dist/' prefix with '/', and also prepend\n// '/static' to every URL.\nmodifyURLPrefix: {\n  '/dist/': '/',\n  '': '/static',\n}\n```",
+        type: "object",
+        additionalProperties: {
+            type: "string"
+        }
+    },
+    globFollow: {
+        description: "Determines whether or not symlinks are followed when generating the\nprecache manifest. For more information, see the definition of `follow` in\nthe `glob` [documentation](https://github.com/isaacs/node-glob#options).",
+        "default": true,
+        type: "boolean"
+    },
+    globIgnores: {
+        description: "A set of patterns matching files to always exclude when generating the\nprecache manifest. For more information, see the definition of `ignore` in\nthe `glob` [documentation](https://github.com/isaacs/node-glob#options).",
+        "default": [
+            "**/node_modules/**/*"
+        ],
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    globPatterns: {
+        description: "Files matching any of these patterns will be included in the precache\nmanifest. For more information, see the\n[`glob` primer](https://github.com/isaacs/node-glob#glob-primer).",
+        "default": [
+            "**/*.{js,css,html}"
+        ],
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    globStrict: {
+        description: "If true, an error reading a directory when generating a precache manifest\nwill cause the build to fail. If false, the problematic directory will be\nskipped. For more information, see the definition of `strict` in the `glob`\n[documentation](https://github.com/isaacs/node-glob#options).",
+        "default": true,
+        type: "boolean"
+    },
+    templatedURLs: {
+        description: "If a URL is rendered based on some server-side logic, its contents may\ndepend on multiple files or on some other unique string value. The keys in\nthis object are server-rendered URLs. If the values are an array of\nstrings, they will be interpreted as `glob` patterns, and the contents of\nany files matching the patterns will be used to uniquely version the URL.\nIf used with a single string, it will be interpreted as unique versioning\ninformation that you've generated for a given URL.",
+        type: "object",
+        additionalProperties: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                {
+                    type: "string"
+                }
+            ]
+        }
+    },
+    globDirectory: {
+        description: "The local directory you wish to match `globPatterns` against. The path is\nrelative to the current directory.",
+        type: "string"
+    }
+};
+var required$2 = [
+    "globDirectory"
+];
+var definitions$2 = {
+    ManifestEntry: {
+        type: "object",
+        properties: {
+            integrity: {
+                type: "string"
+            },
+            revision: {
+                type: [
+                    "null",
+                    "string"
+                ]
+            },
+            url: {
+                type: "string"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "revision",
+            "url"
+        ]
+    },
+    "RegExp": {
+        type: "object",
+        properties: {
+            source: {
+                type: "string"
+            },
+            global: {
+                type: "boolean"
+            },
+            ignoreCase: {
+                type: "boolean"
+            },
+            multiline: {
+                type: "boolean"
+            },
+            lastIndex: {
+                type: "number"
+            },
+            flags: {
+                type: "string"
+            },
+            sticky: {
+                type: "boolean"
+            },
+            unicode: {
+                type: "boolean"
+            },
+            dotAll: {
+                type: "boolean"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "dotAll",
+            "flags",
+            "global",
+            "ignoreCase",
+            "lastIndex",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode"
+        ]
+    }
+};
+var $schema$2 = "http://json-schema.org/draft-07/schema#";
+var getManifestOptionsSchema = {
+    additionalProperties: additionalProperties$2,
+    type: type$2,
+    properties: properties$2,
+    required: required$2,
+    definitions: definitions$2,
+    $schema: $schema$2
+};
+
+var additionalProperties$1 = false;
+var type$1 = "object";
+var properties$1 = {
+    additionalPrecacheEntries: {
+        description: "A list of entries to be precached, in addition to any entries that are\ngenerated as part of the build configuration.",
+        type: "array",
+        items: {
+            anyOf: [
+                {
+                    $ref: "#/definitions/ManifestEntry"
+                },
+                {
+                    type: "string"
+                }
+            ]
+        }
+    },
+    dontCacheBustURLsMatching: {
+        description: "Assets that match this will be assumed to be uniquely versioned via their\nURL, and exempted from the normal HTTP cache-busting that's done when\npopulating the precache. While not required, it's recommended that if your\nexisting build process already inserts a `[hash]` value into each filename,\nyou provide a RegExp that will detect that, as it will reduce the bandwidth\nconsumed when precaching.",
+        $ref: "#/definitions/RegExp"
+    },
+    manifestTransforms: {
+        description: "One or more functions which will be applied sequentially against the\ngenerated manifest. If `modifyURLPrefix` or `dontCacheBustURLsMatching` are\nalso specified, their corresponding transformations will be applied first.",
+        type: "array",
+        items: {}
+    },
+    maximumFileSizeToCacheInBytes: {
+        description: "This value can be used to determine the maximum size of files that will be\nprecached. This prevents you from inadvertently precaching very large files\nthat might have accidentally matched one of your patterns.",
+        "default": 2097152,
+        type: "number"
+    },
+    modifyURLPrefix: {
+        description: "An object mapping string prefixes to replacement string values. This can be\nused to, e.g., remove or add a path prefix from a manifest entry if your\nweb hosting setup doesn't match your local filesystem setup. As an\nalternative with more flexibility, you can use the `manifestTransforms`\noption and provide a function that modifies the entries in the manifest\nusing whatever logic you provide.\n\nExample usage:\n\n```\n// Replace a '/dist/' prefix with '/', and also prepend\n// '/static' to every URL.\nmodifyURLPrefix: {\n  '/dist/': '/',\n  '': '/static',\n}\n```",
+        type: "object",
+        additionalProperties: {
+            type: "string"
+        }
+    },
+    globFollow: {
+        description: "Determines whether or not symlinks are followed when generating the\nprecache manifest. For more information, see the definition of `follow` in\nthe `glob` [documentation](https://github.com/isaacs/node-glob#options).",
+        "default": true,
+        type: "boolean"
+    },
+    globIgnores: {
+        description: "A set of patterns matching files to always exclude when generating the\nprecache manifest. For more information, see the definition of `ignore` in\nthe `glob` [documentation](https://github.com/isaacs/node-glob#options).",
+        "default": [
+            "**/node_modules/**/*"
+        ],
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    globPatterns: {
+        description: "Files matching any of these patterns will be included in the precache\nmanifest. For more information, see the\n[`glob` primer](https://github.com/isaacs/node-glob#glob-primer).",
+        "default": [
+            "**/*.{js,css,html}"
+        ],
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    globStrict: {
+        description: "If true, an error reading a directory when generating a precache manifest\nwill cause the build to fail. If false, the problematic directory will be\nskipped. For more information, see the definition of `strict` in the `glob`\n[documentation](https://github.com/isaacs/node-glob#options).",
+        "default": true,
+        type: "boolean"
+    },
+    templatedURLs: {
+        description: "If a URL is rendered based on some server-side logic, its contents may\ndepend on multiple files or on some other unique string value. The keys in\nthis object are server-rendered URLs. If the values are an array of\nstrings, they will be interpreted as `glob` patterns, and the contents of\nany files matching the patterns will be used to uniquely version the URL.\nIf used with a single string, it will be interpreted as unique versioning\ninformation that you've generated for a given URL.",
+        type: "object",
+        additionalProperties: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                },
+                {
+                    type: "string"
+                }
+            ]
+        }
+    },
+    injectionPoint: {
+        description: "The string to find inside of the `swSrc` file. Once found, it will be\nreplaced by the generated precache manifest.",
+        "default": "self.__SW_MANIFEST",
+        type: "string"
+    },
+    swSrc: {
+        description: "The path and filename of the service worker file that will be read during\nthe build process, relative to the current working directory.",
+        type: "string"
+    },
+    swDest: {
+        description: "The path and filename of the service worker file that will be created by\nthe build process, relative to the current working directory. It must end\nin '.js'.",
+        type: "string"
+    },
+    globDirectory: {
+        description: "The local directory you wish to match `globPatterns` against. The path is\nrelative to the current directory.",
+        type: "string"
+    }
+};
+var required$1 = [
+    "globDirectory",
+    "swDest",
+    "swSrc"
+];
+var definitions$1 = {
+    ManifestEntry: {
+        type: "object",
+        properties: {
+            integrity: {
+                type: "string"
+            },
+            revision: {
+                type: [
+                    "null",
+                    "string"
+                ]
+            },
+            url: {
+                type: "string"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "revision",
+            "url"
+        ]
+    },
+    "RegExp": {
+        type: "object",
+        properties: {
+            source: {
+                type: "string"
+            },
+            global: {
+                type: "boolean"
+            },
+            ignoreCase: {
+                type: "boolean"
+            },
+            multiline: {
+                type: "boolean"
+            },
+            lastIndex: {
+                type: "number"
+            },
+            flags: {
+                type: "string"
+            },
+            sticky: {
+                type: "boolean"
+            },
+            unicode: {
+                type: "boolean"
+            },
+            dotAll: {
+                type: "boolean"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "dotAll",
+            "flags",
+            "global",
+            "ignoreCase",
+            "lastIndex",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode"
+        ]
+    }
+};
+var $schema$1 = "http://json-schema.org/draft-07/schema#";
+var injectManifestOptionsSchema = {
+    additionalProperties: additionalProperties$1,
+    type: type$1,
+    properties: properties$1,
+    required: required$1,
+    definitions: definitions$1,
+    $schema: $schema$1
+};
+
+var additionalProperties = false;
+var type = "object";
+var properties = {
+    additionalPrecacheEntries: {
+        description: "A list of entries to be precached, in addition to any entries that are\ngenerated as part of the build configuration.",
+        type: "array",
+        items: {
+            anyOf: [
+                {
+                    $ref: "#/definitions/ManifestEntry"
+                },
+                {
+                    type: "string"
+                }
+            ]
+        }
+    },
+    dontCacheBustURLsMatching: {
+        description: "Assets that match this will be assumed to be uniquely versioned via their\nURL, and exempted from the normal HTTP cache-busting that's done when\npopulating the precache. While not required, it's recommended that if your\nexisting build process already inserts a `[hash]` value into each filename,\nyou provide a RegExp that will detect that, as it will reduce the bandwidth\nconsumed when precaching.",
+        $ref: "#/definitions/RegExp"
+    },
+    manifestTransforms: {
+        description: "One or more functions which will be applied sequentially against the\ngenerated manifest. If `modifyURLPrefix` or `dontCacheBustURLsMatching` are\nalso specified, their corresponding transformations will be applied first.",
+        type: "array",
+        items: {}
+    },
+    maximumFileSizeToCacheInBytes: {
+        description: "This value can be used to determine the maximum size of files that will be\nprecached. This prevents you from inadvertently precaching very large files\nthat might have accidentally matched one of your patterns.",
+        "default": 2097152,
+        type: "number"
+    },
+    modifyURLPrefix: {
+        description: "An object mapping string prefixes to replacement string values. This can be\nused to, e.g., remove or add a path prefix from a manifest entry if your\nweb hosting setup doesn't match your local filesystem setup. As an\nalternative with more flexibility, you can use the `manifestTransforms`\noption and provide a function that modifies the entries in the manifest\nusing whatever logic you provide.\n\nExample usage:\n\n```\n// Replace a '/dist/' prefix with '/', and also prepend\n// '/static' to every URL.\nmodifyURLPrefix: {\n  '/dist/': '/',\n  '': '/static',\n}\n```",
+        type: "object",
+        additionalProperties: {
+            type: "string"
+        }
+    },
+    chunks: {
+        description: "One or more chunk names whose corresponding output files should be included\nin the precache manifest.",
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    exclude: {
+        description: "One or more specifiers used to exclude assets from the precache manifest.\nThis is interpreted following\n[the same rules](https://webpack.js.org/configuration/module/#condition)\nas `webpack`'s standard `exclude` option.\nIf not provided, the default value is `[/\\.map$/, /^manifest.*\\.js$]`.",
+        type: "array",
+        items: {}
+    },
+    excludeChunks: {
+        description: "One or more chunk names whose corresponding output files should be excluded\nfrom the precache manifest.",
+        type: "array",
+        items: {
+            type: "string"
+        }
+    },
+    include: {
+        description: "One or more specifiers used to include assets in the precache manifest.\nThis is interpreted following\n[the same rules](https://webpack.js.org/configuration/module/#condition)\nas `webpack`'s standard `include` option.",
+        type: "array",
+        items: {}
+    },
+    mode: {
+        description: "If set to 'production', then an optimized service worker bundle that\nexcludes debugging info will be produced. If not explicitly configured\nhere, the `mode` value configured in the current `webpack` compilation\nwill be used.",
+        type: [
+            "null",
+            "string"
+        ]
+    },
+    injectionPoint: {
+        description: "The string to find inside of the `swSrc` file. Once found, it will be\nreplaced by the generated precache manifest.",
+        "default": "self.__SW_MANIFEST",
+        type: "string"
+    },
+    swSrc: {
+        description: "The path and filename of the service worker file that will be read during\nthe build process, relative to the current working directory.",
+        type: "string"
+    },
+    compileSrc: {
+        description: "When `true` (the default), the `swSrc` file will be compiled by webpack.\nWhen `false`, compilation will not occur (and `webpackCompilationPlugins`\ncan't be used.) Set to `false` if you want to inject the manifest into,\ne.g., a JSON file.",
+        "default": true,
+        type: "boolean"
+    },
+    swDest: {
+        description: "The asset name of the service worker file that will be created by this\nplugin. If omitted, the name will be based on the `swSrc` name.",
+        type: "string"
+    },
+    webpackCompilationPlugins: {
+        description: "Optional `webpack` plugins that will be used when compiling the `swSrc`\ninput file. Only valid if `compileSrc` is `true`.",
+        type: "array",
+        items: {}
+    },
+    disablePrecacheManifest: {
+        description: "Whether the precache manifest should be set to `undefined`.",
+        "default": false,
+        type: "boolean"
+    }
+};
+var required = [
+    "swSrc"
+];
+var definitions = {
+    ManifestEntry: {
+        type: "object",
+        properties: {
+            integrity: {
+                type: "string"
+            },
+            revision: {
+                type: [
+                    "null",
+                    "string"
+                ]
+            },
+            url: {
+                type: "string"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "revision",
+            "url"
+        ]
+    },
+    "RegExp": {
+        type: "object",
+        properties: {
+            source: {
+                type: "string"
+            },
+            global: {
+                type: "boolean"
+            },
+            ignoreCase: {
+                type: "boolean"
+            },
+            multiline: {
+                type: "boolean"
+            },
+            lastIndex: {
+                type: "number"
+            },
+            flags: {
+                type: "string"
+            },
+            sticky: {
+                type: "boolean"
+            },
+            unicode: {
+                type: "boolean"
+            },
+            dotAll: {
+                type: "boolean"
+            }
+        },
+        additionalProperties: false,
+        required: [
+            "dotAll",
+            "flags",
+            "global",
+            "ignoreCase",
+            "lastIndex",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode"
+        ]
+    }
+};
+var $schema = "http://json-schema.org/draft-07/schema#";
+var webpackInjectManifestOptionsSchema = {
+    additionalProperties: additionalProperties,
+    type: type,
+    properties: properties,
+    required: required,
+    definitions: definitions,
+    $schema: $schema
+};
+
+const optionsSchemas = {
+    GetManifest: getManifestOptionsSchema,
+    InjectManifest: injectManifestOptionsSchema,
+    WebpackInjectManifest: webpackInjectManifestOptionsSchema
+};
+
+const ajv = new Ajv({
+    useDefaults: true
+});
+const DEFAULT_EXCLUDE_VALUE = [
+    /\.map$/,
+    /^manifest.*\.js$/
+];
+class SerwistConfigError extends Error {
+    constructor(message){
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+// Some methods need to do follow-up validation using the JSON schema,
+// so return both the validated options and then schema.
+function validate(input, methodName) {
+    // Don't mutate input: https://github.com/GoogleChrome/workbox/issues/2158
+    const inputCopy = Object.assign({}, input);
+    const jsonSchema = optionsSchemas[methodName];
+    const validate = ajv.compile(jsonSchema);
+    if (validate(inputCopy)) {
+        // All methods support manifestTransforms, so validate it here.
+        ensureValidManifestTransforms(inputCopy);
+        return [
+            inputCopy,
+            jsonSchema
+        ];
+    }
+    const betterErrors = betterAjvErrors({
+        basePath: methodName,
+        data: input,
+        errors: validate.errors,
+        // This is needed as JSONSchema6 is expected, but JSONSchemaType works.
+        // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
+        schema: jsonSchema
+    });
+    const messages = betterErrors.map((err)=>oneLine`[${err.path}] ${err.message}.
+    ${err.suggestion ? err.suggestion : ""}`);
+    throw new SerwistConfigError(messages.join("\n\n"));
+}
+function ensureValidManifestTransforms(options) {
+    if ("manifestTransforms" in options && !(Array.isArray(options.manifestTransforms) && options.manifestTransforms.every((item)=>typeof item === "function"))) {
+        throw new SerwistConfigError(errors["manifest-transforms"]);
+    }
+}
+function validateGetManifestOptions(input) {
+    const [validatedOptions] = validate(input, "GetManifest");
+    return validatedOptions;
+}
+function validateInjectManifestOptions(input) {
+    const [validatedOptions] = validate(input, "InjectManifest");
+    return validatedOptions;
+}
+function validateWebpackInjectManifestOptions(input) {
+    const inputWithExcludeDefault = Object.assign({
+        // Make a copy, as exclude can be mutated when used.
+        exclude: Array.from(DEFAULT_EXCLUDE_VALUE)
+    }, input);
+    const [validatedOptions] = validate(inputWithExcludeDefault, "WebpackInjectManifest");
+    return validatedOptions;
+}
+
+/**
+ * This method returns a list of URLs to precache, referred to as a "precache
+ * manifest", along with details about the number of entries and their size,
+ * based on the options you provide.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * const {count, manifestEntries, size, warnings} = await getManifest({
+ *   dontCacheBustURLsMatching: [new RegExp('...')],
+ *   globDirectory: '...',
+ *   globPatterns: ['...', '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ * });
+ * ```
+ */ async function getManifest(config) {
+    const options = validateGetManifestOptions(config);
+    return await getFileManifestEntries(options);
+}
+
+/*
+  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.
+*/ // 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;
+}
+
+function rebasePath({ baseDirectory, file }) {
+    // The initial path is relative to the current directory, so make it absolute.
+    const absolutePath = upath.resolve(file);
+    // Convert the absolute path so that it's relative to the baseDirectory.
+    const relativePath = upath.relative(baseDirectory, absolutePath);
+    // Remove any leading ./ as it won't work in a glob pattern.
+    const normalizedPath = upath.normalize(relativePath);
+    return normalizedPath;
+}
+
+/**
+ * Adapted from https://github.com/nsams/sourcemap-aware-replace, with modern
+ * JavaScript updates, along with additional properties copied from originalMap.
+ *
+ * @param options
+ * @returns 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 SourceMapGenerator({
+        file: jsFilename
+    });
+    const consumer = await new 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
+    };
+}
+
+function translateURLToSourcemapPaths(url, swSrc, swDest) {
+    let destPath = undefined;
+    let srcPath = undefined;
+    let warning = undefined;
+    if (url && !url.startsWith("data:")) {
+        const possibleSrcPath = upath.resolve(upath.dirname(swSrc), url);
+        if (fse.existsSync(possibleSrcPath)) {
+            srcPath = possibleSrcPath;
+            destPath = upath.resolve(upath.dirname(swDest), url);
+        } else {
+            warning = `${errors["cant-find-sourcemap"]} ${possibleSrcPath}`;
+        }
+    }
+    return {
+        destPath,
+        srcPath,
+        warning
+    };
+}
+
+/**
+ * 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: '...',
+ * });
+ * ```
+ */ async function injectManifest(config) {
+    const options = 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(rebasePath({
+            file,
+            baseDirectory: options.globDirectory
+        }));
+    }
+    const globalRegexp = new RegExp(escapeRegExp(options.injectionPoint), "g");
+    const { count, size, manifestEntries, warnings } = await getFileManifestEntries(options);
+    let swFileContents;
+    try {
+        swFileContents = await fse.readFile(options.swSrc, "utf8");
+    } catch (error) {
+        throw new Error(`${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.resolve(options.swSrc) === upath.resolve(options.swDest)) {
+            throw new Error(`${errors["same-src-and-dest"]} ${injectionPoint}`);
+        }
+        throw new Error(`${errors["injection-point-not-found"]} ${injectionPoint}`);
+    }
+    assert(injectionResults.length === 1, `${errors["multiple-injection-points"]} ${injectionPoint}`);
+    const manifestString = stringify(manifestEntries);
+    const filesToWrite = {};
+    const url = getSourceMapURL(swFileContents);
+    // See https://github.com/GoogleChrome/workbox/issues/2957
+    const { destPath, srcPath, warning } = 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 fse.readJSON(srcPath, {
+            encoding: "utf8"
+        });
+        const { map, source } = await replaceAndUpdateSourceMap({
+            originalMap,
+            jsFilename: upath.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 fse.mkdirp(upath.dirname(file));
+        } catch (error) {
+            throw new Error(errors["unable-to-make-sw-directory"] + ` '${error instanceof Error && error.message ? error.message : ""}'`);
+        }
+        await fse.writeFile(file, contents);
+    }
+    return {
+        count,
+        size,
+        warnings,
+        // Use upath.resolve() to make all the paths absolute.
+        filePaths: Object.keys(filesToWrite).map((f)=>upath.resolve(f))
+    };
+}
+
+export { escapeRegExp, getManifest, getSourceMapURL, injectManifest, replaceAndUpdateSourceMap, transformManifest, validateWebpackInjectManifestOptions };