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

package/lib/util/parseJson.js

@@ -4,9 +4,11 @@
 
 "use strict";
 
-const JSONParseError = require("../errors/JSONParseError");
+const memoize = require("./memoize");
 
-/** @typedef {import("../util/fs").JsonValue} JsonValue */
+const getJSONParseError = memoize(() => require("../errors/JSONParseError"));
+
+/** @import { JsonValue } from "../util/fs" */
 
 // Inspired by https://github.com/npm/json-parse-even-better-errors
 
@@ -34,7 +36,7 @@ const parseJson = (raw, reviver) => {
 	try {
 		return JSON.parse(txt, reviver);
 	} catch (err) {
-		throw new JSONParseError(/** @type {Error} */ (err), raw, txt);
+		throw new (getJSONParseError())(/** @type {Error} */ (err), raw, txt);
 	}
 };
 

package/lib/util/preloadModuleType.js

@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import NormalModuleFactory from "../NormalModuleFactory" */
+/** @typedef {import("./lazyModule").LazyModuleAccessor<EXPECTED_ANY>} AnyLazyModuleAccessor */
+
+/**
+ * Warms the modules a type's `createParser`/`createGenerator`/`createModuleClass`
+ * taps read, at the factory's async boundary — those hooks are synchronous, so
+ * they cannot await the load themselves.
+ * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+ * @param {string} pluginName name of the tapping plugin
+ * @param {Iterable<[string, AnyLazyModuleAccessor[]]>} table module type to the accessors its taps read
+ * @returns {void}
+ */
+const preloadModuleType = (normalModuleFactory, pluginName, table) => {
+	for (const [type, accessors] of table) {
+		normalModuleFactory.hooks.prepareModuleType
+			.for(type)
+			.tapPromise(pluginName, () =>
+				Promise.all(accessors.map((accessor) => accessor())).then(
+					() => undefined
+				)
+			);
+	}
+};
+
+module.exports = preloadModuleType;

package/lib/util/registerExternalSerializer.js

@@ -19,11 +19,13 @@ const {
 } = require("webpack-sources");
 const { register } = require("./serialization");
 
-/** @typedef {import("acorn").Position} Position */
-/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @import { RealDependencyLocation, SourcePosition } from "../Dependency" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 

package/lib/util/runtime.js

@@ -7,8 +7,8 @@
 
 const SortableSet = require("./SortableSet");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @import Compilation from "../Compilation" */
+/** @import { EntryOptions } from "../Entrypoint" */
 
 /** @typedef {SortableSet<string>} RuntimeSpecSortableSet */
 /** @typedef {string | RuntimeSpecSortableSet | undefined} RuntimeSpec */

package/lib/util/semver.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @typedef {string | number} VersionValue */
 /** @typedef {VersionValue | undefined} SemVerRangeItem */
 /** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */

package/lib/util/serialization.js

@@ -5,31 +5,18 @@
 "use strict";
 
 const { DEFAULTS } = require("../config/defaults");
+const ObjectMiddleware = require("../serialization/ObjectMiddleware");
+const SerializerMiddleware = require("../serialization/SerializerMiddleware");
 const memoize = require("./memoize");
 
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-
-/**
- * Defines the serializer type used by this module.
- * @template D, S, C
- * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
- */
+const getSerializer = memoize(() => require("../serialization/Serializer"));
 
-const getBinaryMiddleware = memoize(() =>
-	require("../serialization/BinaryMiddleware")
-);
-const getObjectMiddleware = memoize(() =>
-	require("../serialization/ObjectMiddleware")
-);
 const getSingleItemMiddleware = memoize(() =>
 	require("../serialization/SingleItemMiddleware")
 );
