@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/asset/AssetModulesPlugin.js

@@ -5,35 +5,43 @@
 
 "use strict";
 
+const { RawSource } = require("webpack-sources");
+const HotUpdateChunk = require("../HotUpdateChunk");
 const {
 	ASSET_MODULE_TYPE,
 	ASSET_MODULE_TYPE_BYTES,
 	ASSET_MODULE_TYPE_INLINE,
 	ASSET_MODULE_TYPE_RESOURCE,
-	ASSET_MODULE_TYPE_SOURCE
+	ASSET_MODULE_TYPE_SOURCE,
+	ASSET_MODULE_TYPE_WEBMANIFEST
 } = require("../ModuleTypeConstants");
 const { compareModulesByFullName } = require("../util/comparators");
+const createHash = require("../util/createHash");
+const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
+const { PUBLIC_PATH_AUTO } = require("../util/publicPathPlaceholder");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("schema-utils").Schema} Schema */
 /** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrl} AssetGeneratorDataUrl */
 /** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
 /** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
-/** @typedef {import("../../declarations/WebpackOptions").FilenameTemplate} FilenameTemplate */
+/** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("./AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 
 /**
+ * Returns definition.
  * @param {string} name name of definitions
  * @returns {Schema} definition
  */
 const getSchema = (name) => {
-	const { definitions } = require("../../schemas/WebpackOptions.json");
+	const { definitions } =
+		/** @type {EXPECTED_ANY} */
+		(require("../../schemas/WebpackOptions.json"));
 
 	return {
 		definitions,
@@ -54,26 +62,35 @@ const getAssetSourceGenerator = memoize(() =>
 	require("./AssetSourceGenerator")
 );
 const getAssetBytesGenerator = memoize(() => require("./AssetBytesGenerator"));
-const getNormalModule = memoize(() => require("../NormalModule"));
+const getAssetModule = memoize(() => require("./AssetModule"));
+const getWebManifestParser = memoize(() => require("./WebManifestParser"));
+const getWebManifestGenerator = memoize(() =>
+	require("./WebManifestGenerator")
+);
 
 const type = ASSET_MODULE_TYPE;
+// Source type produced by `WebManifestGenerator` (its emitted, rewritten JSON).
+const WEBMANIFEST_SOURCE_TYPE = "webmanifest";
 const PLUGIN_NAME = "AssetModulesPlugin";
 
 /**
+ * Represents the asset modules plugin runtime component.
  * @typedef {object} AssetModulesPluginOptions
  * @property {boolean=} sideEffectFree
  */
 
 class AssetModulesPlugin {
 	/**
+	 * Creates an instance of AssetModulesPlugin.
 	 * @param {AssetModulesPluginOptions} options options
 	 */
 	constructor(options) {
+		/** @type {AssetModulesPluginOptions} */
 		this.options = options;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -81,7 +98,7 @@ class AssetModulesPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
-				const NormalModule = getNormalModule();
+				const AssetModule = getAssetModule();
 				for (const type of [
 					ASSET_MODULE_TYPE,
 					ASSET_MODULE_TYPE_BYTES,
@@ -91,18 +108,11 @@ class AssetModulesPlugin {
 				]) {
 					normalModuleFactory.hooks.createModuleClass
 						.for(type)
-						.tap(PLUGIN_NAME, (createData, _resolveData) => {
-							// TODO create the module via new AssetModule with its own properties
-							const module = new NormalModule(
-								/** @type {NormalModuleCreateData} */
-								(createData)
-							);
-							if (this.options.sideEffectFree) {
-								module.factoryMeta = { sideEffectFree: true };
-							}
-
-							return module;
-						});
+						.tap(
+							PLUGIN_NAME,
+							(createData, _resolveData) =>
+								new AssetModule(createData, this.options.sideEffectFree)
+						);
 				}
 
 				normalModuleFactory.hooks.createParser
@@ -222,7 +232,7 @@ class AssetModulesPlugin {
 								}
 							}
 
-							/** @type {undefined | FilenameTemplate} */
+							/** @type {undefined | AssetModuleFilename} */
 							let filename;
 							/** @type {undefined | RawPublicPath} */
 							let publicPath;
@@ -242,7 +252,8 @@ class AssetModulesPlugin {
 								filename,
 								publicPath,
 								outputPath,
-								generatorOptions.emit !== false
+								generatorOptions.emit !== false,
+								compilation
 							);
 						});
 				}
@@ -278,7 +289,9 @@ class AssetModulesPlugin {
 									module,
 									chunk.runtime
 								);
-								const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+								const buildInfo = /** @type {AssetModuleBuildInfo} */ (
+									module.buildInfo
+								);
 								const data =
 									/** @type {NonNullable<CodeGenerationResult["data"]>} */
 									(codeGenResult.data);
@@ -315,7 +328,8 @@ class AssetModulesPlugin {
 												runtimeTemplate,
 												chunkGraph
 											},
-											contentHash
+											contentHash,
+											fullContentHash
 										);
 									entryFilename = filename;
 									entryInfo = assetInfo;
