webpack 5.101.3 → 5.102.1

package/lib/WebpackOptionsApply.js

@@ -73,9 +73,8 @@ const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin");
 
 const { cleverMerge } = require("./util/cleverMerge");
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
@@ -93,7 +92,7 @@ class WebpackOptionsApply extends OptionsApply {
 	 * @returns {WebpackOptions} options object
 	 */
 	process(options, compiler) {
-		compiler.outputPath = /** @type {string} */ (options.output.path);
+		compiler.outputPath = options.output.path;
 		compiler.recordsInputPath = options.recordsInputPath || null;
 		compiler.recordsOutputPath = options.recordsOutputPath || null;
 		compiler.name = options.name;
@@ -111,115 +110,92 @@ class WebpackOptionsApply extends OptionsApply {
 			const NodeTargetPlugin = require("./node/NodeTargetPlugin");
 
 			new NodeTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.electronMain) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
-
-			new ElectronTargetPlugin("main").apply(compiler);
-		}
-		if (options.externalsPresets.electronPreload) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 
-			new ElectronTargetPlugin("preload").apply(compiler);
-		}
-		if (options.externalsPresets.electronRenderer) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+			// Handle external CSS `@import` and `url()`
+			if (options.experiments.css) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ExternalsPlugin = require("./ExternalsPlugin");
 
-			new ElectronTargetPlugin("renderer").apply(compiler);
-		}
-		if (
-			options.externalsPresets.electron &&
-			!options.externalsPresets.electronMain &&
-			!options.externalsPresets.electronPreload &&
-			!options.externalsPresets.electronRenderer
-		) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+				new ExternalsPlugin(
+					"module",
+					({ request, dependencyType, contextInfo }, callback) => {
+						if (
+							/\.css(\?|$)/.test(contextInfo.issuer) &&
+							/^(\/\/|https?:\/\/|#)/.test(request)
+						) {
+							if (dependencyType === "url") {
+								return callback(null, `asset ${request}`);
+							} else if (
+								dependencyType === "css-import" &&
+								options.experiments.css
+							) {
+								return callback(null, `css-import ${request}`);
+							}
+						}
 
-			new ElectronTargetPlugin().apply(compiler);
+						callback();
+					}
+				).apply(compiler);
+			}
 		}
-		if (options.externalsPresets.nwjs) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = require("./ExternalsPlugin");
+		if (options.externalsPresets.webAsync || options.externalsPresets.web) {
+			const type = options.externalsPresets.webAsync ? "import" : "module";
 
-			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
-		}
-		if (options.externalsPresets.webAsync) {
 			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 
-			new ExternalsPlugin("import", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
+			new ExternalsPlugin(type, ({ request, dependencyType }, callback) => {
+				if (/^(\/\/|https?:\/\/|#|std:|jsr:|npm:)/.test(request)) {
+					if (dependencyType === "url") {
 						return callback(null, `asset ${request}`);
-					}
-				} else if (options.experiments.css && dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
-						return callback(null, `css-import ${request}`);
-					}
-				} else if (
-					options.experiments.css &&
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (/^\.css(\?|$)/.test(/** @type {string} */ (request))) {
-						return callback(null, `css-import ${request}`);
-					}
-					return callback(null, `import ${request}`);
-				}
-				callback();
-			}).apply(compiler);
-		} else if (options.externalsPresets.web) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = require("./ExternalsPlugin");
-
-			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
-						return callback(null, `asset ${request}`);
-					}
-				} else if (options.experiments.css && dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
-						return callback(null, `css-import ${request}`);
-					}
-				} else if (
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (
-						options.experiments.css &&
-						/^\.css((\?)|$)/.test(/** @type {string} */ (request))
+					} else if (
+						dependencyType === "css-import" &&
+						options.experiments.css
 					) {
 						return callback(null, `css-import ${request}`);
+					} else if (/^(\/\/|https?:\/\/|std:|jsr:|npm:)/.test(request)) {
+						return callback(null, `${type} ${request}`);
 					}
-					return callback(null, `module ${request}`);
 				}
