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

package/lib/wasm-async/AsyncWasmModule.js

@@ -7,9 +7,9 @@
 const NormalModule = require("../NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
-/** @typedef {import("../dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */
+/** @import Module from "../Module" */
+/** @import { NormalModuleCreateData } from "../NormalModule" */
+/** @import { ImportPhaseName } from "../dependencies/ImportPhase" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ImportPhaseName | undefined]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ImportPhaseName | undefined]>} ObjectSerializerContext */
 

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -9,11 +9,10 @@ const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "../Generator" */
+/** @import { SourceType, SourceTypes } from "../Module" */
+/** @import NormalModule from "../NormalModule" */
 
 /**
  * Represents the async web assembly generator runtime component.

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -13,13 +13,11 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./AsyncWasmModule")} AsyncWasmModule */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @import { Source } from "webpack-sources" */
+/** @import AsyncWasmModule from "./AsyncWasmModule" */
+/** @import { GenerateContext } from "../Generator" */
+/** @import Module, { SourceType, SourceTypes } from "../Module" */
+/** @import NormalModule from "../NormalModule" */
 
 /**
  * Represents the async web assembly javascript generator runtime component.
@@ -72,8 +70,24 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			return this._generateSourcePhase(module, generateContext);
 		}
 
+		const analyzableUrl = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			chunkGraph,
+			module,
+			runtime
+		)
+			? runtimeTemplate.getAnalyzableWasmUrl(
+					module,
+					chunkGraph,
+					runtime,
+					runtimeRequirements
+				)
+			: null;
+
 		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		if (analyzableUrl === null) {
+			runtimeRequirements.add(RuntimeGlobals.moduleId);
+		}
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
 		/** @type {InitFragment<GenerateContext>[]} */
@@ -173,11 +187,15 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 					])
 				: undefined;
 
-		const instantiateCall = `${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
-			module.moduleArgument
-		}.id, ${JSON.stringify(
-			chunkGraph.getRenderedModuleHash(module, runtime)
-		)}${importsObj ? `, ${importsObj})` : ")"}`;
+		const locator =
+			analyzableUrl === null
+				? `${module.moduleArgument}.id, ${JSON.stringify(
+						chunkGraph.getRenderedModuleHash(module, runtime)
+					)}`
+				: analyzableUrl;
+		const instantiateCall = `${RuntimeGlobals.instantiateWasm}(${
+			module.exportsArgument
+		}, ${locator}${importsObj ? `, ${importsObj})` : ")"}`;
 
 		if (promises.length > 0) {
 			runtimeRequirements.add(RuntimeGlobals.asyncModule);
@@ -225,8 +243,24 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		const { chunkGraph, runtimeTemplate, runtimeRequirements, runtime } =
 			generateContext;
 
+		const analyzableUrl = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			chunkGraph,
+			module,
+			runtime
+		)
+			? runtimeTemplate.getAnalyzableWasmUrl(
+					module,
+					chunkGraph,
+					runtime,
+					runtimeRequirements
+				)
+			: null;
+
 		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		if (analyzableUrl === null) {
+			runtimeRequirements.add(RuntimeGlobals.moduleId);
+		}
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.compileWasm);
 		runtimeRequirements.add(RuntimeGlobals.asyncModule);
