@serwist/webpack-plugin 9.5.6 → 9.5.8

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-import { InjectManifest } from "./inject-manifest.js";
-import type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved } from "./lib/types.js";
-import { validateInjectManifestOptions } from "./lib/validator.js";
-export { InjectManifest, validateInjectManifestOptions };
-export type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,EAAE,cAAc,EAAE,6BAA6B,EAAE,CAAC;AACzD,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}

package/dist/index.internal.d.ts

@@ -1,4 +0,0 @@
-import { ChildCompilationPlugin } from "./lib/child-compilation-plugin.js";
-import { relativeToOutputPath } from "./lib/relative-to-output-path.js";
-export { ChildCompilationPlugin, relativeToOutputPath };
-//# sourceMappingURL=index.internal.d.ts.map

package/dist/index.internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.internal.d.ts","sourceRoot":"","sources":["../src/index.internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/index.internal.js

@@ -1,21 +0,0 @@
-import { p as performChildCompilation, r as relativeToOutputPath } from './chunks/relative-to-output-path.js';
-import 'node:path';
-import '@serwist/utils';
-
-class ChildCompilationPlugin {
-    src;
-    dest;
-    plugins;
-    constructor({ src, dest, plugins }){
-        this.src = src;
-        this.dest = dest;
-        this.plugins = plugins;
-    }
-    apply(compiler) {
-        compiler.hooks.make.tapPromise(this.constructor.name, (compilation)=>performChildCompilation(compiler, compilation, this.constructor.name, this.src, relativeToOutputPath(compilation, this.dest), this.plugins).catch((error)=>{
-                compilation.errors.push(error);
-            }));
-    }
-}
-
-export { ChildCompilationPlugin, relativeToOutputPath };

package/dist/index.js