+
 				callback();
 			}).apply(compiler);
-		} else if (options.externalsPresets.node && options.experiments.css) {
+		}
+		if (options.externalsPresets.electron) {
+			if (options.externalsPresets.electronMain) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("main").apply(compiler);
+			}
+			if (options.externalsPresets.electronPreload) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("preload").apply(compiler);
+			}
+			if (options.externalsPresets.electronRenderer) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("renderer").apply(compiler);
+			}
+			if (
+				!options.externalsPresets.electronMain &&
+				!options.externalsPresets.electronPreload &&
+				!options.externalsPresets.electronRenderer
+			) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin().apply(compiler);
+			}
+		}
+		if (options.externalsPresets.nwjs) {
 			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 
-			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
-						return callback(null, `asset ${request}`);
-					}
-				} else if (dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request))) {
-						return callback(null, `css-import ${request}`);
-					}
-				} else if (
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (/^\.css(\?|$)/.test(/** @type {string} */ (request))) {
-						return callback(null, `css-import ${request}`);
-					}
-					return callback(null, `module ${request}`);
-				}
-				callback();
-			}).apply(compiler);
+			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
 		}
 
 		new ChunkPrefetchPreloadPlugin().apply(compiler);
@@ -446,11 +422,7 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 
 		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(
-			/** @type {string} */
-			(options.context),
-			options.entry
-		);
+		compiler.hooks.entryOption.call(options.context, options.entry);
 
 		new RuntimePlugin().apply(compiler);
 
