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

package/lib/FileSystemInfo.js

@@ -297,6 +297,22 @@ class SnapshotIterable {
 /** @typedef {Set<string>} ManagedMissing */
 /** @typedef {Set<Snapshot>} Children */
 
+// `Snapshot._flags` bit for each optional field. Serialized as a whole integer,
+// so these values are a persisted-cache format contract — never renumber them.
+const SNAPSHOT_FLAG_START_TIME = 1;
+const SNAPSHOT_FLAG_FILE_TIMESTAMPS = 2;
+const SNAPSHOT_FLAG_FILE_HASHES = 4;
+const SNAPSHOT_FLAG_FILE_TSHS = 8;
+const SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS = 0x10;
+const SNAPSHOT_FLAG_CONTEXT_HASHES = 0x20;
+const SNAPSHOT_FLAG_CONTEXT_TSHS = 0x40;
+const SNAPSHOT_FLAG_MISSING_EXISTENCE = 0x80;
+const SNAPSHOT_FLAG_MANAGED_ITEM_INFO = 0x100;
+const SNAPSHOT_FLAG_MANAGED_FILES = 0x200;
+const SNAPSHOT_FLAG_MANAGED_CONTEXTS = 0x400;
+const SNAPSHOT_FLAG_MANAGED_MISSING = 0x800;
+const SNAPSHOT_FLAG_CHILDREN = 0x1000;
+
 class Snapshot {
 	constructor() {
 		/** @type {number} */
@@ -336,7 +352,7 @@ class Snapshot {
 	}
 
 	hasStartTime() {
-		return (this._flags & 1) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_START_TIME) !== 0;
 	}
 
 	/**
@@ -344,7 +360,7 @@ class Snapshot {
 	 * @param {number} value start value
 	 */
 	setStartTime(value) {
-		this._flags |= 1;
+		this._flags |= SNAPSHOT_FLAG_START_TIME;
 		this.startTime = value;
 	}
 
@@ -375,7 +391,7 @@ class Snapshot {
 	}
 
 	hasFileTimestamps() {
-		return (this._flags & 2) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -383,12 +399,12 @@ class Snapshot {
 	 * @param {FileTimestamps} value file timestamps
 	 */
 	setFileTimestamps(value) {
-		this._flags |= 2;
+		this._flags |= SNAPSHOT_FLAG_FILE_TIMESTAMPS;
 		this.fileTimestamps = value;
 	}
 
 	hasFileHashes() {
-		return (this._flags & 4) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_HASHES) !== 0;
 	}
 
 	/**
@@ -396,12 +412,12 @@ class Snapshot {
 	 * @param {FileHashes} value file hashes
 	 */
 	setFileHashes(value) {
-		this._flags |= 4;
+		this._flags |= SNAPSHOT_FLAG_FILE_HASHES;
 		this.fileHashes = value;
 	}
 
 	hasFileTshs() {
-		return (this._flags & 8) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TSHS) !== 0;
 	}
 
 	/**
@@ -409,12 +425,12 @@ class Snapshot {
 	 * @param {FileTshs} value file tshs
 	 */
 	setFileTshs(value) {
-		this._flags |= 8;
+		this._flags |= SNAPSHOT_FLAG_FILE_TSHS;
 		this.fileTshs = value;
 	}
 
 	hasContextTimestamps() {
-		return (this._flags & 0x10) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -422,12 +438,12 @@ class Snapshot {
 	 * @param {ContextTimestamps} value context timestamps
 	 */
 	setContextTimestamps(value) {
-		this._flags |= 0x10;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS;
 		this.contextTimestamps = value;
 	}
 
 	hasContextHashes() {
-		return (this._flags & 0x20) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_HASHES) !== 0;
 	}
 
 	/**
@@ -435,12 +451,12 @@ class Snapshot {
 	 * @param {ContextHashes} value context hashes
 	 */
 	setContextHashes(value) {
-		this._flags |= 0x20;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_HASHES;
 		this.contextHashes = value;
 	}
 
 	hasContextTshs() {
-		return (this._flags & 0x40) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TSHS) !== 0;
 	}
 
 	/**
@@ -448,12 +464,12 @@ class Snapshot {
 	 * @param {ContextTshs} value context tshs
 	 */
 	setContextTshs(value) {
-		this._flags |= 0x40;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TSHS;
 		this.contextTshs = value;
 	}
 
 	hasMissingExistence() {
-		return (this._flags & 0x80) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MISSING_EXISTENCE) !== 0;
 	}
 
 	/**
@@ -461,12 +477,12 @@ class Snapshot {
 	 * @param {MissingExistence} value context tshs
 	 */
 	setMissingExistence(value) {
-		this._flags |= 0x80;
+		this._flags |= SNAPSHOT_FLAG_MISSING_EXISTENCE;
 		this.missingExistence = value;
 	}
 
 	hasManagedItemInfo() {
-		return (this._flags & 0x100) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_ITEM_INFO) !== 0;
 	}
 
 	/**
@@ -474,12 +490,12 @@ class Snapshot {
 	 * @param {ManagedItemInfo} value managed item info
 	 */
 	setManagedItemInfo(value) {
-		this._flags |= 0x100;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_ITEM_INFO;
 		this.managedItemInfo = value;
 	}
 
 	hasManagedFiles() {
-		return (this._flags & 0x200) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_FILES) !== 0;
 	}
 
 	/**
@@ -487,12 +503,12 @@ class Snapshot {
 	 * @param {ManagedFiles} value managed files
 	 */
 	setManagedFiles(value) {
-		this._flags |= 0x200;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_FILES;
 		this.managedFiles = value;
 	}
 
 	hasManagedContexts() {
-		return (this._flags & 0x400) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_CONTEXTS) !== 0;
 	}
 
 	/**
@@ -500,12 +516,12 @@ class Snapshot {
 	 * @param {ManagedContexts} value managed contexts
 	 */
 	setManagedContexts(value) {
-		this._flags |= 0x400;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_CONTEXTS;
 		this.managedContexts = value;
 	}
 
 	hasManagedMissing() {
-		return (this._flags & 0x800) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_MISSING) !== 0;
 	}
 
 	/**
@@ -513,12 +529,12 @@ class Snapshot {
 	 * @param {ManagedMissing} value managed missing
 	 */
 	setManagedMissing(value) {
-		this._flags |= 0x800;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_MISSING;
 		this.managedMissing = value;
 	}
 
 	hasChildren() {
-		return (this._flags & 0x1000) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CHILDREN) !== 0;
 	}
 
 	/**
@@ -526,7 +542,7 @@ class Snapshot {
 	 * @param {Children} value children
 	 */
 	setChildren(value) {
-		this._flags |= 0x1000;
+		this._flags |= SNAPSHOT_FLAG_CHILDREN;
 		this.children = value;
 	}
 