@@ -1,281 +0,0 @@
-import path from 'node:path';
-import { transformManifest, getSourceMapURL, escapeRegExp, replaceAndUpdateSourceMap } from '@serwist/build';
-import { toUnix } from '@serwist/utils';
-import prettyBytes from 'pretty-bytes';
-import crypto from 'node:crypto';
-import { r as relativeToOutputPath, p as performChildCompilation } from './chunks/relative-to-output-path.js';
-import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
-
-const getAssetHash = (asset)=>{
-    if (asset.info?.immutable) {
-        return null;
-    }
-    return crypto.createHash("md5").update(asset.source.source()).digest("hex");
-};
-
-const resolveWebpackURL = (publicPath, ...paths)=>{
-    if (publicPath === "auto") {
-        return paths.join("");
-    }
-    return [
-        publicPath,
-        ...paths
-    ].join("");
-};
-
-const checkConditions = (asset, compilation, conditions = [])=>{
-    const matchPart = compilation.compiler.webpack.ModuleFilenameHelpers.matchPart;
-    for (const condition of conditions){
-        if (typeof condition === "function") {
-            if (condition({
-                asset,
-                compilation
-            })) {
-                return true;
-            }
-        } else if (matchPart(asset.name, condition)) {
-            return true;
-        }
-    }
-    return false;
-};
-const getNamesOfAssetsInChunkOrGroup = (compilation, chunkOrGroup)=>{
-    const chunkGroup = compilation.namedChunkGroups?.get(chunkOrGroup);
-    if (chunkGroup) {
-        const assetNames = [];
-        for (const chunk of chunkGroup.chunks){
-            assetNames.push(...getNamesOfAssetsInChunk(chunk));
-        }
-        return assetNames;
-    }
-    const chunk = compilation.namedChunks?.get(chunkOrGroup);
-    if (chunk) {
-        return getNamesOfAssetsInChunk(chunk);
-    }
-    return null;
-};
-const getNamesOfAssetsInChunk = (chunk)=>{
-    const assetNames = [];
-    assetNames.push(...chunk.files);
-    if (chunk.auxiliaryFiles) {
-        assetNames.push(...chunk.auxiliaryFiles);
-    }
-    return assetNames;
-};
-const filterAssets = (compilation, config)=>{
-    const filteredAssets = new Set();
-    const assets = compilation.getAssets();
-    const allowedAssetNames = new Set();
-    if (Array.isArray(config.chunks)) {
-        for (const name of config.chunks){
-            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){
-            const assetsInChunkOrGroup = getNamesOfAssetsInChunkOrGroup(compilation, name);
-            if (assetsInChunkOrGroup) {
-                for (const assetName of assetsInChunkOrGroup){
-                    deniedAssetNames.add(assetName);
-                }
-            }
-        }
-    }
-    for (const asset of assets){
-        if (deniedAssetNames.has(asset.name)) {
-            continue;
-        }
-        if (Array.isArray(config.chunks) && !allowedAssetNames.has(asset.name)) {
-            continue;
-        }
-        const isExcluded = checkConditions(asset, compilation, config.exclude);
-        if (isExcluded) {
-            continue;
-        }
-        const isIncluded = !Array.isArray(config.include) || checkConditions(asset, compilation, config.include);
-        if (!isIncluded) {
-            continue;
-        }
-        filteredAssets.add(asset);
-    }
-    return filteredAssets;
-};
-const getManifestEntriesFromCompilation = async (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 transformManifest({
-        fileDetails,
-        additionalPrecacheEntries: config.additionalPrecacheEntries,
-        dontCacheBustURLsMatching: config.dontCacheBustURLsMatching,
-        manifestTransforms: config.manifestTransforms,
-        maximumFileSizeToCacheInBytes: config.maximumFileSizeToCacheInBytes,
-        modifyURLPrefix: config.modifyURLPrefix,
-        transformParam: compilation,
-        disablePrecacheManifest: config.disablePrecacheManifest
-    });
-    for (const warning of warnings){
-        compilation.warnings.push(new Error(warning));
-    }
-    const sortedEntries = manifestEntries?.sort((a, b)=>a.url === b.url ? 0 : a.url > b.url ? 1 : -1);
-    return {
-        size,
-        sortedEntries
-    };
-};
-
-const getSourcemapAssetName = (compilation, swContents, swDest)=>{
-    const url = getSourceMapURL(swContents);
-    if (url) {
-        const swAssetDirname = path.dirname(swDest);
-        const sourcemapURLAssetName = path.normalize(path.join(swAssetDirname, url));
-        if (compilation.getAsset(sourcemapURLAssetName)) {
-            return sourcemapURLAssetName;
-        }
-    }
-    return undefined;
-};
-
-const validateInjectManifestOptions = async (input)=>{
-    const result = await (await import('./chunks/schema.js')).injectManifestOptions.spa(input, {
-        error: validationErrorMap
-    });
-    if (!result.success) {
-        throw new SerwistConfigError({
-            moduleName: "@serwist/webpack-plugin",
-            message: JSON.stringify(result.error.format(), null, 2)
-        });
-    }
-    return result.data;
-};
-
-const _generatedAssetNames = new Set();
-class InjectManifest {
-    config;
-    alreadyCalled;
-    webpack;
-    constructor(config){
-        this.config = config;
-        this.alreadyCalled = false;
-        this.webpack = null;
-    }
-    propagateWebpackConfig(compiler) {
-        this.webpack = compiler.webpack;
-        const parsedSwSrc = path.parse(this.config.swSrc);
-        this.config = {
-            swDest: `${parsedSwSrc.name}.js`,
-            ...this.config
-        };
-    }
-    async getManifestEntries(compilation, config) {
-        if (config.disablePrecacheManifest) {
-            return {
-                size: 0,
-                sortedEntries: undefined,
-                manifestString: "undefined"
-            };
-        }
-        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;
-        }
-        config.exclude.push(({ asset })=>_generatedAssetNames.has(asset.name));
-        const { size, sortedEntries } = await getManifestEntriesFromCompilation(compilation, config);
-        let manifestString = JSON.stringify(sortedEntries);
-        if (this.config.compileSrc && !(compilation.options?.devtool === "eval-cheap-source-map" && compilation.options.optimization?.minimize)) {
-            manifestString = manifestString.replace(/"/g, `'`);
-        }
-        return {
-            size,
-            sortedEntries,
-            manifestString
-        };
-    }
-    apply(compiler) {
-        this.propagateWebpackConfig(compiler);
-        compiler.hooks.make.tapPromise(this.constructor.name, (compilation)=>this.handleMake(compiler, compilation).catch((error)=>{
-                compilation.errors.push(error);
-            }));
-        const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = this.webpack.Compilation;
-        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation)=>{
-            compilation.hooks.processAssets.tapPromise({
-                name: this.constructor.name,
-                stage: PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 10
-            }, ()=>this.addAssets(compilation).catch((error)=>{
-                    compilation.errors.push(error);
-                }));
-        });
-    }
-    addSrcToAssets(compiler, compilation) {
-        const source = compiler.inputFileSystem.readFileSync(this.config.swSrc);
-        compilation.emitAsset(this.config.swDest, new this.webpack.sources.RawSource(source));
-    }
-    async handleMake(compiler, compilation) {
-        this.config = await validateInjectManifestOptions(this.config);
-        this.config.swDest = relativeToOutputPath(compilation, this.config.swDest);
-        _generatedAssetNames.add(this.config.swDest);
-        if (this.config.compileSrc) {
-            await performChildCompilation(compiler, compilation, this.constructor.name, this.config.swSrc, this.config.swDest, this.config.webpackCompilationPlugins);
-        } else {
-            this.addSrcToAssets(compiler, compilation);
-            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."));
-            }
-        }
-    }
-    async addAssets(compilation) {
-        const config = Object.assign({}, this.config);
-        const { size, sortedEntries, manifestString } = await this.getManifestEntries(compilation, config);
-        compilation.fileDependencies.add(path.resolve(config.swSrc));
-        const swAsset = compilation.getAsset(config.swDest);
-        const swAssetString = swAsset.source.source().toString();
-        const globalRegexp = new RegExp(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 replaceAndUpdateSourceMap({
-                jsFilename: toUnix(config.swDest),
-                originalMap: JSON.parse(sourcemapAsset.source.source().toString()),
-                originalSource: swAssetString,
-                replaceString: manifestString,
-                searchString: config.injectionPoint
-            });
-            compilation.updateAsset(sourcemapAssetName, new this.webpack.sources.RawSource(map));
-            compilation.updateAsset(config.swDest, new this.webpack.sources.RawSource(source));
-        } else {
-            compilation.updateAsset(config.swDest, new this.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 ?? 0} URLs, totaling ${prettyBytes(size)}.`);
-        }
-    }
-}
-
-export { InjectManifest, validateInjectManifestOptions };

package/dist/index.schema.d.ts

@@ -1,3 +0,0 @@
-import { injectManifestOptions, injectPartial, webpackPartial } from "./lib/schema.js";
-export { webpackPartial, injectPartial as injectManifestPartial, injectManifestOptions };
-//# sourceMappingURL=index.schema.d.ts.map

package/dist/index.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,aAAa,IAAI,qBAAqB,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.schema.js

@@ -1,3 +0,0 @@
-export { injectManifestOptions, injectPartial as injectManifestPartial, webpackPartial } from './chunks/schema.js';
-import '@serwist/build/schema';
-import 'zod';

package/dist/inject-manifest.d.ts

@@ -1,72 +0,0 @@
-import type { Compiler } from "webpack";
-import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./lib/types.js";
-/**
- * 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: '...',
- * });
- * ```
- */
-export declare class InjectManifest {
-    protected config: InjectManifestOptionsComplete;
-    private alreadyCalled;
-    private webpack;
-    /**
-     * Creates an instance of InjectManifest.
-     */
-    constructor(config: InjectManifestOptions);
-    /**
-     * @param compiler default compiler object passed from webpack
-     *
-     * @private
-     */
-    private propagateWebpackConfig;
-    /**
-     * `getManifestEntriesFromCompilation` with a few additional checks.
-     *
-     * @private
-     */
-    private getManifestEntries;
-    /**
-     * @param compiler default compiler object passed from webpack
-     *
-     * @private
-     */
-    apply(compiler: Compiler): void;
-    /**
-     * @param compiler The webpack parent compiler.
-     * @param compilation The webpack compilation.
-     *
-     * @private
-     */
-    private addSrcToAssets;
-    /**
-     * @param compiler The webpack parent compiler.
-     * @param compilation The webpack compilation.
-     *
-     * @private
-     */
-    private handleMake;
-    /**
-     * @param compilation The webpack compilation.
-     *
-     * @private
-     */
-    private addAssets;
-}
-//# sourceMappingURL=inject-manifest.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"inject-manifest.d.ts","sourceRoot":"","sources":["../src/inject-manifest.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAe,QAAQ,EAAoC,MAAM,SAAS,CAAC;AAKvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAO3F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,MAAM,EAAE,6BAA6B,CAAC;IAChD,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAEhC;;OAEG;gBACS,MAAM,EAAE,qBAAqB;IAQzC;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAa9B;;;;OAIG;YACW,kBAAkB;IAuChC;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IA6B/B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAKtB;;;;;OAKG;YACW,UAAU;IAwBxB;;;;OAIG;YACW,SAAS;CAiDxB"}

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

@@ -1,24 +0,0 @@
-import type { Compiler, WebpackPluginInstance } 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);
-    /**
-     * @param compiler default compiler object passed from webpack
-     *
-     * @private
-     */
-    apply(compiler: Compiler): void;
-}
-//# sourceMappingURL=child-compilation-plugin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"child-compilation-plugin.d.ts","sourceRoot":"","sources":["../../src/lib/child-compilation-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAgB,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAI7E,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;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAczB"}

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

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

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