-const getSerializer = memoize(() => require("../serialization/Serializer"));
-const getSerializerMiddleware = memoize(() =>
-	require("../serialization/SerializerMiddleware")
+
+const getBinaryMiddleware = memoize(() =>
+	require("../serialization/BinaryMiddleware")
 );
 
 const getBinaryMiddlewareInstance = memoize(
@@ -43,7 +30,7 @@ const registerSerializers = memoize(() => {
 	// This allows bundling all internal serializers
 	const internalSerializables = require("./internalSerializables");
 
-	getObjectMiddleware().registerLoader(/^webpack\/lib\//, (req) => {
+	ObjectMiddleware.registerLoader(/^webpack\/lib\//, (req) => {
 		const loader =
 			internalSerializables[
 				/** @type {keyof import("./internalSerializables")} */
@@ -59,6 +46,21 @@ const registerSerializers = memoize(() => {
 	});
 });
 
+/**
+ * @import {
+ * 	MEASURE_END_OPERATION_TYPE as MEASURE_END_OPERATION,
+ * 	MEASURE_START_OPERATION_TYPE as MEASURE_START_OPERATION
+ * } from "../serialization/BinaryMiddleware"
+ */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
+
+/**
+ * Defines the serializer type used by this module.
+ * @template D, S, C
+ * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
+ */
+
 /**
  * @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>}
  */
@@ -67,16 +69,16 @@ let buffersSerializer;
 // Expose serialization API
 module.exports = {
 	get register() {
-		return getObjectMiddleware().register;
+		return ObjectMiddleware.register;
 	},
 	get registerLoader() {
-		return getObjectMiddleware().registerLoader;
+		return ObjectMiddleware.registerLoader;
 	},
 	get registerNotSerializable() {
-		return getObjectMiddleware().registerNotSerializable;
+		return ObjectMiddleware.registerNotSerializable;
 	},
 	get NOT_SERIALIZABLE() {
-		return getObjectMiddleware().NOT_SERIALIZABLE;
+		return ObjectMiddleware.NOT_SERIALIZABLE;
 	},
 	/** @type {MEASURE_START_OPERATION} */
 	get MEASURE_START_OPERATION() {
@@ -91,12 +93,11 @@ module.exports = {
 		registerSerializers();
 		const Serializer = getSerializer();
 		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
 		return /** @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} */ (
 			buffersSerializer = new Serializer([
 				new SingleItemMiddleware(),
-				new (getObjectMiddleware())((context) => {
+				new ObjectMiddleware((context) => {
 					if ("write" in context) {
 						context.writeLazy = (value) => {
 							context.write(
@@ -124,12 +125,11 @@ module.exports = {
 
 		const fileMiddleware = new FileMiddleware(fs, hashFunction);
 		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
 		return /** @type {Serializer<D, S, C>} */ (
 			new Serializer([
 				new SingleItemMiddleware(),
-				new (getObjectMiddleware())((context) => {
+				new ObjectMiddleware((context) => {
 					if ("write" in context) {
 						context.writeLazy = (value) => {
 							context.write(

package/lib/util/source.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Hash")} Hash */
+/** @import { Source } from "webpack-sources" */
+/** @import Hash from "./Hash" */
 
 /** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
 const equalityCache = new WeakMap();

package/lib/util/traverseDestructuringAssignmentProperties.js

@@ -5,8 +5,12 @@
 
 "use strict";
 
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/**
+ * @import {
+ * 	DestructuringAssignmentProperties,
+ * 	DestructuringAssignmentProperty
+ * } from "../javascript/JavascriptParser"
+ */
 
 /**
  * Deep first traverse the properties of a destructuring assignment.

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { WasmLoadingType } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
 
 /** @typedef {Set<WasmLoadingType>} WasmLoadingTypes */
 
@@ -114,9 +114,10 @@ class EnableWasmLoadingPlugin {
 
 						new ReadFileCompileWasmPlugin({
 							mangleImports: compiler.options.optimization.mangleWasmImports,
-							import:
-								compiler.options.output.module &&
-								compiler.options.output.environment.dynamicImport
+							// ESM output has no `require`, and any runtime that loads ESM has
+							// `import()` — pairing them by `dynamicImport` emitted CJS into an
+							// ES module, which the runtime refuses to load at all.
+							import: compiler.options.output.module
 						}).apply(compiler);
 					}
 
@@ -124,9 +125,10 @@ class EnableWasmLoadingPlugin {
 						const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
 
 						new ReadFileCompileAsyncWasmPlugin({
-							import:
-								compiler.options.output.module &&
-								compiler.options.output.environment.dynamicImport
+							// ESM output has no `require`, and any runtime that loads ESM has
+							// `import()` — pairing them by `dynamicImport` emitted CJS into an
+							// ES module, which the runtime refuses to load at all.
+							import: compiler.options.output.module
 						}).apply(compiler);
 					}
 

package/lib/wasm/wasmModuleFilename.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	getPresentKinds,
+	reEncodeDigest,
+	usesFullHashDigest
+} = require("../TemplatedPathPlugin");
+
+/** @import Compilation from "../Compilation" */
+
+/**
+ * Whether the runtime needs `getFullHash` to build a binary's name. A `[hash]` next to
+ * a module resolves to that module's hash, not the compilation's, so only the explicit
+ * `[fullhash]` spelling asks for it — and a digest is inlined rather than read.
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} true when the runtime reads the compilation hash
+ */
+const needsRuntimeFullHash = (filename) =>
+	getPresentKinds(filename).has("fullhash") && !usesFullHashDigest(filename);
+
+/**
+ * The compilation-hash half of the `getPath` data for interpolating
+ * `output.webassemblyModuleFilename` into runtime code.
+ * @param {Compilation} compilation the compilation
+ * @returns {{ hash: string, hashWithLength: (length: number) => string, hashWithDigest: (digest: string, length?: number) => string }} the fields
+ */
+const fullHashPathData = (compilation) => ({
+	hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+	hashWithLength: (length) =>
+		`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+	// A digest re-encodes the hash, which the runtime expression above cannot carry, so
+	// the settled value is inlined instead — byte-identical to the emitted filename.
+	hashWithDigest: (digest, length) => {
+		const { fullHash, outputOptions } = compilation;
+		// Pre-hash pass: a stand-in, replaced on the post-hash re-render that
+		// `needsInlinedFullHash` asks for. Matches `GetFullHashRuntimeModule`.
+		if (!fullHash) return length ? "x".repeat(length) : "x";
+		const hash = reEncodeDigest(
+			fullHash,
+			outputOptions.hashDigest || "hex",
+			digest
+		);
+		return length ? hash.slice(0, length) : hash;
+	}
+});
+
+module.exports.fullHashPathData = fullHashPathData;
+module.exports.needsRuntimeFullHash = needsRuntimeFullHash;

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -8,12 +8,14 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -22,6 +24,7 @@ const Template = require("../Template");
  * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
  * @property {GenerateBeforeCompileStreaming=} generateBeforeCompileStreaming
  * @property {boolean} supportsStreaming
+ * @property {boolean=} fullHashDigest the binary's name inlines a re-encoded compilation hash
  */
 
 class AsyncWasmCompileRuntimeModule extends RuntimeModule {
@@ -32,9 +35,16 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		generateLoadBinaryCode,
 		generateBeforeLoadBinaryCode,
 		generateBeforeCompileStreaming,
-		supportsStreaming
+		supportsStreaming,
+		fullHashDigest
 	}) {
 		super("wasm compile", RuntimeModule.STAGE_NORMAL);
+		// 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;
+		}
 		/** @type {GenerateLoadBinaryCode} */
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
 		/** @type {GenerateBeforeLoadBinaryCode | undefined} */
@@ -56,24 +66,34 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Opt-out fallback to non-streaming when the server serves wasm with a wrong MIME type.
 		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.compileWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: '" + wasmModuleHash + "',
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
+		// Analyzable output bakes the binary's URL into the call site instead.
+		const analyzable = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			undefined,
+			undefined,
+			chunk.runtime
 		);
+		const wasmModuleSrcPath = analyzable
+			? "wasmModuleUrl"
+			: compilation.getPath(
+					JSON.stringify(outputOptions.webassemblyModuleFilename),
+					{
+						...fullHashPathData(compilation),
+						module: {
+							id: '" + wasmModuleId + "',
+							hash: '" + wasmModuleHash + "',
+							hashWithLength(length) {
+								return `" + wasmModuleHash.slice(0, ${length}) + "`;
+							}
+						},
+						runtime: chunk.runtime
+					}
+				);
 
-		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const loader = this.generateLoadBinaryCode(
+			wasmModuleSrcPath,
+			chunk.runtime
+		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile
 		const fallback = [
@@ -138,7 +158,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		};
 
 		return `${fn} = ${runtimeTemplate.basicFunction(
-			"wasmModuleId, wasmModuleHash",
+			analyzable ? "wasmModuleUrl" : "wasmModuleId, wasmModuleHash",
 			this.supportsStreaming
 				? getStreaming()
 				: [

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -8,12 +8,14 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -22,6 +24,7 @@ const Template = require("../Template");
  * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
  * @property {GenerateBeforeInstantiateStreaming=} generateBeforeInstantiateStreaming
  * @property {boolean} supportsStreaming
+ * @property {boolean=} fullHashDigest the binary's name inlines a re-encoded compilation hash
  */
 
 class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
@@ -32,9 +35,16 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		generateLoadBinaryCode,
 		generateBeforeLoadBinaryCode,
 		generateBeforeInstantiateStreaming,
-		supportsStreaming
+		supportsStreaming,
+		fullHashDigest
 	}) {
 		super("wasm loading", RuntimeModule.STAGE_NORMAL);
+		// 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;
+		}
 		/** @type {GenerateLoadBinaryCode} */
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
 		/** @type {generateBeforeLoadBinaryCode | undefined} */
@@ -57,24 +67,34 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
 		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.instantiateWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: '" + wasmModuleHash + "',
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
+		// Analyzable output bakes the binary's URL into the call site instead.
+		const analyzable = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			undefined,
+			undefined,
+			chunk.runtime
 		);
+		const wasmModuleSrcPath = analyzable
+			? "wasmModuleUrl"
+			: compilation.getPath(
+					JSON.stringify(outputOptions.webassemblyModuleFilename),
+					{
+						...fullHashPathData(compilation),
+						module: {
+							id: '" + wasmModuleId + "',
+							hash: '" + wasmModuleHash + "',
+							hashWithLength(length) {
+								return `" + wasmModuleHash.slice(0, ${length}) + "`;
+							}
+						},
+						runtime: chunk.runtime
+					}
+				);
 
-		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const loader = this.generateLoadBinaryCode(
+			wasmModuleSrcPath,
+			chunk.runtime
+		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
 			`.then(${runtimeTemplate.returningFunction(
@@ -149,7 +169,9 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		};
 
 		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			analyzable
+				? "exports, wasmModuleUrl, importsObj"
+				: "exports, wasmModuleId, wasmModuleHash, importsObj",
 			this.supportsStreaming
 				? getStreaming()
 				: [

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.