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

package/lib/asset/AssetGenerator.js

@@ -10,27 +10,35 @@ const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const {
-	ASSET_AND_CSS_URL_TYPES,
-	ASSET_AND_JAVASCRIPT_AND_CSS_URL_TYPES,
+	ASSET_AND_ASSET_URL_TYPES,
+	ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES,
 	ASSET_AND_JAVASCRIPT_TYPES,
 	ASSET_TYPES,
+	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
 } = require("../ModuleSourceTypeConstants");
-const { ASSET_MODULE_TYPE } = require("../ModuleTypeConstants");
+const {
+	ASSET_MODULE_TYPE,
+	ASSET_MODULE_TYPE_WEBMANIFEST
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const CssUrlDependency = require("../dependencies/CssUrlDependency");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const {
+	PUBLIC_PATH_AUTO,
+	PUBLIC_PATH_FULL_HASH
+} = require("../util/publicPathPlaceholder");
+const { updateHashFromSource } = require("../util/source");
 
-const getMimeTypes = memoize(() => require("mime-types"));
+const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrlOptions} AssetGeneratorDataUrlOptions */
@@ -40,24 +48,42 @@ const getMimeTypes = memoize(() => require("mime-types"));
 /** @typedef {import("../../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").NameForCondition} NameForCondition */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("./AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../dependencies/URLDependency")} URLDependency */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @typedef {(source: string | Buffer, context: { filename: string, module: Module }) => string} DataUrlFunction */
 
