@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/asset/WebManifestParser.js

@@ -0,0 +1,130 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { parse } = require("acorn");
+const Parser = require("../Parser");
+const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+// acorn decorates every node with numeric source offsets (absent from the estree types).
+/** @typedef {{ start: number, end: number }} Positioned */
+
+// A URL carrying its own scheme (`https:`, `data:`, …) is external; it is only
+// bundled when `experiments.buildHttp` is enabled (like an absolute URL in HTML).
+const ABSOLUTE_URL_SCHEME_REGEXP = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+// Manifest members whose array items carry an asset `src` (`icons[].src`,
+// `screenshots[].src`, and `shortcuts[].icons[].src` — the last nests under `icons`).
+const ICON_CONTAINER_KEYS = new Set(["icons", "screenshots"]);
+
+/**
+ * Parses a Web App Manifest (`.webmanifest`) so its icon/screenshot `src`
+ * URLs are bundled as assets. Reuses acorn (JSON is a valid JS expression
+ * literal) to recover the exact source offsets, then emits an
+ * `HtmlSourceDependency` per URL so the generator can rewrite it in place.
+ */
+class WebManifestParser extends Parser {
+	/**
+	 * Parses the provided source and updates the parser state.
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf8");
+		} else if (typeof source === "object") {
+			throw new Error("webpackAst is unexpected for the WebManifestParser");
+		}
+		if (source[0] === "") {
+			source = source.slice(1);
+		}
+
+		const module = state.module;
+		// Without `buildHttp` there is no handler to fetch remote icons, so an
+		// absolute URL is left as-is rather than rewritten to an ignored asset.
+		const buildHttp = Boolean(state.options.experiments.buildHttp);
+
+		/** @type {Program | undefined} */
+		let ast;
+		try {
+			// Wrap in parens so the top-level object is an expression, not a block.
+			ast = /** @type {Program} */ (
+				/** @type {unknown} */ (parse(`(${source})`, { ecmaVersion: "latest" }))
+			);
+		} catch (_err) {
+			// Not valid JSON — leave the file untouched (still emitted as-is).
+			ast = undefined;
+		}
+
+		const statement = ast && ast.body[0];
+		if (
+			statement &&
+			statement.type === "ExpressionStatement" &&
+			statement.expression.type === "ObjectExpression"
+		) {
+			/**
+			 * @param {ObjectExpression} obj object expression node
+			 * @param {string | undefined} parentKey key of the array/object this node sits in
+			 */
+			const walk = (obj, parentKey) => {
+				for (const prop of obj.properties) {
+					if (prop.type !== "Property") continue;
+					const key =
+						prop.key.type === "Literal" && typeof prop.key.value === "string"
+							? prop.key.value
+							: prop.key.type === "Identifier"
+								? prop.key.name
+								: undefined;
+					const value = /** @type {Expression} */ (prop.value);
+					if (value.type === "ObjectExpression") {
+						walk(value, key);
+					} else if (value.type === "ArrayExpression") {
+						for (const element of value.elements) {
+							if (element && element.type === "ObjectExpression") {
+								walk(element, key);
+							}
+						}
+					} else if (
+						key === "src" &&
+						value.type === "Literal" &&
+						typeof value.value === "string" &&
+						parentKey !== undefined &&
+						ICON_CONTAINER_KEYS.has(parentKey)
+					) {
+						const url = value.value;
+						// Fragment-only refs aren't assets; absolute URLs need `buildHttp`.
+						if (!url || url.startsWith("#")) continue;
+						if (!buildHttp && ABSOLUTE_URL_SCHEME_REGEXP.test(url)) continue;
+						// acorn offsets are into `(${source})`; the leading `(` and the
+						// opening quote cancel, so the inner span is [start, end - 2].
+						const { start, end } = /** @type {Positioned} */ (
+							/** @type {unknown} */ (value)
+						);
+						const dep = new HtmlSourceDependency(url, [start, end - 2]);
+						module.addDependency(dep);
+						module.addCodeGenerationDependency(dep);
+					}
+				}
+			};
+			walk(statement.expression, undefined);
+		}
+
+		/** @type {BuildInfo} */
+		(state.module.buildInfo).strict = true;
+
+		return state;
+	}
+}
+
+module.exports = WebManifestParser;

package/lib/async-modules/AsyncModuleHelpers.js