@@ -234,8 +268,12 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 		// Source phase: export default WebAssembly.Module (via compileWasm)
 		const compileCall = `${RuntimeGlobals.compileWasm}(${
-			module.moduleArgument
-		}.id, ${JSON.stringify(chunkGraph.getRenderedModuleHash(module, runtime))})`;
+			analyzableUrl === null
+				? `${module.moduleArgument}.id, ${JSON.stringify(
+						chunkGraph.getRenderedModuleHash(module, runtime)
+					)}`
+				: analyzableUrl
+		})`;
 
 		// Use async module wrapper to handle the Promise from compileWasm
 		return new RawSource(
@@ -264,7 +302,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -12,27 +12,28 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
 const { compareModulesByFullName } = require("../util/comparators");
 const createHooksRegistry = require("../util/createHooksRegistry");
-const memoize = require("../util/memoize");
+const lazyModule = require("../util/lazyModule");
+const preloadModuleType = require("../util/preloadModuleType");
 const AsyncWasmModule = require("./AsyncWasmModule");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-
-const getAsyncWebAssemblyGenerator = memoize(() =>
+/** @import { Source } from "webpack-sources" */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Compiler from "../Compiler" */
+/** @import DependencyTemplates from "../DependencyTemplates" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import WebpackError from "../errors/WebpackError" */
+
+const getAsyncWebAssemblyGenerator = lazyModule(() =>
 	require("./AsyncWebAssemblyGenerator")
 );
-const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
+const getAsyncWebAssemblyJavascriptGenerator = lazyModule(() =>
 	require("./AsyncWebAssemblyJavascriptGenerator")
 );
-const getAsyncWebAssemblyParser = memoize(() =>
+const getAsyncWebAssemblyParser = lazyModule(() =>
 	require("./AsyncWebAssemblyParser")
 );
 
@@ -77,6 +78,9 @@ class AsyncWebAssemblyModulesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		// A binary's name may carry the compilation hash, which the analyzable call site
+		// leaves as a stand-in — so whatever the chunk loading is, the pass that fills it
+		// in has to be there. Applying it twice is a no-op.
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
@@ -87,6 +91,17 @@ class AsyncWebAssemblyModulesPlugin {
 					normalModuleFactory
 				);
 
+				preloadModuleType(normalModuleFactory, PLUGIN_NAME, [
+					[
+						WEBASSEMBLY_MODULE_TYPE_ASYNC,
+						[
+							getAsyncWebAssemblyParser,
+							getAsyncWebAssemblyJavascriptGenerator,
+							getAsyncWebAssemblyGenerator
+						]
+					]
+				]);
+
 				normalModuleFactory.hooks.createModuleClass
 					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
 					.tap(
@@ -101,7 +116,7 @@ class AsyncWebAssemblyModulesPlugin {
 				normalModuleFactory.hooks.createParser
 					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
 					.tap(PLUGIN_NAME, () => {
-						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
+						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser.loaded();
 
 						return new AsyncWebAssemblyParser();
 					});
@@ -109,8 +124,9 @@ class AsyncWebAssemblyModulesPlugin {
 					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
 					.tap(PLUGIN_NAME, () => {
 						const AsyncWebAssemblyJavascriptGenerator =
-							getAsyncWebAssemblyJavascriptGenerator();
-						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
+							getAsyncWebAssemblyJavascriptGenerator.loaded();
+						const AsyncWebAssemblyGenerator =
+							getAsyncWebAssemblyGenerator.loaded();
 
 						return Generator.byType({
 							javascript: new AsyncWebAssemblyJavascriptGenerator(),

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -10,14 +10,15 @@ const { decode } = require("@webassemblyjs/wasm-parser");
 const Parser = require("../Parser");
 const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSupportAsyncWarning");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("./AsyncWasmModule")} AsyncWasmModule */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+const getEnvironmentNotSupportAsyncWarning = memoize(() =>
+	require("../errors/EnvironmentNotSupportAsyncWarning")
+);
+
+/** @import AsyncWasmModule from "./AsyncWasmModule" */
+/** @import { BuildInfo, BuildMeta } from "../Module" */
+/** @import { ParserState, PreparsedAst } from "../Parser" */
 
 const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
 
@@ -45,7 +46,7 @@ class WebAssemblyParser extends Parser {
 		buildMeta.exportsType = "namespace";
 		buildMeta.async = true;
 
-		EnvironmentNotSupportAsyncWarning.check(
+		getEnvironmentNotSupportAsyncWarning().check(
 			state.module,
 			state.compilation.runtimeTemplate,
 			"asyncWebAssembly"

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -8,11 +8,13 @@
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { usesFullHashDigest } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 const PLUGIN_NAME = "UniversalCompileAsyncWasmPlugin";
 
@@ -61,21 +63,30 @@ class UniversalCompileAsyncWasmPlugin {
 					`var useFetch = ${compilation.runtimeTemplate.isWebLikePlatformExpression()};`,
 					`var wasmUrl = ${path};`
 				]);
+			// `wasmUrl` already holds a complete `URL` when the call site bakes it. Read that
+			// per call: it depends on parse results, so it is not settled while the plugin
+			// is being applied.
+			/**
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
+			 * @returns {string} the argument to hand the reader
+			 */
+			const wasmUrlArg = (analyzable) =>
+				analyzable
+					? "wasmUrl"
+					: compilation.runtimeTemplate.importMetaUrl("wasmUrl");
 			/**
 			 * Generates the runtime expression that fetches the binary in browsers
 			 * or reads it from the filesystem in Node.js.
-			 * @type {(path: string) => string}
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string}
 			 */
-			const generateLoadBinaryCode = () =>
+			const generateLoadBinaryCode = (path, runtime, analyzable) =>
 				Template.asString([
 					"(useFetch",
-					Template.indent([
-						`? fetch(new URL(wasmUrl, ${compilation.outputOptions.importMetaName}.url))`
-					]),
+					Template.indent([`? fetch(${wasmUrlArg(analyzable)})`]),
 					Template.indent([
 						": Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 						Template.indent([
-							`readFile(new URL(wasmUrl, ${compilation.outputOptions.importMetaName}.url), (err, buffer) => {`,
+							`readFile(${wasmUrlArg(analyzable)}, (err, buffer) => {`,
 							Template.indent([
 								"if (err) return reject(err);",
 								"",
@@ -105,6 +116,11 @@ class UniversalCompileAsyncWasmPlugin {
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
 							generateBeforeLoadBinaryCode,
 							generateLoadBinaryCode,
 							generateBeforeInstantiateStreaming: generateBeforeStreaming,
@@ -128,6 +144,11 @@ class UniversalCompileAsyncWasmPlugin {
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
 							generateBeforeLoadBinaryCode,
 							generateLoadBinaryCode,
 							generateBeforeCompileStreaming: generateBeforeStreaming,

package/lib/wasm-sync/SyncWasmModule.js

@@ -7,8 +7,8 @@
 const NormalModule = require("../NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @import { BuildMeta } from "../Module" */
+/** @import { NormalModuleCreateData } from "../NormalModule" */
 
 /**
  * Defines the build meta properties specific to sync wasm modules.

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -8,17 +8,16 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
+const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
-/** @typedef {import("@webassemblyjs/ast").Signature} Signature */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { Signature } from "@webassemblyjs/ast" */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Module, { ReadOnlyRuntimeRequirements } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 // TODO webpack 6 remove the whole folder
 
@@ -225,6 +224,7 @@ const generateImportObject = (
  * @property {boolean=} supportsStreaming
  * @property {boolean=} mangleImports
  * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
+ * @property {boolean=} fullHashDigest the binary's name inlines a re-encoded compilation hash
  */
 
 class WasmChunkLoadingRuntimeModule extends RuntimeModule {
@@ -235,9 +235,16 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		generateLoadBinaryCode,
 		supportsStreaming,
 		mangleImports,
-		runtimeRequirements
+		runtimeRequirements,
+		fullHashDigest
 	}) {
 		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
+		// A re-encoded digest is inlined from the settled hash, so this has to render
+		// again once there is one.
+		if (fullHashDigest) {
+			/** @type {boolean} */
+			this.fullHash = true;
+		}
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
 		/** @type {boolean | undefined} */
 		this.supportsStreaming = supportsStreaming;
@@ -291,9 +298,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		const wasmModuleSrcPath = compilation.getPath(
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				...fullHashPathData(compilation),
 				module: {
 					id: '" + wasmModuleId + "',
 					hash: `" + ${JSON.stringify(

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -8,11 +8,10 @@
 const formatLocation = require("../util/formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("./SyncWasmModule").SyncWasmModuleBuildMeta} SyncWasmModuleBuildMeta */
+/** @import Compiler from "../Compiler" */
+/** @import Dependency from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import { SyncWasmModuleBuildMeta } from "./SyncWasmModule" */
 
 const PLUGIN_NAME = "WasmFinalizeExportsPlugin";
 

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -15,23 +15,24 @@ const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
-/** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
-/** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
-/** @typedef {import("@webassemblyjs/ast").ModuleExport} ModuleExport */
-/** @typedef {import("@webassemblyjs/ast").Global} Global */
-/** @typedef {import("@webassemblyjs/ast").AST} AST */
-/** @typedef {import("@webassemblyjs/ast").GlobalType} GlobalType */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext, UpdateHashContext } from "../Generator" */
+/** @import Module, { SourceType, SourceTypes } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import NormalModule from "../NormalModule" */
+/** @import Hash from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { UsedWasmDependency } from "./WebAssemblyUtils" */
+/**
+ * @import {
+ * 	Instruction,
+ * 	ModuleImport,
+ * 	ModuleExport,
+ * 	Global,
+ * 	AST,
+ * 	GlobalType
+ * } from "@webassemblyjs/ast"
+ */
 /**
  * Defines the node path type used by this module.
  * @template T

package/lib/wasm-sync/WebAssemblyInInitialChunkError.js

@@ -6,10 +6,10 @@
 
 const WebpackError = require("../errors/WebpackError");
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import RequestShortener from "../RequestShortener" */
 
 /**
  * Gets initial module chains.

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -16,12 +16,10 @@ const ModuleDependency = require("../dependencies/ModuleDependency");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "../Generator" */
+/** @import Module, { SourceType, SourceTypes } from "../Module" */
+/** @import NormalModule from "../NormalModule" */
 
 class WebAssemblyJavascriptGenerator extends Generator {
 	/**
@@ -233,7 +231,9 @@ class WebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -14,20 +14,21 @@ const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByFullName } = require("../util/comparators");
-const memoize = require("../util/memoize");
+const lazyModule = require("../util/lazyModule");
+const preloadModuleType = require("../util/preloadModuleType");
 const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError");
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
 
-const getWebAssemblyGenerator = memoize(() =>
+const getWebAssemblyGenerator = lazyModule(() =>
 	require("./WebAssemblyGenerator")
 );
-const getWebAssemblyJavascriptGenerator = memoize(() =>
+const getWebAssemblyJavascriptGenerator = lazyModule(() =>
 	require("./WebAssemblyJavascriptGenerator")
 );
-const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
-const getSyncWasmModule = memoize(() => require("./SyncWasmModule"));
+const getWebAssemblyParser = lazyModule(() => require("./WebAssemblyParser"));
+const getSyncWasmModule = lazyModule(() => require("./SyncWasmModule"));
 
 const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
@@ -73,10 +74,22 @@ class WebAssemblyModulesPlugin {
 					normalModuleFactory
 				);
 
+				preloadModuleType(normalModuleFactory, PLUGIN_NAME, [
+					[
+						WEBASSEMBLY_MODULE_TYPE_SYNC,
+						[
+							getSyncWasmModule,
+							getWebAssemblyParser,
+							getWebAssemblyJavascriptGenerator,
+							getWebAssemblyGenerator
+						]
+					]
+				]);
+
 				normalModuleFactory.hooks.createModuleClass
 					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
 					.tap(PLUGIN_NAME, (createData, _resolveData) => {
-						const SyncWasmModule = getSyncWasmModule();
+						const SyncWasmModule = getSyncWasmModule.loaded();
 
 						return new SyncWasmModule(createData);
 					});
@@ -84,7 +97,7 @@ class WebAssemblyModulesPlugin {
 				normalModuleFactory.hooks.createParser
 					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
 					.tap(PLUGIN_NAME, () => {
-						const WebAssemblyParser = getWebAssemblyParser();
+						const WebAssemblyParser = getWebAssemblyParser.loaded();
 
 						return new WebAssemblyParser();
 					});
@@ -93,8 +106,8 @@ class WebAssemblyModulesPlugin {
 					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
 					.tap(PLUGIN_NAME, () => {
 						const WebAssemblyJavascriptGenerator =
-							getWebAssemblyJavascriptGenerator();
-						const WebAssemblyGenerator = getWebAssemblyGenerator();
+							getWebAssemblyJavascriptGenerator.loaded();
+						const WebAssemblyGenerator = getWebAssemblyGenerator.loaded();
 
 						return Generator.byType({
 							[JAVASCRIPT_TYPE]: new WebAssemblyJavascriptGenerator(),

package/lib/wasm-sync/WebAssemblyParser.js

@@ -13,12 +13,10 @@ const StaticExportsDependency = require("../dependencies/StaticExportsDependency
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
-/** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("./SyncWasmModule").SyncWasmModuleBuildMeta} SyncWasmModuleBuildMeta */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @import { ModuleImport } from "@webassemblyjs/ast" */
+/** @import { BuildInfo, BuildMeta } from "../Module" */
+/** @import { SyncWasmModuleBuildMeta } from "./SyncWasmModule" */
+/** @import { ParserState, PreparsedAst } from "../Parser" */
 
 const JS_COMPAT_TYPES = new Set(["i32", "i64", "f32", "f64", "externref"]);
 

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -8,8 +8,8 @@
 const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
 
 /**
  * Defines the used wasm dependency type used by this module.