+// slash separating a module type from its subtype (`css/auto` -> `css`)
+const TYPE_SEPARATOR_CHAR_CODE = 47;
+
+/**
+ * Whether a module type's prefix (the part before `/`) equals `prefix`, without
+ * allocating the substring `type.split("/")[0]` would produce.
+ * @param {string} type module type (e.g. `javascript/auto`)
+ * @param {string} prefix expected prefix (e.g. `javascript`)
+ * @returns {boolean} whether the type's prefix equals `prefix`
+ */
+const typePrefixEquals = (type, prefix) =>
+	type.startsWith(prefix) &&
+	(type.length === prefix.length ||
+		type.charCodeAt(prefix.length) === TYPE_SEPARATOR_CHAR_CODE);
+
 /**
+ * Merges maybe arrays.
  * @template T
  * @template U
  * @param {null | string | T[] | Set<T> | undefined} a a
@@ -75,6 +101,7 @@ const mergeMaybeArrays = (a, b) => {
 };
 
 /**
+ * Merges the provided values into a single result.
  * @param {AssetInfo} a a
  * @param {AssetInfo} b b
  * @returns {AssetInfo} object
@@ -115,6 +142,7 @@ const mergeAssetInfo = (a, b) => {
 };
 
 /**
+ * Merges related info.
  * @param {NonNullable<AssetInfo["related"]>} a a
  * @param {NonNullable<AssetInfo["related"]>} b b
  * @returns {NonNullable<AssetInfo["related"]>} object
@@ -131,6 +159,7 @@ const mergeRelatedInfo = (a, b) => {
 };
 
 /**
+ * Encodes the provided encoding.
  * @param {"base64" | false} encoding encoding
  * @param {Source} source source
  * @returns {string} encoded data
@@ -147,14 +176,10 @@ const encodeDataUri = (encoding, source) => {
 		case false: {
 			const content = source.source();
 
-			if (typeof content !== "string") {
-				encodedContent = content.toString("utf8");
-			}
+			encodedContent =
+				typeof content === "string" ? content : content.toString("utf8");
 
-			encodedContent = encodeURIComponent(
-				/** @type {string} */
-				(encodedContent)
-			).replace(
+			encodedContent = encodeURIComponent(encodedContent).replace(
 				/[!'()*]/g,
 				(character) =>
 					`%${/** @type {number} */ (character.codePointAt(0)).toString(16)}`
@@ -169,6 +194,7 @@ const encodeDataUri = (encoding, source) => {
 };
 
 /**
+ * Decodes data uri content.
  * @param {"base64" | false} encoding encoding
  * @param {string} content content
  * @returns {Buffer} decoded content
@@ -182,9 +208,9 @@ const decodeDataUriContent = (encoding, content) => {
 
 	// If we can't decode return the original body
 	try {
-		return Buffer.from(decodeURIComponent(content), "ascii");
+		return Buffer.from(decodeURIComponent(content), "utf8");
 	} catch (_) {
-		return Buffer.from(content, "ascii");
+		return Buffer.from(content, "utf8");
 	}
 };
 
@@ -192,12 +218,14 @@ const DEFAULT_ENCODING = "base64";
 
 class AssetGenerator extends Generator {
 	/**
+	 * Creates an instance of AssetGenerator.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
 	 * @param {AssetModuleFilename=} filename override for output.assetModuleFilename
 	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
 	 * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import
 	 * @param {boolean=} emit generate output asset
+	 * @param {Compilation=} compilation the compilation (`getTypes` has no generate context, so the analyzable-output decision reads `output.module`/`output.publicPath` from here)
 	 */
 	constructor(
 		moduleGraph,
@@ -205,7 +233,8 @@ class AssetGenerator extends Generator {
 		filename,
 		publicPath,
 		outputPath,
-		emit
+		emit,
+		compilation
 	) {
 		super();
 		/** @type {AssetGeneratorOptions["dataUrl"] | undefined} */
@@ -218,11 +247,14 @@ class AssetGenerator extends Generator {
 		this.outputPath = outputPath;
 		/** @type {boolean | undefined} */
 		this.emit = emit;
+		/** @type {Compilation | undefined} */
+		this._compilation = compilation;
 		/** @type {ModuleGraph} */
 		this._moduleGraph = moduleGraph;
 	}
 
 	/**
+	 * Gets source file name.
 	 * @param {NormalModule} module module
 	 * @param {RuntimeTemplate} runtimeTemplate runtime template
 	 * @returns {string} source file name
@@ -237,6 +269,7 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Gets full content hash.
 	 * @param {NormalModule} module module
 	 * @param {RuntimeTemplate} runtimeTemplate runtime template
 	 * @returns {[string, string]} return full hash and non-numeric full hash
@@ -251,7 +284,7 @@ class AssetGenerator extends Generator {
 		const source = module.originalSource();
 
 		if (source) {
-			hash.update(source.buffer());
+			updateHashFromSource(hash, source);
 		}
 
 		if (module.error) {
@@ -271,17 +304,20 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Gets filename with info.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {Pick<AssetResourceGeneratorOptions, "filename" | "outputPath">} generatorOptions generator options
 	 * @param {{ runtime: RuntimeSpec, runtimeTemplate: RuntimeTemplate, chunkGraph: ChunkGraph }} generateContext context for generate
 	 * @param {string} contentHash the content hash
+	 * @param {string=} fullContentHash untruncated content hash, so `[contenthash:<digest>]` re-encodes from full entropy
 	 * @returns {{ filename: string, originalFilename: string, assetInfo: AssetInfo }} info
 	 */
 	static getFilenameWithInfo(
 		module,
 		generatorOptions,
 		{ runtime, runtimeTemplate, chunkGraph },
-		contentHash
+		contentHash,
+		fullContentHash
 	) {
 		const assetModuleFilename =
 			generatorOptions.filename ||
@@ -297,7 +333,8 @@ class AssetGenerator extends Generator {
 				runtime,
 				filename: sourceFilename,
 				chunkGraph,
-				contentHash
+				contentHash,
+				contentHashFull: fullContentHash
 			});
 
 		const originalFilename = filename;
@@ -311,7 +348,8 @@ class AssetGenerator extends Generator {
 						runtime,
 						filename: sourceFilename,
 						chunkGraph,
-						contentHash
+						contentHash,
+						contentHashFull: fullContentHash
 					}
 				);
 			filename = path.posix.join(outputPath, filename);
@@ -322,12 +360,14 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Gets asset path with info.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {Pick<AssetResourceGeneratorOptions, "publicPath">} generatorOptions generator options
 	 * @param {GenerateContext} generateContext context for generate
 	 * @param {string} filename the filename
 	 * @param {AssetInfo} assetInfo the asset info
 	 * @param {string} contentHash the content hash
+	 * @param {string=} fullContentHash untruncated content hash, so `[contenthash:<digest>]` re-encodes from full entropy
 	 * @returns {{ assetPath: string, assetInfo: AssetInfo }} asset path and info
 	 */
 	static getAssetPathWithInfo(
@@ -336,7 +376,8 @@ class AssetGenerator extends Generator {
 		{ runtime, runtimeTemplate, type, chunkGraph, runtimeRequirements },
 		filename,
 		assetInfo,
-		contentHash
+		contentHash,
+		fullContentHash
 	) {
 		const sourceFilename = AssetGenerator.getSourceFileName(
 			module,
@@ -354,14 +395,15 @@ class AssetGenerator extends Generator {
 					runtime,
 					filename: sourceFilename,
 					chunkGraph,
-					contentHash
+					contentHash,
+					contentHashFull: fullContentHash
 				}
 			);
 			assetInfo = mergeAssetInfo(assetInfo, info);
 			assetPath = JSON.stringify(path + filename);
 		} else if (
 			generatorOptions.publicPath !== undefined &&
-			type === CSS_URL_TYPE
+			type === ASSET_URL_TYPE
 		) {
 			const { path, info } = runtimeTemplate.compilation.getAssetPathWithInfo(
 				generatorOptions.publicPath,
@@ -370,7 +412,8 @@ class AssetGenerator extends Generator {
 					runtime,
 					filename: sourceFilename,
 					chunkGraph,
-					contentHash
+					contentHash,
+					contentHashFull: fullContentHash
 				}
 			);
 			assetInfo = mergeAssetInfo(assetInfo, info);
@@ -382,13 +425,17 @@ class AssetGenerator extends Generator {
 				{ expr: RuntimeGlobals.publicPath },
 				filename
 			);
-		} else if (type === CSS_URL_TYPE) {
+		} else if (type === ASSET_URL_TYPE) {
 			const compilation = runtimeTemplate.compilation;
 			const path =
 				compilation.outputOptions.publicPath === "auto"
-					? CssUrlDependency.PUBLIC_PATH_AUTO
+					? PUBLIC_PATH_AUTO
 					: compilation.getAssetPath(compilation.outputOptions.publicPath, {
-							hash: compilation.hash
+							hash: compilation.hash || `${PUBLIC_PATH_FULL_HASH}0__`,
+							hashWithLength: (length) =>
+								compilation.hash
+									? compilation.hash.slice(0, length)
+									: `${PUBLIC_PATH_FULL_HASH}${length}__`
 						});
 
 			assetPath = path + filename;
@@ -401,6 +448,7 @@ class AssetGenerator 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
@@ -410,6 +458,7 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Returns mime type.
 	 * @param {NormalModule} module module
 	 * @returns {string} mime type
 	 */
@@ -420,7 +469,7 @@ class AssetGenerator extends Generator {
 			);
 		}
 
-		/** @type {string | boolean | undefined} */
+		/** @type {string | undefined} */
 		let mimeType =
 			/** @type {AssetGeneratorDataUrlOptions} */
 			(this.dataUrlOptions).mimetype;
@@ -462,6 +511,7 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Generates data uri.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @returns {string} DataURI
 	 */
@@ -522,6 +572,7 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * 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
@@ -538,11 +589,11 @@ class AssetGenerator extends Generator {
 		/** @type {string} */
 		let content;
 
-		const needContent = type === JAVASCRIPT_TYPE || type === CSS_URL_TYPE;
+		const needContent = type === JAVASCRIPT_TYPE || type === ASSET_URL_TYPE;
 		const data = getData ? getData() : undefined;
 
 		if (
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(module.buildInfo).dataUrl &&
 			needContent
 		) {
@@ -553,7 +604,7 @@ class AssetGenerator extends Generator {
 					: encodedSource;
 
 			if (data) {
-				data.set("url", { [type]: content, ...data.get("url") });
+				data.set("url", { ...data.get("url"), [type]: content });
 			}
 		} else {
 			const [fullContentHash, contentHash] = AssetGenerator.getFullContentHash(
@@ -566,7 +617,7 @@ class AssetGenerator extends Generator {
 				data.set("contentHash", contentHash);
 			}
 
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(module.buildInfo).fullContentHash = fullContentHash;
 
 			const { originalFilename, filename, assetInfo } =
@@ -574,7 +625,8 @@ class AssetGenerator extends Generator {
 					module,
 					{ filename: this.filename, outputPath: this.outputPath },
 					generateContext,
-					contentHash
+					contentHash,
+					fullContentHash
 				);
 
 			if (data) {
@@ -588,11 +640,12 @@ class AssetGenerator extends Generator {
 					generateContext,
 					originalFilename,
 					assetInfo,
-					contentHash
+					contentHash,
+					fullContentHash
 				);
 
-			if (data && (type === JAVASCRIPT_TYPE || type === CSS_URL_TYPE)) {
-				data.set("url", { [type]: assetPath, ...data.get("url") });
+			if (data && (type === JAVASCRIPT_TYPE || type === ASSET_URL_TYPE)) {
+				data.set("url", { ...data.get("url"), [type]: assetPath });
 			}
 
 			if (data) {
@@ -610,10 +663,10 @@ class AssetGenerator extends Generator {
 			// Due to code generation caching module.buildInfo.XXX can't used to store such information
 			// It need to be stored in the code generation results instead, where it's cached too
 			// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(module.buildInfo).filename = filename;
 
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(module.buildInfo).assetInfo = newAssetInfo;
 
 			content = assetPath;
@@ -635,7 +688,7 @@ class AssetGenerator extends Generator {
 			runtimeRequirements.add(RuntimeGlobals.module);
 
 			return new RawSource(`${module.moduleArgument}.exports = ${content};`);
-		} else if (type === CSS_URL_TYPE) {
+		} else if (type === ASSET_URL_TYPE) {
 			return null;
 		}
 
@@ -643,6 +696,7 @@ class AssetGenerator 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
@@ -664,28 +718,101 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Returns whether the effective publicPath yields a chunk-independent absolute
+	 * url (scheme-relative, protocol-absolute, or root-absolute) with no hash tokens.
+	 * Only then is a `new URL` literal correct for every chunk the asset is shared by,
+	 * so the `module.exports` wrapper can be dropped in favor of the `asset-url` type.
+	 * @returns {boolean} true when the publicPath is a token-free absolute string
+	 */
+	_hasAbsolutePublicPath() {
+		const publicPath =
+			this.publicPath !== undefined
+				? this.publicPath
+				: this._compilation && this._compilation.outputOptions.publicPath;
+		return (
+			typeof publicPath === "string" &&
+			!publicPath.includes("[") &&
+			(publicPath.startsWith("/") ||
+				/^[a-z][a-z\d+\-.]*:\/\//i.test(publicPath))
+		);
+	}
+
+	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		/** @type {Set<string>} */
-		const sourceTypes = new Set();
 		const connections = this._moduleGraph.getIncomingConnections(module);
 
+		// Only ESM output can drop a bare `new URL()` to an analyzable asset-url; without
+		// it every JS consumer needs the wrapper, so skip the per-connection dependency
+		// probe entirely and keep the pre-existing cheap path.
+		const isModule = Boolean(
+			this._compilation && this._compilation.outputOptions.module
+		);
+
+		// Collapse the incoming origin types into flags instead of a Set of prefixes:
+		// on assets shared by many modules this loop runs millions of times, so avoid
+		// the per-connection `split("/")` allocation and stop early when the result is fixed.
+		let hasOrigin = false;
+		// JS origin that needs the `module.exports = …` wrapper (not a `new URL` ref).
+		let hasOtherJs = false;
+		// JS origin via `new URL(…, import.meta.url)` — droppable to `asset-url` in ESM.
+		let hasUrlJs = false;
+		// A manifest embeds a bare URL string (like css/html), so its icons must
+		// resolve to `ASSET_URL_TYPE` rather than the JS runtime form.
+		let hasUrl = false;
 		for (const connection of connections) {
-			if (!connection.originModule) {
+			const originModule = connection.originModule;
+			if (!originModule) {
 				continue;
 			}
-
-			sourceTypes.add(connection.originModule.type.split("/")[0]);
+			hasOrigin = true;
+			const originType = originModule.type;
+			if (originType === ASSET_MODULE_TYPE_WEBMANIFEST) {
+				hasUrl = true;
+			} else if (typePrefixEquals(originType, JAVASCRIPT_TYPE)) {
+				// Only a bare `new URL()` becomes the analyzable literal; relative and
+				// prefetch/preload refs keep the runtime form and still need the wrapper.
+				const dependency = isModule && connection.dependency;
+				if (
+					dependency &&
+					dependency.type === "new URL()" &&
+					!(/** @type {URLDependency} */ (dependency).relative) &&
+					!(/** @type {URLDependency} */ (dependency).prefetch) &&
+					!(/** @type {URLDependency} */ (dependency).preload)
+				) {
+					hasUrlJs = true;
+				} else {
+					hasOtherJs = true;
+				}
+			} else if (
+				typePrefixEquals(originType, CSS_TYPE) ||
+				typePrefixEquals(originType, HTML_TYPE)
+			) {
+				hasUrl = true;
+			}
+			// Once a non-URL JS consumer and a url consumer coexist the result is fixed.
+			if (hasOtherJs && hasUrl) break;
 		}
 
-		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
-			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;
+		const jsAsAssetUrl =
+			isModule && hasUrlJs && !hasOtherJs && this._hasAbsolutePublicPath();
+		// JS wrapper is needed for non-URL JS consumers, or URL consumers not dropped to asset-url.
+		const wantJs = hasOtherJs || (hasUrlJs && !jsAsAssetUrl);
+		const wantUrl = hasUrl || jsAsAssetUrl;
+
+		if (
+			(module.buildInfo &&
+				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl) ||
+			this.emit === false
+		) {
+			if (hasOrigin) {
+				if (wantJs && wantUrl) {
+					return JAVASCRIPT_AND_ASSET_URL_TYPES;
+				} else if (wantUrl) {
+					return ASSET_URL_TYPES;
 				}
 				return JAVASCRIPT_TYPES;
 			}
@@ -693,11 +820,11 @@ class AssetGenerator extends Generator {
 			return NO_TYPES;
 		}
 
-		if (sourceTypes.size > 0) {
-			if (sourceTypes.has(JAVASCRIPT_TYPE) && sourceTypes.has(CSS_TYPE)) {
-				return ASSET_AND_JAVASCRIPT_AND_CSS_URL_TYPES;
-			} else if (sourceTypes.has(CSS_TYPE)) {
-				return ASSET_AND_CSS_URL_TYPES;
+		if (hasOrigin) {
+			if (wantJs && wantUrl) {
+				return ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES;
+			} else if (wantUrl) {
+				return ASSET_AND_ASSET_URL_TYPES;
 			}
 			return ASSET_AND_JAVASCRIPT_TYPES;
 		}
@@ -706,6 +833,14 @@ class AssetGenerator 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
@@ -722,7 +857,10 @@ class AssetGenerator extends Generator {
 				return originalSource.size();
 			}
 			default:
-				if (module.buildInfo && module.buildInfo.dataUrl) {
+				if (
+					module.buildInfo &&
+					/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl
+				) {
 					const originalSource = module.originalSource();
 
 					if (!originalSource) {
@@ -742,6 +880,7 @@ class AssetGenerator extends Generator {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
@@ -749,7 +888,7 @@ class AssetGenerator extends Generator {
 		const { module } = updateHashContext;
 
 		if (
-			/** @type {BuildInfo} */
+			/** @type {AssetModuleBuildInfo} */
 			(module.buildInfo).dataUrl
 		) {
 			hash.update("data-url");

package/lib/asset/AssetModule.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
+/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+
+/**
+ * Defines the build info properties specific to asset modules.
+ * @typedef {object} KnownAssetModuleBuildInfo
+ * @property {boolean=} dataUrl whether the asset is inlined as a data url
+ * @property {string=} filename
+ * @property {AssetInfo=} assetInfo
+ * @property {string=} fullContentHash
+ */
+
+/** @typedef {NormalModuleBuildInfo & KnownAssetModuleBuildInfo} AssetModuleBuildInfo */
+
+/**
+ * Module class for all `asset/*` modules. Asset-specific properties should live here instead of `NormalModule`.
+ */
+class AssetModule extends NormalModule {
+	/**
+	 * @param {NormalModuleCreateData} options options object
+	 * @param {boolean=} sideEffectFree whether asset modules are side-effect-free (`AssetModulesPluginOptions`)
+	 */
+	constructor(options, sideEffectFree) {
+		super(options);
+
+		// Redeclared with the asset specific shape
+		/** @type {AssetModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+		if (sideEffectFree) {
+			this.factoryMeta = { sideEffectFree: true };
+		}
+	}
+}
+
+makeSerializable(AssetModule, "webpack/lib/asset/AssetModule");
+
+module.exports = AssetModule;