@@ -1221,6 +1237,58 @@ const addAll = (source, target) => {
 
 const getEsModuleLexer = memoize(() => require("es-module-lexer"));
 
+const getAcorn = memoize(/* istanbul ignore next */ () => require("acorn"));
+
+// Bun doesn't populate `require.cache` `module.children`, so the CJS build-dependency
+// walk needs a source-parsing fallback there. Node/Deno populate it — never pay for it.
+const IS_BUN = Boolean(process.versions.bun);
+
+/**
+ * Collects static `require("literal")` specifiers from CommonJS source. Used as a
+ * fallback where `require.cache` children aren't populated (e.g. Bun), so build
+ * dependencies of a CJS file are still tracked. Dynamic requires can't be seen here.
+ * @param {string} source source
+ * @returns {Set<string>} required specifiers
+ */
+// Bun-only: exercised by BuildDependencies.longtest under the Bun CI job (no coverage upload).
+/* istanbul ignore next */
+const parseCjsRequires = (source) => {
+	/** @type {Set<string>} */
+	const requires = new Set();
+	const ast = getAcorn().parse(source, {
+		ecmaVersion: "latest",
+		sourceType: "script",
+		allowReturnOutsideFunction: true
+	});
+	/** @type {EXPECTED_ANY[]} */
+	const stack = [ast];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node || typeof node.type !== "string") continue;
+		if (
+			node.type === "CallExpression" &&
+			node.callee.type === "Identifier" &&
+			node.callee.name === "require" &&
+			node.arguments.length === 1 &&
+			node.arguments[0].type === "Literal" &&
+			typeof node.arguments[0].value === "string"
+		) {
+			requires.add(node.arguments[0].value);
+		}
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) {
+					if (item && typeof item.type === "string") stack.push(item);
+				}
+			} else if (value && typeof value.type === "string") {
+				stack.push(value);
+			}
+		}
+	}
+	return requires;
+};
+
 /** @typedef {Set<string>} LoggedPaths */
 
 /** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */
@@ -2213,6 +2281,38 @@ class FileSystemInfo {
 									});
 								}
 							}