@@ -461,7 +433,6 @@ class WebpackOptionsApply extends OptionsApply {
 
 		new CompatibilityPlugin().apply(compiler);
 		new HarmonyModulesPlugin({
-			topLevelAwait: options.experiments.topLevelAwait,
 			deferImport: options.experiments.deferImport
 		}).apply(compiler);
 		if (options.amd !== false) {
@@ -478,9 +449,7 @@ class WebpackOptionsApply extends OptionsApply {
 
 			new NodeStuffPlugin(options.node).apply(compiler);
 		}
-		new APIPlugin({
-			module: options.output.module
-		}).apply(compiler);
+		new APIPlugin().apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
@@ -703,9 +672,7 @@ class WebpackOptionsApply extends OptionsApply {
 			}).apply(compiler);
 		}
 		if (options.optimization.minimize) {
-			for (const minimizer of /** @type {(WebpackPluginInstance | WebpackPluginFunction | "...")[]} */ (
-				options.optimization.minimizer
-			)) {
+			for (const minimizer of options.optimization.minimizer) {
 				if (typeof minimizer === "function") {
 					/** @type {WebpackPluginFunction} */
 					(minimizer).call(compiler, compiler);
@@ -810,7 +777,7 @@ class WebpackOptionsApply extends OptionsApply {
 									fs:
 										/** @type {IntermediateFileSystem} */
 										(compiler.intermediateFileSystem),
-									context: /** @type {string} */ (options.context),
+									context: options.context,
 									cacheLocation:
 										/** @type {string} */
 										(cacheOptions.cacheLocation),

package/lib/asset/AssetBytesGenerator.js

@@ -0,0 +1,167 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
+const Generator = require("../Generator");
+const {
+	CSS_URL_TYPES,
+	JS_AND_CSS_URL_TYPES,
+	JS_TYPES,
+	NO_TYPES
+} = require("../ModuleSourceTypesConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+class AssetSourceGenerator extends Generator {
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 */
+	constructor(moduleGraph) {
+		super();
+
+		this._moduleGraph = moduleGraph;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generate(
+		module,
+		{ type, concatenationScope, getData, runtimeTemplate, runtimeRequirements }
+	) {
+		const originalSource = module.originalSource();
+		const data = getData ? getData() : undefined;
+
+		switch (type) {
+			case "javascript": {
+				if (!originalSource) {
+					return new RawSource("");
+				}
+
+				const encodedSource = originalSource.buffer().toString("base64");
+
+				runtimeRequirements.add(RuntimeGlobals.requireScope);
+				runtimeRequirements.add(RuntimeGlobals.toBinary);
+
+				let sourceContent;
+				if (concatenationScope) {
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+					sourceContent = `${runtimeTemplate.renderConst()} ${
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					} = ${RuntimeGlobals.toBinary}(${JSON.stringify(encodedSource)});`;
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.module);
+					sourceContent = `${RuntimeGlobals.module}.exports = ${RuntimeGlobals.toBinary}(${JSON.stringify(
+						encodedSource
+					)});`;
+				}
+				return new RawSource(sourceContent);
+			}
+			case "css-url": {
+				if (!originalSource) {
+					return null;
+				}
+
+				const encodedSource = originalSource.buffer().toString("base64");
+
+				if (data) {
+					data.set("url", {
+						[type]: `data:application/octet-stream;base64,${encodedSource}`
+					});
+				}
+				return null;
+			}
+			default:
+				return null;
+		}
+	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		switch (generateContext.type) {
+			case "javascript": {
+				return new RawSource(
+					`throw new Error(${JSON.stringify(error.message)});`
+				);
+			}
+			default:
+				return null;
+		}
+	}
+
+	/**
+	 * @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
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
+
+	/**
+	 * @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);
+
+		for (const connection of connections) {
+			if (!connection.originModule) {
+				continue;
+			}
+
+			sourceTypes.add(connection.originModule.type.split("/")[0]);
+		}
+
+		if (sourceTypes.size > 0) {
+			if (sourceTypes.has("javascript") && sourceTypes.has("css")) {
+				return JS_AND_CSS_URL_TYPES;
+			} else if (sourceTypes.has("css")) {
+				return CSS_URL_TYPES;
+			}
+			return JS_TYPES;
+		}
+
+		return NO_TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return 0;
+		}
+
+		// Example: m.exports="abcd"
+		return originalSource.size() + 12;
+	}
+}
+
+module.exports = AssetSourceGenerator;

package/lib/asset/AssetBytesParser.js

@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Parser = require("../Parser");
+
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+class AssetBytesParser extends Parser {
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetBytesParser doesn't accept preparsed AST");
+		}
+		const { module } = state;
+		/** @type {BuildInfo} */
+		(module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(module.buildMeta).exportsType = "default";
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).defaultObject = false;
+
+		return state;
+	}
+}
+
+module.exports = AssetBytesParser;

package/lib/asset/AssetGenerator.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const path = require("path");
-const mimeTypes = require("mime-types");
 const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
@@ -25,41 +24,38 @@ 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 getMimeTypes = memoize(() => require("mime-types"));
+
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrlOptions} AssetGeneratorDataUrlOptions */
 /** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
 /** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */
 /** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
 /** @typedef {import("../../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").InterpolatedPathAndAssetInfo} InterpolatedPathAndAssetInfo */
-/** @typedef {import("../Compiler")} Compiler */
 /** @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("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @template T
  * @template U
- * @param {null | string | Array<T> | Set<T> | undefined} a a
- * @param {null | string | Array<U> | Set<U> | undefined} b b
- * @returns {Array<T> & Array<U>} array
+ * @param {null | string | T[] | Set<T> | undefined} a a
+ * @param {null | string | U[] | Set<U> | undefined} b b
+ * @returns {T[] & U[]} array
  */
 const mergeMaybeArrays = (a, b) => {
 	const set = new Set();
@@ -220,7 +216,8 @@ class AssetGenerator extends Generator {
 	static getSourceFileName(module, runtimeTemplate) {
 		return makePathsRelative(
 			runtimeTemplate.compilation.compiler.context,
-			module.matchResource || module.resource,
+			/** @type {string} */
+			(module.getResource()),
 			runtimeTemplate.compilation.compiler.root
 		).replace(/^\.\//, "");
 	}
@@ -231,10 +228,7 @@ class AssetGenerator extends Generator {
 	 * @returns {[string, string]} return full hash and non-numeric full hash
 	 */
 	static getFullContentHash(module, runtimeTemplate) {
-		const hash = createHash(
-			/** @type {HashFunction} */
-			(runtimeTemplate.outputOptions.hashFunction)
-		);
+		const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
 
 		if (runtimeTemplate.outputOptions.hashSalt) {
 			hash.update(runtimeTemplate.outputOptions.hashSalt);
@@ -250,15 +244,13 @@ class AssetGenerator extends Generator {
 			hash.update(module.error.toString());
 		}
 
-		const fullContentHash = /** @type {string} */ (
-			hash.digest(runtimeTemplate.outputOptions.hashDigest)
+		const fullContentHash = hash.digest(
+			runtimeTemplate.outputOptions.hashDigest
 		);
 
-		/** @type {string} */
 		const contentHash = nonNumericOnlyHash(
 			fullContentHash,
-			/** @type {number} */
-			(runtimeTemplate.outputOptions.hashDigestLength)
+			runtimeTemplate.outputOptions.hashDigestLength
 		);
 
 		return [fullContentHash, contentHash];
@@ -279,8 +271,7 @@ class AssetGenerator extends Generator {
 	) {
 		const assetModuleFilename =
 			generatorOptions.filename ||
-			/** @type {AssetModuleFilename} */
-			(runtimeTemplate.outputOptions.assetModuleFilename);
+			runtimeTemplate.outputOptions.assetModuleFilename;
 
 		const sourceFilename = AssetGenerator.getSourceFileName(
 			module,
@@ -381,13 +372,9 @@ class AssetGenerator extends Generator {
 			const path =
 				compilation.outputOptions.publicPath === "auto"
 					? CssUrlDependency.PUBLIC_PATH_AUTO
-					: compilation.getAssetPath(
-							/** @type {TemplatePath} */
-							(compilation.outputOptions.publicPath),
-							{
-								hash: compilation.hash
-							}
-						);
+					: compilation.getAssetPath(compilation.outputOptions.publicPath, {
+							hash: compilation.hash
+						});
 
 			assetPath = path + filename;
 		}
@@ -425,7 +412,7 @@ class AssetGenerator extends Generator {
 			(this.dataUrlOptions).mimetype;
 		if (mimeType === undefined) {
 			const ext = path.extname(
-				/** @type {string} */
+				/** @type {NameForCondition} */
 				(module.nameForCondition())
 			);
 			if (
@@ -436,7 +423,7 @@ class AssetGenerator extends Generator {
 					module.resourceResolveData.mimetype +
 					module.resourceResolveData.parameters;
 			} else if (ext) {
-				mimeType = mimeTypes.lookup(ext);
+				mimeType = getMimeTypes().lookup(ext);
 
 				if (typeof mimeType !== "string") {
 					throw new Error(
@@ -471,7 +458,7 @@ class AssetGenerator extends Generator {
 
 		if (typeof this.dataUrlOptions === "function") {
 			encodedSource = this.dataUrlOptions.call(null, source.source(), {
-				filename: module.matchResource || module.resource,
+				filename: /** @type {string} */ (module.getResource()),
 				module
 			});
 		} else {
@@ -619,7 +606,7 @@ class AssetGenerator extends Generator {
 				);
 
 				return new RawSource(
-					`${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+					`${runtimeTemplate.renderConst()} ${
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					} = ${content};`
 				);
@@ -794,9 +781,7 @@ class AssetGenerator extends Generator {
 			}
 
 			const assetModuleFilename =
-				this.filename ||
-				/** @type {AssetModuleFilename} */
-				(runtimeTemplate.outputOptions.assetModuleFilename);
+				this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
 			const { path: filename, info } =
 				runtimeTemplate.compilation.getAssetPathWithInfo(
 					assetModuleFilename,