@@ -1 +0,0 @@
-{"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,eAAO,MAAM,YAAY,GAAI,OAAO,KAAK,KAAG,MAAM,GAAG,IASpD,CAAC"}

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

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

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

@@ -1 +0,0 @@
-{"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,MAAM,gBAAgB,CAAC;AAEjE,OAAO,KAAK,EAAgB,WAAW,EAAgB,MAAM,SAAS,CAAC;AAIvE,OAAO,KAAK,EAAyB,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAiKvF,eAAO,MAAM,iCAAiC,GAC5C,aAAa,WAAW,EACxB,QAAQ,6BAA6B,KACpC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,aAAa,EAAE,GAAG,SAAS,CAAA;CAAE,CAiCtE,CAAC"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-script-files-for-chunks.d.ts","sourceRoot":"","sources":["../../src/lib/get-script-files-for-chunks.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,SAAS,CAAC;AAIzD,eAAO,MAAM,uBAAuB,GAAI,aAAa,WAAW,EAAE,YAAY,MAAM,EAAE,KAAG,MAAM,EAwB9F,CAAC"}

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

@@ -1,20 +0,0 @@
-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 const 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

@@ -1 +0,0 @@
-{"version":3,"file":"get-sourcemap-asset-name.d.ts","sourceRoot":"","sources":["../../src/lib/get-sourcemap-asset-name.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,WAAW,EAAE,YAAY,MAAM,EAAE,QAAQ,MAAM,KAAG,MAAM,GAAG,SAgB7G,CAAC"}

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

@@ -1,16 +0,0 @@
-import type { Compilation, Compiler } from "webpack";
-import type { WebpackPlugin } from "./types.js";
-/**
- * Perform a child compilation.
- *
- * @param compiler The parent webpack compiler.
- * @param compilation The webpack compilation.
- * @param name The name of the child compiler.
- * @param src The source file. Should be absolute.
- * @param dest The destination file. Should be relative to the compilation.
- * @param plugins Additional webpack plugins.
- *
- * @private
- */
-export declare const performChildCompilation: (compiler: Compiler, compilation: Compilation, name: string, src: string, dest: string, plugins: WebpackPlugin[] | undefined) => Promise<void>;
-//# sourceMappingURL=perform-child-compilation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"perform-child-compilation.d.ts","sourceRoot":"","sources":["../../src/lib/perform-child-compilation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAU,QAAQ,EAClB,aAAa,WAAW,EACxB,MAAM,MAAM,EACZ,KAAK,MAAM,EACX,MAAM,MAAM,EACZ,SAAS,aAAa,EAAE,GAAG,SAAS,kBAuBrC,CAAC"}

package/dist/lib/relative-to-output-path.d.ts

@@ -1,12 +0,0 @@
-import type { Compilation } from "webpack";
-/**
- * @param compilation The webpack compilation.
- * @param originalPath The original path value.
- *
- * @returns If path was not absolute, the returns path as-is.
- * Otherwise, returns path relative to the compilation's output path.
- *
- * @private
- */
-export declare const relativeToOutputPath: (compilation: Compilation, originalPath: string) => string;
-//# sourceMappingURL=relative-to-output-path.d.ts.map

package/dist/lib/relative-to-output-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relative-to-output-path.d.ts","sourceRoot":"","sources":["../../src/lib/relative-to-output-path.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,aAAa,WAAW,EAAE,cAAc,MAAM,KAAG,MAQrF,CAAC"}

package/dist/lib/resolve-webpack-url.d.ts

@@ -1,13 +0,0 @@
-/**
- * Resolves a url in the way that webpack would (with string concatenation)
- *
- * Use publicPath + filePath instead of url.resolve(publicPath, filePath) see:
- * https://webpack.js.org/configuration/output/#output-publicpath
- *
- * @param publicPath The publicPath value from webpack's compilation.
- * @param paths File paths to join
- * @returns Joined file path
- * @private
- */
-export declare const resolveWebpackURL: (publicPath: string, ...paths: string[]) => string;
-//# sourceMappingURL=resolve-webpack-url.d.ts.map

package/dist/lib/resolve-webpack-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-webpack-url.d.ts","sourceRoot":"","sources":["../../src/lib/resolve-webpack-url.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,EAAE,GAAG,OAAO,MAAM,EAAE,KAAG,MAO1E,CAAC"}

package/dist/lib/schema.d.ts

@@ -1,86 +0,0 @@
-import { z } from "zod";
-export declare const webpackPartial: z.ZodObject<{
-    chunks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodPipe<z.ZodCustom<z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>, z.ZodTransform<(args_0: any) => boolean, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>>]>>>;
-    excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodPipe<z.ZodCustom<z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>, z.ZodTransform<(args_0: any) => boolean, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>>]>>>;
-}, z.core.$strict>;
-export declare const injectPartial: z.ZodObject<{
-    compileSrc: z.ZodDefault<z.ZodBoolean>;
-    swDest: z.ZodOptional<z.ZodString>;
-    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-}, z.core.$strict>;
-export declare const injectManifestOptions: z.ZodObject<{
-    compileSrc: z.ZodDefault<z.ZodBoolean>;
-    swDest: z.ZodOptional<z.ZodString>;
-    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-    injectionPoint: z.ZodDefault<z.ZodString>;
-    swSrc: z.ZodString;
-    chunks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodPipe<z.ZodCustom<z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>, z.ZodTransform<(args_0: any) => boolean, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>>]>>>;
-    excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodPipe<z.ZodCustom<z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>, z.ZodTransform<(args_0: any) => boolean, z.core.$InferInnerFunctionType<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>>>]>>>;
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strict>]>>>;
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    dontCacheBustURLsMatching: z.ZodOptional<z.ZodCustom<RegExp, RegExp>>;
-    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>, z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>, z.ZodTransform<z.core.$InferOuterFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>, z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>>>>;
-    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
-    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strict>;
-//# sourceMappingURL=schema.d.ts.map

package/dist/lib/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lib/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,cAAc;;;;;kBAKzB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;kBAIxB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhC,CAAC"}