@serwist/webpack-plugin 8.0.0

package/dist/index.old.cjs

@@ -0,0 +1,496 @@
+'use strict';
+
+var path = require('node:path');
+var build = require('@serwist/build');
+var stringify = require('fast-json-stable-stringify');
+var prettyBytes = require('pretty-bytes');
+var upath = require('upath');
+var webpack = require('webpack');
+var crypto = require('crypto');
+
+/**
+ * @param asset
+ * @returns The MD5 hash of the asset's source.
+ *
+ * @private
+ */ function getAssetHash(asset) {
+    // If webpack has the asset marked as immutable, then we don't need to
+    // use an out-of-band revision for it.
+    // See https://github.com/webpack/webpack/issues/9038
+    if (asset.info && asset.info.immutable) {
+        return null;
+    }
+    return crypto.createHash("md5").update(Buffer.from(asset.source.source())).digest("hex");
+}
+
+/*
+  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.
+*/ /**
+ * Resolves a url in the way that webpack would (with string concatenation)
+ *
+ * Use publicPath + filePath instead of url.resolve(publicPath, filePath) see:
+ * https://webpack.js.org/configuration/output/#output-publicpath
+ *
+ * @param publicPath The publicPath value from webpack's compilation.
+ * @param paths File paths to join
+ * @returns Joined file path
+ * @private
+ */ function resolveWebpackURL(publicPath, ...paths) {
+    // This is a change in webpack v5.
+    // See https://github.com/jantimon/html-webpack-plugin/pull/1516
+    if (publicPath === "auto") {
+        return paths.join("");
+    } else {
+        return [
+            publicPath,
+            ...paths
+        ].join("");
+    }
+}
+
+/**
+ * For a given asset, checks whether at least one of the conditions matches.
+ *
+ * @param asset The webpack asset in question. This will be passed
+ * to any functions that are listed as conditions.
+ * @param compilation The webpack compilation. This will be passed
+ * to any functions that are listed as conditions.
+ * @param conditions
+ * @returns Whether or not at least one condition matches.
+ * @private
+ */ function checkConditions(asset, compilation, conditions = []) {
+    for (const condition of conditions){
+        if (typeof condition === "function") {
+            return condition({
+                asset,
+                compilation
+            });
+        //return compilation !== null;
+        } else {
+            if (webpack.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
+                return true;
+            }
+        }
+    }
+    // We'll only get here if none of the conditions applied.
+    return false;
+}
+/**
+ * Returns the names of all the assets in all the chunks in a chunk group,
+ * if provided a chunk group name.
+ * Otherwise, if provided a chunk name, return all the assets in that chunk.
+ * Otherwise, if there isn't a chunk group or chunk with that name, return null.
+ *
+ * @param compilation
+ * @param chunkOrGroup
+ * @returns
+ * @private
+ */ function getNamesOfAssetsInChunkOrGroup(compilation, chunkOrGroup) {
+    const chunkGroup = compilation.namedChunkGroups && compilation.namedChunkGroups.get(chunkOrGroup);
+    if (chunkGroup) {
+        const assetNames = [];
+        for (const chunk of chunkGroup.chunks){
+            assetNames.push(...getNamesOfAssetsInChunk(chunk));
+        }
+        return assetNames;
+    } else {
+        const chunk = compilation.namedChunks && compilation.namedChunks.get(chunkOrGroup);
+        if (chunk) {
+            return getNamesOfAssetsInChunk(chunk);
+        }
+    }
+    // If we get here, there's no chunkGroup or chunk with that name.
+    return null;
+}
+/**
+ * Returns the names of all the assets in a chunk.
+ *
+ * @param chunk
+ * @returns
+ * @private
+ */ function getNamesOfAssetsInChunk(chunk) {
+    const assetNames = [];
+    assetNames.push(...chunk.files);
+    // This only appears to be set in webpack v5.
+    if (chunk.auxiliaryFiles) {
+        assetNames.push(...chunk.auxiliaryFiles);
+    }
+    return assetNames;
+}
+/**
+ * Filters the set of assets out, based on the configuration options provided:
+ * - chunks and excludeChunks, for chunkName-based criteria.
+ * - include and exclude, for more general criteria.
+ *
+ * @param compilation The webpack compilation.
+ * @param config The validated configuration, obtained from the plugin.
+ * @returns The assets that should be included in the manifest,
+ * based on the criteria provided.
+ * @private
+ */ function filterAssets(compilation, config) {
+    const filteredAssets = new Set();
+    const assets = compilation.getAssets();
+    const allowedAssetNames = new Set();
+    // See https://github.com/GoogleChrome/workbox/issues/1287
+    if (Array.isArray(config.chunks)) {
+        for (const name of config.chunks){
+            // See https://github.com/GoogleChrome/workbox/issues/2717
+            const assetsInChunkOrGroup = getNamesOfAssetsInChunkOrGroup(compilation, name);
+            if (assetsInChunkOrGroup) {
+                for (const assetName of assetsInChunkOrGroup){
+                    allowedAssetNames.add(assetName);
+                }
+            } else {
+                compilation.warnings.push(new Error(`The chunk '${name}' was ` + `provided in your Serwist chunks config, but was not found in the ` + `compilation.`));
+            }
+        }
+    }
+    const deniedAssetNames = new Set();
+    if (Array.isArray(config.excludeChunks)) {
+        for (const name of config.excludeChunks){
+            // See https://github.com/GoogleChrome/workbox/issues/2717
+            const assetsInChunkOrGroup = getNamesOfAssetsInChunkOrGroup(compilation, name);
+            if (assetsInChunkOrGroup) {
+                for (const assetName of assetsInChunkOrGroup){
+                    deniedAssetNames.add(assetName);
+                }
+            } // Don't warn if the chunk group isn't found.
+        }
+    }
+    for (const asset of assets){
+        // chunk based filtering is funky because:
+        // - Each asset might belong to one or more chunks.
+        // - If *any* of those chunk names match our config.excludeChunks,
+        //   then we skip that asset.
+        // - If the config.chunks is defined *and* there's no match
+        //   between at least one of the chunkNames and one entry, then
+        //   we skip that assets as well.
+        if (deniedAssetNames.has(asset.name)) {
+            continue;
+        }
+        if (Array.isArray(config.chunks) && !allowedAssetNames.has(asset.name)) {
+            continue;
+        }
+        // Next, check asset-level checks via includes/excludes:
+        const isExcluded = checkConditions(asset, compilation, config.exclude);
+        if (isExcluded) {
+            continue;
+        }
+        // Treat an empty config.includes as an implicit inclusion.
+        const isIncluded = !Array.isArray(config.include) || checkConditions(asset, compilation, config.include);
+        if (!isIncluded) {
+            continue;
+        }
+        // If we've gotten this far, then add the asset.
+        filteredAssets.add(asset);
+    }
+    return filteredAssets;
+}
+async function getManifestEntriesFromCompilation(compilation, config) {
+    const filteredAssets = filterAssets(compilation, config);
+    const { publicPath } = compilation.options.output;
+    const fileDetails = Array.from(filteredAssets).map((asset)=>{
+        return {
+            file: resolveWebpackURL(publicPath, asset.name),
+            hash: getAssetHash(asset),
+            size: asset.source.size() || 0
+        };
+    });
+    const { manifestEntries, size, warnings } = await build.transformManifest({
+        fileDetails,
+        additionalPrecacheEntries: config.additionalPrecacheEntries,
+        dontCacheBustURLsMatching: config.dontCacheBustURLsMatching,
+        manifestTransforms: config.manifestTransforms,
+        maximumFileSizeToCacheInBytes: config.maximumFileSizeToCacheInBytes,
+        modifyURLPrefix: config.modifyURLPrefix,
+        transformParam: compilation
+    });
+    // See https://github.com/GoogleChrome/workbox/issues/2790
+    for (const warning of warnings){
+        compilation.warnings.push(new Error(warning));
+    }
+    // Ensure that the entries are properly sorted by URL.
+    const sortedEntries = manifestEntries.sort((a, b)=>a.url === b.url ? 0 : a.url > b.url ? 1 : -1);
+    return {
+        size,
+        sortedEntries
+    };
+}
+
+/**
+ * If our bundled swDest file contains a sourcemap, we would invalidate that
+ * mapping if we just replaced injectionPoint with the stringified manifest.
+ * Instead, we need to update the swDest contents as well as the sourcemap
+ * at the same time.
+ *
+ * See https://github.com/GoogleChrome/workbox/issues/2235
+ *
+ * @param compilation The current webpack compilation.
+ * @param swContents The contents of the swSrc file, which may or
+ * may not include a valid sourcemap comment.
+ * @param swDest The configured swDest value.
+ * @returns If the swContents contains a valid sourcemap
+ * comment pointing to an asset present in the compilation, this will return the
+ * name of that asset. Otherwise, it will return undefined.
+ * @private
+ */ function getSourcemapAssetName(compilation, swContents, swDest) {
+    const url = build.getSourceMapURL(swContents);
+    if (url) {
+        // Translate the relative URL to what the presumed name for the webpack
+        // asset should be.
+        // This *might* not be a valid asset if the sourcemap URL that was found
+        // was added by another module incidentally.
+        // See https://github.com/GoogleChrome/workbox/issues/2250
+        const swAssetDirname = upath.dirname(swDest);
+        const sourcemapURLAssetName = upath.normalize(upath.join(swAssetDirname, url));
+        // Not sure if there's a better way to check for asset existence?
+        if (compilation.getAsset(sourcemapURLAssetName)) {
+            return sourcemapURLAssetName;
+        }
+    }
+    return undefined;
+}
+
+/**
+ * @param compilation The webpack compilation.
+ * @param swDest The original swDest value.
+ *
+ * @returns If swDest was not absolute, the returns swDest as-is.
+ * Otherwise, returns swDest relative to the compilation's output path.
+ *
+ * @private
+ */ function relativeToOutputPath(compilation, swDest) {
+    // See https://github.com/jantimon/html-webpack-plugin/pull/266/files#diff-168726dbe96b3ce427e7fedce31bb0bcR38
+    if (upath.resolve(swDest) === upath.normalize(swDest)) {
+        return upath.relative(compilation.options.output.path, swDest);
+    }
+    // Otherwise, return swDest as-is.
+    return swDest;
+}
+
+// Used to keep track of swDest files written by *any* instance of this plugin.
+// See https://github.com/GoogleChrome/workbox/issues/2181
+const _generatedAssetNames = new Set();
+/**
+ * This class supports compiling a service worker file provided via `swSrc`,
+ * and injecting into that service worker a list of URLs and revision
+ * information for precaching based on the webpack asset pipeline.
+ *
+ * Use an instance of `InjectManifest` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * In addition to injecting the manifest, this plugin will perform a compilation
+ * of the `swSrc` file, using the options from the main webpack configuration.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new InjectManifest({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swSrc: '...',
+ * });
+ * ```
+ */ class InjectManifest {
+    config;
+    alreadyCalled;
+    /**
+   * Creates an instance of InjectManifest.
+   */ constructor(config){
+        this.config = config;
+        this.alreadyCalled = false;
+    }
+    /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */ propagateWebpackConfig(compiler) {
+        const parsedSwSrc = upath.parse(this.config.swSrc);
+        // Because this.config is listed last, properties that are already set
+        // there take precedence over derived properties from the compiler.
+        this.config = Object.assign({
+            mode: compiler.options.mode,
+            // Use swSrc with a hardcoded .js extension, in case swSrc is a .ts file.
+            swDest: path.join(parsedSwSrc.dir, parsedSwSrc.name + ".js")
+        }, this.config);
+    }
+    /**
+   * `getManifestEntriesFromCompilation` with a few additional checks.
+   *
+   * @private
+   */ async getManifestEntries(compilation, config) {
+        if (config.disablePrecacheManifest) {
+            return {
+                size: 0,
+                sortedEntries: [],
+                manifestString: "undefined"
+            };
+        }
+        // See https://github.com/GoogleChrome/workbox/issues/1790
+        if (this.alreadyCalled) {
+            const warningMessage = `${this.constructor.name} has been called ` + `multiple times, perhaps due to running webpack in --watch mode. The ` + `precache manifest generated after the first call may be inaccurate! ` + `Please see https://github.com/GoogleChrome/workbox/issues/1790 for ` + `more information.`;
+            if (!compilation.warnings.some((warning)=>warning instanceof Error && warning.message === warningMessage)) {
+                compilation.warnings.push(new Error(warningMessage));
+            }
+        } else {
+            this.alreadyCalled = true;
+        }
+        // Ensure that we don't precache any of the assets generated by *any*
+        // instance of this plugin.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        config.exclude.push(({ asset })=>_generatedAssetNames.has(asset.name));
+        const { size, sortedEntries } = await getManifestEntriesFromCompilation(compilation, config);
+        let manifestString = stringify(sortedEntries);
+        if (this.config.compileSrc && // See https://github.com/GoogleChrome/workbox/issues/2729
+        !(compilation.options?.devtool === "eval-cheap-source-map" && compilation.options.optimization?.minimize)) {
+            // See https://github.com/GoogleChrome/workbox/issues/2263
+            manifestString = manifestString.replace(/"/g, `'`);
+        }
+        return {
+            size,
+            sortedEntries,
+            manifestString
+        };
+    }
+    /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */ apply(compiler) {
+        this.propagateWebpackConfig(compiler);
+        compiler.hooks.make.tapPromise(this.constructor.name, (compilation)=>this.handleMake(compilation, compiler).catch((error)=>{
+                compilation.errors.push(error);
+            }));
+        const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = webpack.Compilation;
+        // Specifically hook into thisCompilation, as per
+        // https://github.com/webpack/webpack/issues/11425#issuecomment-690547848
+        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: this.constructor.name,
+                // TODO(jeffposnick): This may need to change eventually.
+                // See https://github.com/webpack/webpack/issues/11822#issuecomment-726184972
+                stage: PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 10
+            }, ()=>this.addAssets(compilation).catch((error)=>{
+                    compilation.errors.push(error);
+                }));
+        });
+    }
+    /**
+   * @param compilation The webpack compilation.
+   * @param parentCompiler The webpack parent compiler.
+   *
+   * @private
+   */ async performChildCompilation(compilation, parentCompiler) {
+        const outputOptions = {
+            filename: this.config.swDest
+        };
+        const childCompiler = compilation.createChildCompiler(this.constructor.name, outputOptions, []);
+        childCompiler.context = parentCompiler.context;
+        childCompiler.inputFileSystem = parentCompiler.inputFileSystem;
+        childCompiler.outputFileSystem = parentCompiler.outputFileSystem;
+        if (Array.isArray(this.config.webpackCompilationPlugins)) {
+            for (const plugin of this.config.webpackCompilationPlugins){
+                plugin.apply(childCompiler);
+            }
+        }
+        new webpack.EntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
+        await new Promise((resolve, reject)=>{
+            childCompiler.runAsChild((error, _entries, childCompilation)=>{
+                if (error) {
+                    reject(error);
+                } else {
+                    compilation.warnings = compilation.warnings.concat(childCompilation?.warnings ?? []);
+                    compilation.errors = compilation.errors.concat(childCompilation?.errors ?? []);
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+   * @param compilation The webpack compilation.
+   * @param parentCompiler The webpack parent compiler.
+   *
+   * @private
+   */ addSrcToAssets(compilation, parentCompiler) {
+        // eslint-disable-next-line
+        const source = parentCompiler.inputFileSystem.readFileSync(this.config.swSrc);
+        compilation.emitAsset(this.config.swDest, new webpack.sources.RawSource(source));
+    }
+    /**
+   * @param compilation The webpack compilation.
+   * @param parentCompiler The webpack parent compiler.
+   *
+   * @private
+   */ async handleMake(compilation, parentCompiler) {
+        try {
+            this.config = build.validateWebpackInjectManifestOptions(this.config);
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Please check your ${this.constructor.name} plugin ` + `configuration:\n${error.message}`);
+            }
+        }
+        this.config.swDest = relativeToOutputPath(compilation, this.config.swDest);
+        _generatedAssetNames.add(this.config.swDest);
+        if (this.config.compileSrc) {
+            await this.performChildCompilation(compilation, parentCompiler);
+        } else {
+            this.addSrcToAssets(compilation, parentCompiler);
+            // This used to be a fatal error, but just warn at runtime because we
+            // can't validate it easily.
+            if (Array.isArray(this.config.webpackCompilationPlugins) && this.config.webpackCompilationPlugins.length > 0) {
+                compilation.warnings.push(new Error("compileSrc is false, so the " + "webpackCompilationPlugins option will be ignored."));
+            }
+        }
+    }
+    /**
+   * @param compilation The webpack compilation.
+   *
+   * @private
+   */ async addAssets(compilation) {
+        const config = Object.assign({}, this.config);
+        const { size, sortedEntries, manifestString } = await this.getManifestEntries(compilation, config);
+        // See https://webpack.js.org/contribute/plugin-patterns/#monitoring-the-watch-graph
+        const absoluteSwSrc = upath.resolve(config.swSrc);
+        compilation.fileDependencies.add(absoluteSwSrc);
+        const swAsset = compilation.getAsset(config.swDest);
+        const swAssetString = swAsset.source.source().toString();
+        const globalRegexp = new RegExp(build.escapeRegExp(config.injectionPoint), "g");
+        const injectionResults = swAssetString.match(globalRegexp);
+        if (!injectionResults) {
+            throw new Error(`Can't find ${config.injectionPoint} in your SW source.`);
+        }
+        if (injectionResults.length !== 1) {
+            throw new Error(`Multiple instances of ${config.injectionPoint} were ` + "found in your SW source. Include it only once. For more info, see " + "https://github.com/GoogleChrome/workbox/issues/2681");
+        }
+        const sourcemapAssetName = getSourcemapAssetName(compilation, swAssetString, config.swDest);
+        if (sourcemapAssetName) {
+            _generatedAssetNames.add(sourcemapAssetName);
+            const sourcemapAsset = compilation.getAsset(sourcemapAssetName);
+            const { source, map } = await build.replaceAndUpdateSourceMap({
+                jsFilename: config.swDest,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                originalMap: JSON.parse(sourcemapAsset.source.source().toString()),
+                originalSource: swAssetString,
+                replaceString: manifestString,
+                searchString: config.injectionPoint
+            });
+            compilation.updateAsset(sourcemapAssetName, new webpack.sources.RawSource(map));
+            compilation.updateAsset(config.swDest, new webpack.sources.RawSource(source));
+        } else {
+            // If there's no sourcemap associated with swDest, a simple string
+            // replacement will suffice.
+            compilation.updateAsset(config.swDest, new webpack.sources.RawSource(swAssetString.replace(config.injectionPoint, manifestString)));
+        }
+        if (compilation.getLogger) {
+            const logger = compilation.getLogger(this.constructor.name);
+            logger.info(`The service worker at ${config.swDest ?? ""} will precache ${sortedEntries.length} URLs, totaling ${prettyBytes(size)}.`);
+        }
+    }
+}
+
+exports.InjectManifest = InjectManifest;

package/dist/inject-manifest.d.ts

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

package/dist/inject-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-manifest.d.ts","sourceRoot":"","sources":["../src/inject-manifest.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAMnE,OAAO,OAAO,MAAM,SAAS,CAAC;AAU9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,cAAM,cAAc;IAClB,SAAS,CAAC,MAAM,EAAE,4BAA4B,CAAC;IAC/C,OAAO,CAAC,aAAa,CAAU;IAE/B;;OAEG;gBACS,MAAM,EAAE,4BAA4B;IAKhD;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;IAcxD;;;;OAIG;IACG,kBAAkB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,4BAA4B;;;;;IA6C/F;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;IA4BvC;;;;;OAKG;IACG,uBAAuB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAiChH;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;IAMxF;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BnG;;;;OAIG;IACG,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAqDjE;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/lib/child-compilation-plugin.d.ts

@@ -0,0 +1,21 @@
+import type { WebpackPluginInstance } from "webpack";
+import webpack from "webpack";
+export interface ChildCompilationPluginOptions {
+    src: string;
+    dest: string;
+    plugins?: WebpackPluginInstance[];
+}
+/**
+ * Compile a file by creating a child of the hooked compiler.
+ *
+ * @private
+ */
+export declare class ChildCompilationPlugin implements WebpackPluginInstance {
+    src: string;
+    dest: string;
+    plugins: WebpackPluginInstance[] | undefined;
+    constructor({ src, dest, plugins }: ChildCompilationPluginOptions);
+    apply(compiler: webpack.Compiler): void;
+    performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+}
+//# sourceMappingURL=child-compilation-plugin.d.ts.map

package/dist/lib/child-compilation-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-compilation-plugin.d.ts","sourceRoot":"","sources":["../../src/lib/child-compilation-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,OAAO,MAAM,SAAS,CAAC;AAI9B,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,qBAAqB;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAC;gBACjC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKjE,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ;IAO1B,uBAAuB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAiCjH"}

package/dist/lib/get-asset-hash.d.ts

@@ -0,0 +1,9 @@
+import type { Asset } from "webpack";
+/**
+ * @param asset
+ * @returns The MD5 hash of the asset's source.
+ *
+ * @private
+ */
+export declare function getAssetHash(asset: Asset): string | null;
+//# sourceMappingURL=get-asset-hash.d.ts.map

package/dist/lib/get-asset-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-asset-hash.d.ts","sourceRoot":"","sources":["../../src/lib/get-asset-hash.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CASxD"}

package/dist/lib/get-manifest-entries-from-compilation.d.ts

@@ -0,0 +1,7 @@
+import type { ManifestEntry, WebpackInjectManifestOptions } from "@serwist/build";
+import type { Compilation } from "webpack";
+export declare function getManifestEntriesFromCompilation(compilation: Compilation, config: WebpackInjectManifestOptions): Promise<{
+    size: number;
+    sortedEntries: ManifestEntry[];
+}>;
+//# sourceMappingURL=get-manifest-entries-from-compilation.d.ts.map

package/dist/lib/get-manifest-entries-from-compilation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-manifest-entries-from-compilation.d.ts","sourceRoot":"","sources":["../../src/lib/get-manifest-entries-from-compilation.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAe,aAAa,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAE/F,OAAO,KAAK,EAAgB,WAAW,EAAgB,MAAM,SAAS,CAAC;AA6KvE,wBAAsB,iCAAiC,CACrD,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,aAAa,EAAE,CAAA;CAAE,CAAC,CAgC3D"}

package/dist/lib/get-script-files-for-chunks.d.ts

@@ -0,0 +1,3 @@
+import type { Compilation } from "webpack";
+export declare function getScriptFilesForChunks(compilation: Compilation, chunkNames: Array<string>): Array<string>;
+//# sourceMappingURL=get-script-files-for-chunks.d.ts.map

package/dist/lib/get-script-files-for-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-script-files-for-chunks.d.ts","sourceRoot":"","sources":["../../src/lib/get-script-files-for-chunks.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,SAAS,CAAC;AAIzD,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CA0B1G"}

package/dist/lib/get-sourcemap-asset-name.d.ts

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

package/dist/lib/get-sourcemap-asset-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-sourcemap-asset-name.d.ts","sourceRoot":"","sources":["../../src/lib/get-sourcemap-asset-name.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiBtH"}