@@ -13,6 +13,7 @@ const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency
 /** @typedef {Set<Module>} Modules */
 
 /**
+ * Gets outgoing async modules.
  * @param {ModuleGraph} moduleGraph module graph
  * @param {Module} module module
  * @returns {Modules} set of modules

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -15,13 +15,16 @@ const Template = require("../Template");
 /** @typedef {Map<string, string>} Dependencies */
 
 /**
+ * Represents AwaitDependenciesInitFragment.
  * @extends {InitFragment<GenerateContext>}
  */
 class AwaitDependenciesInitFragment extends InitFragment {
 	/**
+	 * Creates an instance of AwaitDependenciesInitFragment.
 	 * @param {Dependencies} dependencies maps an import var to an async module that needs to be awaited
+	 * @param {boolean=} generatorLowered module is emitted as a generator, so use `yield` instead of `await`
 	 */
-	constructor(dependencies) {
+	constructor(dependencies, generatorLowered = false) {
 		super(
 			undefined,
 			InitFragment.STAGE_ASYNC_DEPENDENCIES,
@@ -30,9 +33,12 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		);
 		/** @type {Dependencies} */
 		this.dependencies = dependencies;
+		/** @type {boolean} */
+		this.generatorLowered = generatorLowered;
 	}
 
 	/**
+	 * Merges another await-dependencies fragment into this fragment.
 	 * @param {AwaitDependenciesInitFragment} other other AwaitDependenciesInitFragment
 	 * @returns {AwaitDependenciesInitFragment} AwaitDependenciesInitFragment
 	 */
@@ -41,10 +47,14 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		for (const [key, value] of this.dependencies) {
 			dependencies.set(key, value);
 		}
-		return new AwaitDependenciesInitFragment(dependencies);
+		return new AwaitDependenciesInitFragment(
+			dependencies,
+			this.generatorLowered || other.generatorLowered
+		);
 	}
 
 	/**
+	 * Returns the source code that will be included as initialization code.
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
@@ -57,6 +67,10 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		const importVars = [...this.dependencies.keys()];
 		const asyncModuleValues = [...this.dependencies.values()].join(", ");
 
+		// In a generator-lowered module (no `async`/`await`, but generators) the
+		// dependency `await` becomes `yield`; the body stays a single scope.
+		const suspend = this.generatorLowered ? "yield" : "await";
+
 		const templateInput = [
 			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${asyncModuleValues}]);`
 		];
@@ -66,7 +80,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			!runtimeTemplate.supportsDestructuring()
 		) {
 			templateInput.push(
-				"var __webpack_async_dependencies_result__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);"
+				`var __webpack_async_dependencies_result__ = (__webpack_async_dependencies__.then ? (${suspend} __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
 			);
 			for (const [index, importVar] of importVars.entries()) {
 				templateInput.push(
@@ -77,7 +91,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			const importVarsStr = importVars.join(", ");
 
 			templateInput.push(
-				`([${importVarsStr}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
+				`([${importVarsStr}] = __webpack_async_dependencies__.then ? (${suspend} __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
 			);
 		}
 

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -14,7 +14,7 @@ const PLUGIN_NAME = "InferAsyncModulesPlugin";
 
 class InferAsyncModulesPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/async-modules/isGeneratorLowered.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+/**
+ * Whether an async module is lowered to a generator: the target has no
+ * `async`/`await` but supports generators, and the module contains no
+ * top-level `for await…of` (which generators can't express).
+ * @param {Module} module module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeTemplate} runtimeTemplate runtime template
+ * @returns {boolean} true when the module should be emitted as a generator
+ */
+const isGeneratorLowered = (module, moduleGraph, runtimeTemplate) =>
+	moduleGraph.isAsync(module) &&
+	!runtimeTemplate.supportsAsyncFunction() &&
+	Boolean(runtimeTemplate.supportsGenerator()) &&
+	!(module.buildInfo && module.buildInfo.usesTopLevelAwaitForOf);
+
+module.exports = isGeneratorLowered;

package/lib/buildChunkGraph.js

@@ -5,9 +5,8 @@
 
 "use strict";
 
-const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");
-const { connectChunkGroupParentAndChild } = require("./GraphHelpers");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const AsyncDependencyToInitialChunkError = require("./errors/AsyncDependencyToInitialChunkError");
 const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -17,6 +16,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -24,6 +24,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
+ * Defines the queue item type used by this module.
  * @typedef {object} QueueItem
  * @property {number} action
  * @property {DependenciesBlock} block
@@ -34,6 +35,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  */
 
 /**
+ * Defines the chunk group info type used by this module.
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
@@ -55,6 +57,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  */
 
 /**
+ * Defines the block chunk group connection type used by this module.
  * @typedef {object} BlockChunkGroupConnection
  * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
  * @property {ChunkGroup} chunkGroup referenced chunk group
@@ -74,6 +77,7 @@ const ZERO_BIGINT = BigInt(0);
 const ONE_BIGINT = BigInt(1);
 
 /**
+ * Checks whether this object is ordinal set in mask.
  * @param {bigint} mask The mask to test
  * @param {number} ordinal The ordinal of the bit to test
  * @returns {boolean} If the ordinal-th bit is set in the mask
@@ -82,6 +86,7 @@ const isOrdinalSetInMask = (mask, ordinal) =>
 	BigInt.asUintN(1, mask >> BigInt(ordinal)) !== ZERO_BIGINT;
 
 /**
+ * Gets active state of connections.
  * @param {ModuleGraphConnection[]} connections list of connections
  * @param {RuntimeSpec} runtime for which runtime
  * @returns {ConnectionState} connection state
@@ -101,6 +106,7 @@ const getActiveStateOfConnections = (connections, runtime) => {
 };
 
 /**
+ * Extract block modules.
  * @param {Module} module module
  * @param {ModuleGraph} moduleGraph module graph
  * @param {RuntimeSpec} runtime runtime
@@ -237,6 +243,45 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 };
 
 /**
+ * Derives block modules for another runtime from an already extracted result.
+ * Only the merged active state of each connection group can differ per
+ * runtime; modules and connection groups are reused. When all states turn
+ * out equal, the tuple array is shared instead of copied.
+ * @param {Module} module the root module
+ * @param {BlockModulesMap} source map containing the extracted result for all blocks of the module
+ * @param {RuntimeSpec} runtime runtime to derive for
+ * @param {BlockModulesMap} blockModulesMap block modules map to fill
+ */
+const deriveBlockModules = (module, source, runtime, blockModulesMap) => {
+	/** @type {DependenciesBlock[]} */
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = /** @type {DependenciesBlock} */ (queue.pop());
+		const sourceModules =
+			/** @type {BlockModulesInFlattenTuples} */
+			(source.get(block));
+		let target = sourceModules;
+		for (let i = 0, len = sourceModules.length; i < len; i += 3) {
+			const state = getActiveStateOfConnections(
+				/** @type {ModuleGraphConnection[]} */ (sourceModules[i + 2]),
+				runtime
+			);
+			if (target === sourceModules) {
+				if (state === sourceModules[i + 1]) continue;
+				// states diverged, copy (states before i are identical)
+				target = [...sourceModules];
+			}
+			target[i + 1] = state;
+		}
+		blockModulesMap.set(block, target);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
+	}
+};
+
+/**
+ * Processes the provided logger.
  * @param {Logger} logger a logger
  * @param {Compilation} compilation the compilation
  * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
@@ -261,13 +306,16 @@ const visitModules = (
 	/** @type {Map<RuntimeSpec, BlockModulesMap>} */
 	const blockModulesRuntimeMap = new Map();
 