@@ -352,6 +366,83 @@ class AssetModulesPlugin {
 					return result;
 				});
 
+				// A Web App Manifest (`asset/webmanifest`, gated on `experiments.html`)
+				// parses/emits like an asset, but its icon URLs are rewritten in place
+				// and the emitted file needs its own per-file public-path resolution.
+				if (compilation.options.experiments.html) {
+					normalModuleFactory.hooks.createParser
+						.for(ASSET_MODULE_TYPE_WEBMANIFEST)
+						.tap(PLUGIN_NAME, () => {
+							const WebManifestParser = getWebManifestParser();
+
+							return new WebManifestParser();
+						});
+					normalModuleFactory.hooks.createGenerator
+						.for(ASSET_MODULE_TYPE_WEBMANIFEST)
+						.tap(PLUGIN_NAME, () => {
+							const WebManifestGenerator = getWebManifestGenerator();
+
+							return new WebManifestGenerator(compilation.moduleGraph);
+						});
+
+					compilation.hooks.renderManifest.tap(
+						PLUGIN_NAME,
+						(result, options) => {
+							const { chunk, codeGenerationResults } = options;
+							if (chunk instanceof HotUpdateChunk) return result;
+							const { chunkGraph, outputOptions } = compilation;
+							const modules =
+								chunkGraph.getOrderedChunkModulesIterableBySourceType(
+									chunk,
+									WEBMANIFEST_SOURCE_TYPE,
+									compareModulesByFullName(compilation.compiler)
+								);
+							if (!modules) return result;
+							for (const module of modules) {
+								const codeGenResult = codeGenerationResults.get(
+									module,
+									chunk.runtime
+								);
+								const source = codeGenResult.sources.get(
+									WEBMANIFEST_SOURCE_TYPE
+								);
+								if (!source) continue;
+								const filename = /** @type {string} */ (
+									codeGenResult.data && codeGenResult.data.get("filename")
+								);
+								if (!filename) continue;
+								// Icon URLs resolve relative to the manifest's own location.
+								const undoPath = getUndoPath(
+									filename,
+									/** @type {string} */ (outputOptions.path),
+									false
+								);
+								const content = source
+									.source()
+									.toString()
+									.split(PUBLIC_PATH_AUTO)
+									.join(undoPath);
+								const hash = createHash(outputOptions.hashFunction || "md4");
+								hash.update(content);
+								const contentHash = /** @type {string} */ (
+									hash.digest(outputOptions.hashDigest || "hex")
+								).slice(0, outputOptions.hashDigestLength || 20);
+								result.push({
+									render: () => new RawSource(content),
+									filename,
+									info: { immutable: true },
+									auxiliary: true,
+									identifier: `webManifestModule${chunkGraph.getModuleId(
+										module
+									)}|${filename}`,
+									hash: contentHash
+								});
+							}
+							return result;
+						}
+					);
+				}
+
 				compilation.hooks.prepareModuleExecution.tap(
 					PLUGIN_NAME,
 					(options, context) => {

package/lib/asset/AssetParser.js

@@ -10,7 +10,7 @@ const Parser = require("../Parser");
 /** @typedef {import("../../declarations/WebpackOptions").AssetParserDataUrlOptions} AssetParserDataUrlOptions */
 /** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("./AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
@@ -19,6 +19,7 @@ const Parser = require("../Parser");
 
 class AssetParser extends Parser {
 	/**
+	 * Creates an instance of AssetParser.
 	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
 	 */
 	constructor(dataUrlCondition) {
@@ -28,6 +29,7 @@ class AssetParser extends Parser {
 	}
 
 	/**
+	 * Parses the provided source and updates the parser state.
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
 	 * @returns {ParserState} the parser state
@@ -38,7 +40,7 @@ class AssetParser extends Parser {
 		}
 
 		const buildInfo =
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(state.module.buildInfo);
 		buildInfo.strict = true;
 		const buildMeta =

package/lib/asset/AssetSourceGenerator.js

@@ -9,10 +9,11 @@ const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const {
+	ASSET_URL_TYPE,
+	ASSET_URL_TYPES,
 	CSS_TYPE,
-	CSS_URL_TYPE,
-	CSS_URL_TYPES,
-	JAVASCRIPT_AND_CSS_URL_TYPES,
+	HTML_TYPE,
+	JAVASCRIPT_AND_ASSET_URL_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES,
 	NO_TYPES
@@ -29,15 +30,18 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 
 class AssetSourceGenerator extends Generator {
 	/**
+	 * Creates an instance of AssetSourceGenerator.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 */
 	constructor(moduleGraph) {
 		super();
 
+		/** @type {ModuleGraph} */
 		this._moduleGraph = moduleGraph;
 	}
 
 	/**
+	 * Generates generated code for this runtime module.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
@@ -76,7 +80,7 @@ class AssetSourceGenerator extends Generator {
 				}
 				return new RawSource(sourceContent);
 			}
-			case CSS_URL_TYPE: {
+			case ASSET_URL_TYPE: {
 				if (!originalSource) {
 					return null;
 				}
@@ -96,6 +100,7 @@ class AssetSourceGenerator extends Generator {
 	}
 
 	/**
+	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -114,6 +119,7 @@ class AssetSourceGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the reason this module cannot be concatenated, when one exists.
 	 * @param {NormalModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
@@ -123,6 +129,7 @@ class AssetSourceGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -140,10 +147,13 @@ class AssetSourceGenerator extends Generator {
 		}
 
 		if (sourceTypes.size > 0) {
-			if (sourceTypes.has(JAVASCRIPT_TYPE) && sourceTypes.has(CSS_TYPE)) {
-				return JAVASCRIPT_AND_CSS_URL_TYPES;
-			} else if (sourceTypes.has(CSS_TYPE)) {
-				return CSS_URL_TYPES;
+			if (
+				sourceTypes.has(JAVASCRIPT_TYPE) &&
+				(sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE))
+			) {
+				return JAVASCRIPT_AND_ASSET_URL_TYPES;
+			} else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) {
+				return ASSET_URL_TYPES;
 			}
 			return JAVASCRIPT_TYPES;
 		}
@@ -152,6 +162,14 @@ class AssetSourceGenerator extends Generator {
 	}
 
 	/**
+	 * @returns {boolean} whether getTypes() depends on the module's incoming connections
+	 */
+	getTypesDependOnIncomingConnections() {
+		return true;
+	}
+
+	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {NormalModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module

package/lib/asset/AssetSourceParser.js

@@ -14,6 +14,7 @@ const Parser = require("../Parser");
 
 class AssetSourceParser extends Parser {
 	/**
+	 * Parses the provided source and updates the parser state.
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
 	 * @returns {ParserState} the parser state

package/lib/asset/RawDataUrlModule.js

@@ -29,13 +29,14 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Buffer | undefined, string, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Buffer | undefined, string, string]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 class RawDataUrlModule extends Module {
 	/**
+	 * Creates an instance of RawDataUrlModule.
 	 * @param {string} url raw url
 	 * @param {string} identifier unique identifier
 	 * @param {string=} readableIdentifier readable identifier
@@ -53,6 +54,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -60,6 +62,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -67,6 +70,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -78,6 +82,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @returns {string} a user readable identifier of the module
 	 */
@@ -88,6 +93,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Checks whether the module needs to be rebuilt for the current build state.
 	 * @param {NeedBuildContext} context context info
 	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
@@ -97,6 +103,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -113,6 +120,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -138,6 +146,7 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -148,29 +157,30 @@ class RawDataUrlModule extends Module {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.urlBuffer);
-		write(this.identifierStr);
-		write(this.readableIdentifierStr);
+		context
+			.write(this.urlBuffer)
+			.write(this.identifierStr)
+			.write(this.readableIdentifierStr);
 
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.urlBuffer = read();
-		this.identifierStr = read();
-		this.readableIdentifierStr = read();
+		this.urlBuffer = context.read();
+		const c1 = context.rest;
+		this.identifierStr = c1.read();
+		const c2 = c1.rest;
+		this.readableIdentifierStr = c2.read();
 
-		super.deserialize(context);
+		super.deserialize(c2.rest);
 	}
 }
 

package/lib/asset/WebManifestGenerator.js

@@ -0,0 +1,164 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { RawSource, ReplaceSource } = require("webpack-sources");
+const { ASSET_URL_TYPE } = require("../ModuleSourceTypeConstants");
+const createHash = require("../util/createHash");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const { PUBLIC_PATH_AUTO } = require("../util/publicPathPlaceholder");
+const AssetGenerator = require("./AssetGenerator");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compilation").DependencyConstructor} DependencyConstructor */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").SourceType} SourceType */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+const WEBMANIFEST_TYPE = "webmanifest";
+const WEBMANIFEST_TYPES = new Set([WEBMANIFEST_TYPE]);
+const WEBMANIFEST_AND_ASSET_URL_TYPES = new Set([
+	WEBMANIFEST_TYPE,
+	ASSET_URL_TYPE
+]);
+
+/**
+ * A Web App Manifest is a "typed asset": a variant of `AssetGenerator` (reusing
+ * its filename/hash and `ASSET_URL_TYPE` machinery) whose emitted content is the
+ * raw JSON with each icon `src` rewritten to its bundled asset URL. The manifest
+ * itself is emitted — with its own URL exposed to the referencing
+ * `<link rel="manifest">` — by `AssetModulesPlugin`'s `renderManifest`, which
+ * resolves the per-file public path (like the CSS/HTML plugins).
+ */
+class WebManifestGenerator extends AssetGenerator {
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 */
+	constructor(moduleGraph) {
+		super(moduleGraph, undefined, undefined, undefined, undefined, true);
+	}
+
+	/**
+	 * Returns the source types available for this module.
+	 * @param {NormalModule} module fresh module
+	 * @returns {SourceTypes} available types (do not mutate)
+	 */
+	getTypes(module) {
+		// Expose the manifest's own URL only when it is referenced (from HTML).
+		const connections = this._moduleGraph.getIncomingConnections(module);
+		const referenced = !connections[Symbol.iterator]().next().done;
+		return referenced ? WEBMANIFEST_AND_ASSET_URL_TYPES : WEBMANIFEST_TYPES;
+	}
+
+	/**
+	 * Returns the estimated size for the requested source type.
+	 * @param {NormalModule} module the module
+	 * @param {SourceType=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		return originalSource ? originalSource.size() : 0;
+	}
+
+	/**
+	 * Rewrites each icon `src` in the raw manifest to its emitted asset URL.
+	 * @param {NormalModule} module the manifest module
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {string} the rewritten manifest content
+	 */
+	_rewrite(module, generateContext) {
+		const originalSource = /** @type {Source} */ (module.originalSource());
+		const source = new ReplaceSource(originalSource);
+		// `HtmlSourceDependency.Template` only reads `moduleGraph`/`runtimeTemplate`/
+		// `codeGenerationResults`; the rest is filled to satisfy the context shape.
+		/** @type {DependencyTemplateContext} */
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults:
+				/** @type {CodeGenerationResults} */
+				(generateContext.codeGenerationResults),
+			initFragments: [],
+			chunkInitFragments: []
+		};
+		for (const dependency of module.dependencies) {
+			const constructor = /** @type {DependencyConstructor} */ (
+				dependency.constructor
+			);
+			const template = templateContext.dependencyTemplates.get(constructor);
+			if (!template) {
+				throw new Error(
+					`No template for dependency: ${dependency.constructor.name}`
+				);
+			}
+			template.apply(dependency, source, templateContext);
+		}
+		return /** @type {string} */ (source.source());
+	}
+
+	/**
+	 * Generates generated code for this runtime module.
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generate(module, generateContext) {
+		if (!module.originalSource()) return new RawSource("");
+
+		const { type, getData } = generateContext;
+		const content = this._rewrite(module, generateContext);
+
+		// Hash the *rewritten* content (so the filename tracks the icons) and reuse
+		// the asset filename machinery, so a plain (icon-less) manifest emits like a
+		// plain asset (`output.assetModuleFilename`, `[name]`, `[ext]`).
+		const outputOptions = generateContext.runtimeTemplate.outputOptions;
+		const hash = createHash(outputOptions.hashFunction);
+		if (outputOptions.hashSalt) hash.update(outputOptions.hashSalt);
+		hash.update(content);
+		const fullContentHash = /** @type {string} */ (
+			hash.digest(outputOptions.hashDigest)
+		);
+		const contentHash = nonNumericOnlyHash(
+			fullContentHash,
+			/** @type {number} */ (outputOptions.hashDigestLength)
+		);
+		const { filename, assetInfo } = AssetGenerator.getFilenameWithInfo(
+			module,
+			{ filename: undefined, outputPath: undefined },
+			generateContext,
+			contentHash,
+			fullContentHash
+		);
+
+		const data = getData ? getData() : undefined;
+		if (data) {
+			data.set("filename", filename);
+			data.set("assetInfo", assetInfo);
+			if (type === ASSET_URL_TYPE) {
+				data.set("url", {
+					...data.get("url"),
+					[ASSET_URL_TYPE]: PUBLIC_PATH_AUTO + filename
+				});
+			}
+		}
+
+		return type === ASSET_URL_TYPE ? null : new RawSource(content);
+	}
+}
+
+module.exports = WebManifestGenerator;