+							// On Bun the children array is empty (unpopulated), so recover the
+							// static require() specifiers by parsing the source; Node/Deno don't.
+							/* istanbul ignore next */
+							if (IS_BUN && module.children.length === 0) {
+								this.fs.readFile(path, (err, content) => {
+									if (err) return callback(err);
+									try {
+										const context = dirname(this.fs, path);
+										const source = /** @type {Buffer} */ (content).toString();
+										/** @type {Set<string>} */
+										const added = new Set();
+										for (const dependency of parseCjsRequires(source)) {
+											if (dependency.startsWith("node:")) continue;
+											if (builtinModules.has(dependency)) continue;
+											if (added.has(dependency)) continue;
+											push({
+												type: RBDT_RESOLVE_CJS_FILE,
+												context,
+												path: dependency,
+												// Best effort: tolerate specifiers that don't resolve.
+												expected: false,
+												issuer: job
+											});
+											added.add(dependency);
+										}
+									} catch (_err) {
+										// Source we can't parse as CommonJS — ignore its dependencies.
+									}
+									process.nextTick(callback);
+								});
+								break;
+							}
 						} else if (supportsEsm && /\.m?js$/.test(path)) {
 							if (!this._warnAboutExperimentalEsmTracking) {
 								logger.log(

package/lib/FlagDependencyUsagePlugin.js

@@ -30,6 +30,19 @@ const {
 const PLUGIN_NAME = "FlagDependencyUsagePlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
+// Hoisted stateless predicates for setUsedConditionally on the innermost
+// used-export loop, so they aren't re-allocated per export.
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether unused
+ */
+const IS_UNUSED = (used) => used === UsageState.Unused;
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether not used
+ */
+const IS_NOT_USED = (used) => used !== UsageState.Used;
+
 class FlagDependencyUsagePlugin {
 	/**
 	 * Creates an instance of FlagDependencyUsagePlugin.
@@ -162,7 +175,7 @@ class FlagDependencyUsagePlugin {
 											if (nestedInfo) {
 												if (
 													exportInfo.setUsedConditionally(
-														(used) => used === UsageState.Unused,
+														IS_UNUSED,
 														UsageState.OnlyPropertiesUsed,
 														runtime
 													)
@@ -181,7 +194,7 @@ class FlagDependencyUsagePlugin {
 										}
 										if (
 											exportInfo.setUsedConditionally(
-												(v) => v !== UsageState.Used,
+												IS_NOT_USED,
 												UsageState.Used,
 												runtime
 											)
@@ -229,8 +242,9 @@ class FlagDependencyUsagePlugin {
 						// Modules whose whole namespace object escapes in a mangleable way.
 						// Tracked separately so specific member references are still merged
 						// (and marked used) instead of being dropped by the escape marker.
-						/** @type {Set<Module>} */
-						const mangleableEscapeModules = new Set();
+						// Lazily allocated — usually empty.
+						/** @type {Set<Module> | undefined} */
+						let mangleableEscapeModules;
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
 						const queue = new ArrayQueue();
@@ -273,7 +287,9 @@ class FlagDependencyUsagePlugin {
 								// conservative result and always wins.
 								if (referencedExports === EXPORTS_OBJECT_REFERENCED) {
 									map.set(module, EXPORTS_OBJECT_REFERENCED);
-									mangleableEscapeModules.delete(module);
+									if (mangleableEscapeModules) {
+										mangleableEscapeModules.delete(module);
+									}
 									continue;
 								}
 								// A mangleable whole-object escape keeps the module's exports
@@ -284,6 +300,9 @@ class FlagDependencyUsagePlugin {
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {
+									if (mangleableEscapeModules === undefined) {
+										mangleableEscapeModules = new Set();
+									}
 									mangleableEscapeModules.add(module);
 									continue;
 								}
@@ -358,13 +377,15 @@ class FlagDependencyUsagePlugin {
 								);
 							}
 						}
-						for (const module of mangleableEscapeModules) {
-							processReferencedModule(
-								module,
-								EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
-								runtime,
-								forceSideEffects
-							);
+						if (mangleableEscapeModules) {
+							for (const module of mangleableEscapeModules) {
+								processReferencedModule(
+									module,
+									EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
+									runtime,
+									forceSideEffects
+								);
+							}
 						}
 					};
 

package/lib/InitFragment.js

@@ -28,30 +28,6 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>[]) => MaybeMergeableInitFragment<GenerateContext>[]=} mergeAll
  */
 
-/**
- * Extract fragment index.
- * @template T
- * @param {T} fragment the init fragment
- * @param {number} index index
- * @returns {[T, number]} tuple with both
- */
-const extractFragmentIndex = (fragment, index) => [fragment, index];
-
-/**
- * Sorts fragment with index.
- * @template T
- * @param {[MaybeMergeableInitFragment<T>, number]} a first pair
- * @param {[MaybeMergeableInitFragment<T>, number]} b second pair
- * @returns {number} sort value
- */
-const sortFragmentWithIndex = ([a, i], [b, j]) => {
-	const stageCmp = a.stage - b.stage;
-	if (stageCmp !== 0) return stageCmp;
-	const positionCmp = a.position - b.position;
-	if (positionCmp !== 0) return positionCmp;
-	return i - j;
-};
-
 /**
  * Represents InitFragment.
  * @template GenerateContext
@@ -107,16 +83,28 @@ class InitFragment {
 	 */
 	static addToSource(source, initFragments, context) {
 		if (initFragments.length > 0) {
-			// Sort fragments by position. If 2 fragments have the same position,
-			// use their index.
-			const sortedFragments = initFragments
-				.map(extractFragmentIndex)
-				.sort(sortFragmentWithIndex);
+			// Sort fragment indices by (stage, position), falling back to the
+			// original index — one flat number array instead of N [fragment, index]
+			// tuples for a stable-by-index order.
+			const sortedIndices = initFragments.map((_, index) => index);
+			sortedIndices.sort((a, b) => {
+				const fragmentA = initFragments[a];
+				const fragmentB = initFragments[b];
+				const stageCmp = fragmentA.stage - fragmentB.stage;
+				if (stageCmp !== 0) return stageCmp;
+				const positionCmp = fragmentA.position - fragmentB.position;
+				if (positionCmp !== 0) return positionCmp;
+				return a - b;
+			});
 
 			// Deduplicate fragments. If a fragment has no key, it is always included.
-			/** @type {Map<InitFragmentKey | symbol, MaybeMergeableInitFragment<Context> | MaybeMergeableInitFragment<Context>[]>} */
+			// Keyless fragments get a unique numeric key; number keys never collide
+			// with the string `InitFragmentKey`s used for keyed fragments.
+			/** @type {Map<InitFragmentKey | number, MaybeMergeableInitFragment<Context> | MaybeMergeableInitFragment<Context>[]>} */
 			const keyedFragments = new Map();
-			for (const [fragment] of sortedFragments) {
+			let keylessKey = 0;
+			for (const index of sortedIndices) {
+				const fragment = initFragments[index];
 				if (typeof fragment.mergeAll === "function") {
 					if (!fragment.key) {
 						throw new Error(
@@ -142,7 +130,7 @@ class InitFragment {
 						continue;
 					}
 				}
-				keyedFragments.set(fragment.key || Symbol("fragment key"), fragment);
+				keyedFragments.set(fragment.key || keylessKey++, fragment);
 			}
 
 			const concatSource = new ConcatSource();

package/lib/ModuleFilenameHelpers.js

@@ -169,11 +169,14 @@ ModuleFilenameHelpers.createFilename = (
 	let moduleId;
 	/** @type {ReturnStringCallback} */
 	let shortIdentifier;
+	/** @type {ReturnStringCallback} */
+	let resourceIdentifier;
 	if (typeof module === "string") {
 		shortIdentifier =
 			/** @type {ReturnStringCallback} */
 			(memoize(() => requestShortener.shorten(module)));
 		identifier = shortIdentifier;
+		resourceIdentifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () =>
 			/** @type {string} */ (module.split("!").pop());
@@ -182,6 +185,14 @@ ModuleFilenameHelpers.createFilename = (
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
 		);
+		// `[resource]` and `[loaders]` must stay request paths: a subclass's
+		// readable identifier may carry display-only decorations (e.g. CssModule's
+		// `css ` prefix)
+		resourceIdentifier = memoize(() =>
+			module instanceof NormalModule
+				? /** @type {string} */ (requestShortener.shorten(module.userRequest))
+				: module.readableIdentifier(requestShortener)
+		);
 		identifier =
 			/** @type {ReturnStringCallback} */
 			(memoize(() => requestShortener.shorten(module.identifier())));
@@ -196,9 +207,9 @@ ModuleFilenameHelpers.createFilename = (
 	}
 	const resource =
 		/** @type {ReturnStringCallback} */
-		(memoize(() => shortIdentifier().split("!").pop()));
+		(memoize(() => resourceIdentifier().split("!").pop()));
 
-	const loaders = getBefore(shortIdentifier, "!");
+	const loaders = getBefore(resourceIdentifier, "!");
 	const allLoaders = getBefore(identifier, "!");
 	const query = getAfter(resource, "?");
 	const resourcePath = () => {