-	/** @type {BlockModulesMap | undefined} */
-	let blockModulesMap;
+	// map containing the first extraction per root module,
+	// other runtimes derive their result from it
+	/** @type {Map<Module, BlockModulesMap>} */
+	const firstBlockModulesMapByModule = new Map();
 
 	/** @type {Map<Module, number>} */
 	const ordinalByModule = new Map();
 
 	/**
+	 * Gets module ordinal.
 	 * @param {Module} module The module to look up
 	 * @returns {number} The ordinal of the module in masks
 	 */
@@ -289,12 +337,13 @@ const visitModules = (
 	}
 
 	/**
+	 * Gets block modules.
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
 	 * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
-		blockModulesMap = blockModulesRuntimeMap.get(runtime);
+		let blockModulesMap = blockModulesRuntimeMap.get(runtime);
 		if (blockModulesMap === undefined) {
 			/** @type {BlockModulesMap} */
 			blockModulesMap = new Map();
@@ -312,18 +361,33 @@ const visitModules = (
 				() => {
 					logger.time("visitModules: prepare");
 					const map = new Map();
-					extractBlockModules(module, moduleGraph, runtime, map);
+					const source = firstBlockModulesMapByModule.get(module);
+					if (source !== undefined) {
+						deriveBlockModules(module, source, runtime, map);
+					} else {
+						extractBlockModules(module, moduleGraph, runtime, map);
+					}
 					logger.timeAggregate("visitModules: prepare");
 					return map;
 				}
 			);
+			// allow other runtimes to derive from a memCache hit too
+			if (!firstBlockModulesMapByModule.has(module)) {
+				firstBlockModulesMapByModule.set(module, map);
+			}
 			for (const [block, blockModules] of map) {
 				blockModulesMap.set(block, blockModules);
 			}
 			return map.get(block);
 		}
 		logger.time("visitModules: prepare");
-		extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+		const source = firstBlockModulesMapByModule.get(module);
+		if (source !== undefined) {
+			deriveBlockModules(module, source, runtime, blockModulesMap);
+		} else {
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			firstBlockModulesMapByModule.set(module, blockModulesMap);
+		}
 		blockModules =
 			/** @type {BlockModulesInFlattenTuples} */
 			(blockModulesMap.get(block));
@@ -493,6 +557,7 @@ const visitModules = (
 
 	// For each async Block in graph
 	/**
+	 * Processes the provided b.
 	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
 	 * @returns {void}
 	 */
@@ -572,7 +637,27 @@ const visitModules = (
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// TODO merge entryOptions
+					// Fill in options the existing entrypoint hasn't set yet. We never
+					// overwrite: blocks that dedupe to one entrypoint (e.g. several
+					// workers pointing at the same module) legitimately carry distinct
+					// values such as `runtime`, so the first block to create the
+					// entrypoint wins and later ones only contribute missing keys.
+					// `name` is excluded: it is the entrypoint's identity, fixed at
+					// creation (and used to key namedChunkGroups), so back-filling it
+					// from a block that deduped in via its module would leave
+					// `entrypoint.name` out of sync and make module codegen
+					// order-dependent, which breaks persistent caching.
+					const existingOptions = entrypoint.options;
+					for (const key_ of Object.keys(entryOptions)) {
+						const key =
+							/** @type {keyof EntryOptions} */
+							(key_);
+						if (key === "name") continue;
+						if (entryOptions[key] === undefined) continue;
+						if (existingOptions[key] !== undefined) continue;
+						/** @type {EntryOptions[keyof EntryOptions]} */
+						(existingOptions[key]) = entryOptions[key];
+					}
 					entrypoint.addOrigin(
 						module,
 						/** @type {DependencyLocation} */ (b.loc),
@@ -699,6 +784,7 @@ const visitModules = (
 	};
 
 	/**
+	 * Processes the provided block.
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
@@ -723,7 +809,6 @@ const visitModules = (
 					continue;
 				}
 
-				const refOrdinal = /** @type {number} */ getModuleOrdinal(refModule);
 				const activeState = /** @type {ConnectionState} */ (
 					blockModules[i + 1]
 				);
@@ -734,7 +819,10 @@ const visitModules = (
 					skipConnectionBuffer.push([refModule, connections]);
 					// We skip inactive connections
 					if (activeState === false) continue;
-				} else if (isOrdinalSetInMask(minAvailableModules, refOrdinal)) {
+				} else if (
+					// assigning ordinals lazily here keeps masks small
+					isOrdinalSetInMask(minAvailableModules, getModuleOrdinal(refModule))
+				) {
 					// already in parent chunks, skip it for now
 					skipBuffer.push(refModule);
 					continue;
@@ -791,6 +879,7 @@ const visitModules = (
 	};
 
 	/**
+	 * Process entry block.
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
@@ -918,6 +1007,7 @@ const visitModules = (
 	};
 
 	/**
+	 * Calculate resulting available modules.
 	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
 	 * @returns {bigint} The mask of available modules after the chunk group
 	 */
@@ -1193,6 +1283,7 @@ const visitModules = (
 			let preOrderIndex = 0;
 			let postOrderIndex = 0;
 			/**
+			 * Processes the provided current.
 			 * @param {DependenciesBlock} current current
 			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
 			 */
@@ -1240,6 +1331,7 @@ const visitModules = (
 };
 
 /**
+ * Connects chunk groups.
  * @param {Compilation} compilation the compilation
  * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
  * @param {BlockConnections} blockConnections connection for blocks
@@ -1276,7 +1368,8 @@ const connectChunkGroups = (
 		// connections and modules can only create one version
 		// TODO maybe decide this per runtime
 		if (
-			// TODO is this needed?
+			// Blocks with nested blocks must stay connected — skipping orphans the
+			// nested block's chunk group from this block's chunk group parent.
 			!blocksWithNestedBlocks.has(block) &&
 			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
 				areModulesAvailable(
@@ -1296,10 +1389,9 @@ const connectChunkGroups = (
 			chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
 
 			// 4. Connect chunk with parent
-			connectChunkGroupParentAndChild(
-				originChunkGroupInfo.chunkGroup,
-				chunkGroup
-			);
+			if (originChunkGroupInfo.chunkGroup.addChild(chunkGroup)) {
+				chunkGroup.addParent(originChunkGroupInfo.chunkGroup);
+			}
 		}
 	}
 };

package/lib/bun/BunTargetPlugin.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+const ExternalsPlugin = require("../ExternalsPlugin");
+const { coreModules } = require("../node/nodeBuiltins");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+// Bun exposes the node.js core modules; externalize them with the `node:`
+// specifier (Bun resolves both forms) like the deno target.
+
+// Bun's own built-in modules (`bun`, `bun:sqlite`, ...) are provided by the
+// runtime, never bundled.
+const BUN_BUILTINS = /^bun(?::|$)/;
+
+class BunTargetPlugin {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ExternalsPlugin(
+			(dependency) =>
+				dependency.category === "commonjs" ? "node-commonjs" : "module-import",
+			({ request }, callback) => {
+				if (!request) return callback();
+				if (request.startsWith("node:") || BUN_BUILTINS.test(request)) {
+					return callback(null, request);
+				}
+				if (coreModules.has(request)) return callback(null, `node:${request}`);
+				callback();
+			}
+		).apply(compiler);
+	}
+}
+
+module.exports = BunTargetPlugin;

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -11,14 +11,16 @@ const PLUGIN_NAME = "AddBuildDependenciesPlugin";
 
 class AddBuildDependenciesPlugin {
 	/**
+	 * Creates an instance of AddBuildDependenciesPlugin.
 	 * @param {Iterable<string>} buildDependencies list of build dependencies
 	 */
 	constructor(buildDependencies) {
+		/** @type {Set<string>} */
 		this.buildDependencies = new Set(buildDependencies);
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/cache/AddManagedPathsPlugin.js

@@ -9,18 +9,22 @@
 
 class AddManagedPathsPlugin {
 	/**
+	 * Creates an instance of AddManagedPathsPlugin.
 	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
 	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
 	 * @param {Iterable<string | RegExp>} unmanagedPaths list of unmanaged paths
 	 */
 	constructor(managedPaths, immutablePaths, unmanagedPaths) {
+		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set(managedPaths);
+		/** @type {Set<string | RegExp>} */
 		this.immutablePaths = new Set(immutablePaths);
+		/** @type {Set<string | RegExp>} */
 		this.unmanagedPaths = new Set(unmanagedPaths);
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/cache/IdleFileCachePlugin.js

@@ -16,6 +16,7 @@ const PLUGIN_NAME = "IdleFileCachePlugin";
 
 class IdleFileCachePlugin {
 	/**
+	 * Creates an instance of IdleFileCachePlugin.
 	 * @param {PackFileCacheStrategy} strategy cache strategy
 	 * @param {number} idleTimeout timeout
 	 * @param {number} idleTimeoutForInitialStore initial timeout
@@ -27,14 +28,18 @@ class IdleFileCachePlugin {
 		idleTimeoutForInitialStore,
 		idleTimeoutAfterLargeChanges
 	) {
+		/** @type {PackFileCacheStrategy} */
 		this.strategy = strategy;
+		/** @type {number} */
 		this.idleTimeout = idleTimeout;
+		/** @type {number} */
 		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+		/** @type {number} */
 		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/cache/MemoryCachePlugin.js

@@ -13,7 +13,7 @@ const Cache = require("../Cache");
 
 class MemoryCachePlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */