webpack 5.111.0 → 5.111.1

package/lib/APIPlugin.js

@@ -45,10 +45,9 @@ const getConcatenatedModule = memoize(() =>
 /** @import { RuntimeSpec } from "./util/runtime" */
 /** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
 
-// Modules that reassign `__webpack_public_path__` at runtime, by compilation. A baked
-// analyzable specifier can't reflect that, so those forms fall back. Also recorded per
-// module in `buildInfo`, because a module restored from the persistent cache is never
-// re-parsed and would otherwise lose the flag.
+// Modules reassigning `__webpack_public_path__` at runtime, per compilation, since
+// a baked specifier cannot reflect that. Also kept in `buildInfo`: a module
+// restored from the persistent cache is never re-parsed.
 /** @type {WeakMap<Compilation, Set<Module>>} */
 const runtimePublicPathOverride = new WeakMap();
 

package/lib/CompatibilityPlugin.js

@@ -180,10 +180,9 @@ class CompatibilityPlugin {
 							});
 							return true;
 						});
-					// `const`/`let` are block-pre-walked, by which point the name is no
-					// longer free and `hooks.pattern` is not dispatched for it — tag
-					// them through the kind-specific declaration hooks instead.
-					// Returning nothing lets the variable be defined, keeping the tag.
+					// `const` and `let` are block-pre-walked, by which point the name is no
+					// longer free and `hooks.pattern` never fires, so they are tagged
+					// through the declaration hooks instead.
 					for (const hookMap of [
 						parser.hooks.varDeclarationConst,
 						parser.hooks.varDeclarationLet

package/lib/Compilation.js

@@ -27,6 +27,9 @@ const Dependency = require("./Dependency");
 const DependencyTemplates = require("./DependencyTemplates");
 const Entrypoint = require("./Entrypoint");
 const ErrorHelpers = require("./ErrorHelpers");
+
+const { toError } = ErrorHelpers;
+
 const FileSystemInfo = require("./FileSystemInfo");
 const LazyBarrelController = require("./LazyBarrel");
 const MainTemplate = require("./MainTemplate");
@@ -2371,7 +2374,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (err) {
 					const notFoundError = new (getModuleNotFoundError())(
 						originModule,
-						err,
+						toError(err),
 						/** @type {DependencyLocation} */
 						(dependencies.map((d) => d.loc).find(Boolean))
 					);
@@ -2656,12 +2659,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return;
 			}
 
-			// lazy barrel:
-			// 1. first call: barrel module is not classified yet, so this records the requested
-			//    ids and returns undefined; the targets get built below when
-			//    `processModuleDependencies` runs `_lazyBarrelController.classify` and replays them.
-			// 2. later call: barrel module is already built, so `processModuleDependencies` won't
-			//    re-walk it; the newly requested targets must be built here.
+			// lazy barrel: on the first call the module is unclassified, so this only
+			// records the ids and `processModuleDependencies` replays them. Later the
+			// module is built and never re-walked, so the targets are built here.
 			const unlazyItems = this._lazyBarrelController.request(
 				module,
 				dependencies
@@ -4187,7 +4187,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						// Reported and carried on with, as the first pass does: a throw
 						// here would leave the build with no error to show for it.
 						this.errors.push(
-							new (getCodeGenerationError())(module, /** @type {Error} */ (err))
+							new (getCodeGenerationError())(module, toError(err))
 						);
 						result = {
 							sources: new Map(),
@@ -4377,9 +4377,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					compilation: this
 				});
 			} catch (err) {
-				errors.push(
-					new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-				);
+				errors.push(new (getCodeGenerationError())(module, toError(err)));
 				result = {
 					sources: new Map(),
 					runtimeRequirements: null,
@@ -4430,9 +4428,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						result.data.set("analyzableBailouts", bailouts);
 					}
 				} catch (err) {
-					errors.push(
-						new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-					);
+					errors.push(new (getCodeGenerationError())(module, toError(err)));
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null,
@@ -5208,22 +5204,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 
 		this.logger.time("hashing: sort chunks");
-		/*
-		 * Chunks are hashed in 4 categories, in this order:
-		 * 1. Async chunks - no hash dependencies on other chunks
-		 * 2. Non-entry initial chunks (e.g. shared split chunks) - no hash
-		 *    dependencies on other chunks, but runtime chunks may read their
-		 *    hashes via GetChunkFilenameRuntimeModule (dependentHash)
-		 * 3. Runtime chunks - may use hashes of async and non-entry initial
-		 *    chunks (via GetChunkFilenameRuntimeModule). Ordered by references
-		 *    between each other (for async entrypoints)
-		 * 4. Entry chunks - may depend on runtimeChunk.hash (via
-		 *    createChunkHashHandler for ESM/CJS entry importing runtime)
-		 *
-		 * This ordering ensures all hash dependencies flow in one direction:
-		 * async/initial → runtime → entry, with no circular dependencies.
-		 * Chunks within each category are sorted by id for determinism.
-		 */
+		// Hashed as async, then non-entry initial, then runtime, then entry chunks,
+		// so hash dependencies flow one way between those groups. A cycle among the
+		// runtime chunks is still possible, and is warned about below.
 		/** @type {Chunk[]} */
 		const unorderedRuntimeChunks = [];
 		/** @type {Chunk[]} */
@@ -5410,9 +5393,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.hooks.contentHash.call(chunk);
 				}
 			} catch (err) {
-				this.errors.push(
-					new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
-				);
+				this.errors.push(new (getChunkRenderError())(chunk, "", toError(err)));
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
@@ -5926,7 +5907,7 @@ This prevents using hashes of each other and should be avoided.`);
 					});
 				} catch (err) {
 					this.errors.push(
-						new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
+						new (getChunkRenderError())(chunk, "", toError(err))
 					);
 					return callback();
 				}
@@ -5965,7 +5946,7 @@ This prevents using hashes of each other and should be avoided.`);
 											: "");
 
 								this.errors.push(
-									new (getChunkRenderError())(chunk, filename, err)
+									new (getChunkRenderError())(chunk, filename, toError(err))
 								);
 								inTry = false;
 								return callback();

package/lib/Compiler.js

@@ -16,12 +16,12 @@ const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
-const ContextModuleFactory = require("./ContextModuleFactory");
 const ModuleGraph = require("./ModuleGraph");
 const NormalModuleFactory = require("./NormalModuleFactory");
 const RequestShortener = require("./RequestShortener");
 const ResolverFactory = require("./ResolverFactory");
 const Stats = require("./Stats");
+const ContextModuleFactory = require("./context/ContextModuleFactory");
 const WebpackError = require("./errors/WebpackError");
 const { Logger } = require("./logging/Logger");
 const asyncLib = require("./util/async");
@@ -1063,10 +1063,9 @@ ${other}`);
 
 							updateWithReplacementSource(content.length);
 
-							// if it exists and content on disk matches content
-							// skip writing the same content again
-							// (to keep mtime and don't trigger watchers)
-							// for a fast negative match file size is compared first
+							// Skip rewriting content already on disk, which would move the
+							// mtime and wake watchers. Size is compared first, as a cheap
+							// negative match.
 							if (content.length === stats.size) {
 								compilation.comparedForEmitAssets.add(file);
 								return /** @type {OutputFileSystem} */ (

package/lib/ConstPlugin.js

@@ -219,17 +219,8 @@ class ConstPlugin {
 								} else {
 									parser.walkExpression(expression.test);
 								}
-								// Expressions do not hoist.
-								// It is safe to remove the dead branch.
-								//
-								// Given the following code:
-								//
-								//   false ? someExpression() : otherExpression();
-								//
-								// the generated code is:
-								//
-								//   false ? 0 : otherExpression();
-								//
+								// Expressions do not hoist, so the dead branch is safe to remove:
+								// `false ? someExpression() : other()` becomes `false ? 0 : other()`.
 								const branchToRemove = bool
 									? expression.alternate
 									: expression.consequent;
@@ -254,49 +245,9 @@ class ConstPlugin {
 								const param = parser.evaluateExpression(expression.left);
 								const bool = param.asBool();
 								if (typeof bool === "boolean") {
-									// Expressions do not hoist.
-									// It is safe to remove the dead branch.
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   falsyExpression() && false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   true && someExpression();
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   truthyExpression() || false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   false && someExpression();
-									//
+									// Expressions do not hoist, so the dead branch is safe to remove.
+									// Whichever side cannot decide the result is replaced, leaving the
+									// deciding side and its side effects in place.
 									const keepRight =
 										(expression.operator === "&&" && bool) ||
 										(expression.operator === "||" && !bool);
@@ -305,14 +256,8 @@ class ConstPlugin {
 										!param.couldHaveSideEffects() &&
 										(param.isBoolean() || keepRight)
 									) {
-										// for case like
-										//
-										//   return'development'===process.env.NODE_ENV&&'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnfalse&&'foo'
-										//
+										// The bool needs a leading space: `return'a'===b&&'foo'` would
+										// otherwise become `returnfalse&&'foo'`.
 										const dep = new ConstDependency(
 											` ${bool}`,
 											/** @type {Range} */ (param.range)
@@ -336,36 +281,12 @@ class ConstPlugin {
 								const param = parser.evaluateExpression(expression.left);
 								const keepRight = param.asNullish();
 								if (typeof keepRight === "boolean") {
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nonNullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   nonNullish ?? 0;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   null ?? someExpression();
-									//
+									// `nonNullish ?? x` becomes `nonNullish ?? 0`, and `nullish ?? x`
+									// becomes `null ?? x`: the unreachable side is replaced.
 									if (!param.couldHaveSideEffects() && keepRight) {
 										// cspell:word returnnull
-										// for case like
-										//
-										//   return('development'===process.env.NODE_ENV&&null)??'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnnull??'foo'
-										//
+										// As above, the value needs a leading space, or `return(…&&null)`
+										// would become `returnnull??'foo'`.
 										const dep = new ConstDependency(
 											" null",
 											/** @type {Range} */ (param.range)
@@ -423,18 +344,8 @@ class ConstPlugin {
 							);
 
 							if (evaluated.asNullish()) {
-								// ------------------------------------------
-								//
-								// Given the following code:
-								//
-								//   nullishMemberChain?.a.b();
-								//
-								// the generated code is:
-								//
-								//   undefined;
-								//
-								// ------------------------------------------
-								//
+								// A nullish chain short-circuits whole, so `nullish?.a.b()`
+								// becomes `undefined`.
 								const dep = new ConstDependency(
 									" undefined",
 									/** @type {Range} */ (expr.range)
@@ -519,36 +430,9 @@ class ConstPlugin {
 	 * @returns {void}
 	 */
 	eliminateUnusedStatement(parser, statement, alwaysInBlock) {
-		// Before removing the unused branch, the hoisted declarations
-		// must be collected.
-		//
-		// Given the following code:
-		//
-		//     if (true) f() else g()
-		//     if (false) {
-		//       function f() {}
-		//       const g = function g() {}
-		//       if (someTest) {
-		//         let a = 1
-		//         var x, {y, z} = obj
-		//       }
-		//     } else {
-		//       …
-		//     }
-		//
-		// the generated code is:
-		//
-		//     if (true) f() else {}
-		//     if (false) {
-		//       var f, x, y, z;   (in loose mode)
-		//       var x, y, z;      (in strict mode)
-		//     } else {
-		//       …
-		//     }
-		//
-		// NOTE: When code runs in strict mode, `var` declarations
-		// are hoisted but `function` declarations don't.
-		//
+		// The hoisted declarations must be collected before the unused branch goes,
+		// since the removed code still contributes them. In strict mode `var` is
+		// hoisted but `function` is not, so the two modes collect different sets.
 		const declarations = parser.scope.isStrict
 			? getHoistedDeclarations(statement, false)
 			: getHoistedDeclarations(statement, true);

package/lib/DependencyTemplate.js

@@ -12,7 +12,7 @@
 /** @import Dependency from "./Dependency" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
 /** @import { GenerateContext } from "./Generator" */
-/** @import Module, { RuntimeRequirements } from "./Module" */
+/** @import Module, { CodeGenerationResultData, RuntimeRequirements } from "./Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /** @import { RuntimeSpec } from "./util/runtime" */
@@ -37,6 +37,7 @@
  * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults} codeGenerationResults the code generation results
  * @property {InitFragment<GenerateContext>[]} chunkInitFragments chunkInitFragments
+ * @property {(() => CodeGenerationResultData)=} getData get access to the code generation data
  */
 
 /**

package/lib/DotenvPlugin.js

@@ -3,28 +3,6 @@
 	Author Natsu @xiaoxiaojx
 */
 
-"use strict";
-
-const FileSystemInfo = require("./FileSystemInfo");
-const DotenvFileError = require("./errors/DotenvFileError");
-const { join } = require("./util/fs");
-
-/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import { ItemCacheFacade } from "./CacheFacade" */
-/** @import { InputFileSystem } from "./util/fs" */
-/** @import { Snapshot } from "./FileSystemInfo" */
-
-/** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
-/** @typedef {Record<string, string>} Env */
-
-const DEFAULT_TEMPLATE = [
-	".env",
-	".env.local",
-	".env.[mode]",
-	".env.[mode].local"
-];
-
 // cspell:ignore Motte, motdotla
 
 /*
@@ -62,6 +40,28 @@ const DEFAULT_TEMPLATE = [
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+"use strict";
+
+const FileSystemInfo = require("./FileSystemInfo");
+const DotenvFileError = require("./errors/DotenvFileError");
+const { join } = require("./util/fs");
+
+/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
+/** @import Compiler from "./Compiler" */
+/** @import { ItemCacheFacade } from "./CacheFacade" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { Snapshot } from "./FileSystemInfo" */
+
+/** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
+/** @typedef {Record<string, string>} Env */
+
+const DEFAULT_TEMPLATE = [
+	".env",
+	".env.local",
+	".env.[mode]",
+	".env.[mode].local"
+];
+
 // Regex for parsing .env files
 // ported from https://github.com/motdotla/dotenv/blob/v17.4.2/lib/main.js#L38
 const LINE =
@@ -223,12 +223,8 @@ function expand(options) {
 		runningParsed[key] = resolvedValue;
 	}
 
-	// Part of `dotenv-expand` code, but we don't need it because of we don't modify `process.env`
-	// for (const processKey in options.parsed) {
-	// 	if (processEnv) {
-	// 		processEnv[processKey] = options.parsed[processKey];
-	// 	}
-	// }
+	// `dotenv-expand` writes the parsed values back into `process.env` here.
+	// Omitted: webpack never mutates the ambient environment.
 
 	return options;
 }

package/lib/ErrorHelpers.js

@@ -5,10 +5,39 @@
 
 "use strict";
 
+const path = require("path");
+const { fileUrlToPath } = require("./util/identifier");
+const memoize = require("./util/memoize");
+
+/** @import RequestShortener from "./RequestShortener" */
+
+const getNonErrorEmittedError = memoize(() =>
+	require("./errors/NonErrorEmittedError")
+);
+
 const loaderFlag = "LOADER_EXECUTION";
 
 const webpackOptionsFlag = "WEBPACK_OPTIONS";
 
+// Every frame of a stack is indented, so a line opening with `at ` after
+// whitespace is a frame rather than a part of the message itself.
+const STACK_FRAME_REGEXP = /^\s+at\s/;
+
+// `at name (file:line:column)`, and the `at file:line:column` a frame with no
+// name is written as.
+const STACK_FRAME_FILE_REGEXP = /^(\s+at\s(?:.*\()?)(.+?):(\d+):(\d+)(\)?)$/;
+
+// A generated function nests its parentheses and carries a position of its
+// own, so each `file:line:column` in it is read on its own.
+const GENERATED_FRAME_REGEXP = /\beval at /;
+const POSITION_REGEXP = /([^\s()]+):\d+:\d+/g;
+
+const WEBPACK_SOURCE_PATH = path.join(__dirname, path.sep);
+
+// The engine's own frames name no file of the project: `node:internal/…` under
+// node and deno, the bare `native` under bun.
+const ENGINE_FILE_REGEXP = /^(?:node:|native$)/;
+
 /**
  * Returns stack trace without the specified flag included.
  * @param {string} stack stack trace
@@ -74,6 +103,88 @@ const cutOffMessage = (stack, message) => {
 	return firstLine === message ? stack.slice(nextLine + 1) : stack;
 };
 
+/**
+ * Returns the file a stack frame names, or undefined when the line names none.
+ * @param {string} line line of a stack
+ * @returns {string | undefined} the file the frame names
+ */
+const frameFile = (line) => {
+	const match = STACK_FRAME_FILE_REGEXP.exec(line);
+	return match === null ? undefined : fileUrlToPath(match[2]);
+};
+
+/**
+ * Returns the stack without the frames this file's own wrapping put on it.
+ * @param {string | undefined} stack stack trace
+ * @returns {string | undefined} stack trace starting at the caller
+ */
+const cutOffWrappingFrames = (stack) => {
+	if (typeof stack !== "string") return stack;
+	const lines = stack.split("\n");
+	const index = lines.findIndex((line) => STACK_FRAME_REGEXP.test(line));
+	if (index === -1) return stack;
+	while (index < lines.length && frameFile(lines[index]) === __filename) {
+		lines.splice(index, 1);
+	}
+	return lines.join("\n");
+};
+
+/**
+ * Returns the value as an error, naming whatever a tap, a loader or a plugin
+ * failed with when that is not one. Everything reading a failure expects one.
+ * @param {EXPECTED_ANY} value value something failed with
+ * @returns {Error} the value, or an error naming it
+ */
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	const error = new (getNonErrorEmittedError())(value);
+	// The wrapping is not the site: the stack starts where the value was caught.
+	// Cut rather than `captureStackTrace`, which elides every frame under bun.
+	error.stack = cutOffWrappingFrames(error.stack);
+	return error;
+};
+
+/**
+ * Returns whether a rebuild of the same project names the same position in the
+ * file. Webpack's own sources move with a release, and the engine's with it.
+ * @param {string} file file a stack frame names
+ * @returns {boolean} whether the position is worth keeping
+ */
+const isReproduciblePosition = (file) =>
+	!file.startsWith(WEBPACK_SOURCE_PATH) && !ENGINE_FILE_REGEXP.test(file);
+
+/**
+ * Returns the message with every stack frame naming its file relative to the
+ * context, and a position only where {@link isReproduciblePosition} allows one.
+ * @param {string} message error message
+ * @param {RequestShortener} requestShortener request shortener
+ * @returns {string} message whose frames a second build writes the same way
+ */
+const contextifyStackFrames = (message, requestShortener) =>
+	message
+		.split("\n")
+		.map((line) => {
+			if (!STACK_FRAME_REGEXP.test(line)) return line;
+			if (GENERATED_FRAME_REGEXP.test(line)) {
+				return line.replace(
+					POSITION_REGEXP,
+					(position, file) =>
+						/** @type {string} */
+						(requestShortener.shorten(fileUrlToPath(file)))
+				);
+			}
+			const match = STACK_FRAME_FILE_REGEXP.exec(line);
+			if (match === null) return line;
+			const [, frame, url, lineNumber, column, end] = match;
+			// An engine may name the file as a URL rather than as a path.
+			const file = fileUrlToPath(url);
+			const position = isReproduciblePosition(file)
+				? `:${lineNumber}:${column}`
+				: "";
+			return `${frame}${requestShortener.shorten(file)}${position}${end}`;
+		})
+		.join("\n");
+
 /**
  * Returns stack trace without the loader execution flag and message included.
  * @param {string} stack stack trace
@@ -100,8 +211,10 @@ const cleanUpWebpackOptions = (stack, message) => {
 
 module.exports.cleanUp = cleanUp;
 module.exports.cleanUpWebpackOptions = cleanUpWebpackOptions;
+module.exports.contextifyStackFrames = contextifyStackFrames;
 module.exports.cutOffByFlag = cutOffByFlag;
 module.exports.cutOffLoaderExecution = cutOffLoaderExecution;
 module.exports.cutOffMessage = cutOffMessage;
 module.exports.cutOffMultilineMessage = cutOffMultilineMessage;
 module.exports.cutOffWebpackOptions = cutOffWebpackOptions;
+module.exports.toError = toError;

package/lib/ExportsInfo.js

@@ -151,20 +151,20 @@ class ExportsInfo {
 		/** @type {Exports} */
 		this._exports = new Map();
 
-		// `_otherExportsInfo` is a fallback entry for unlisted exports. Two roles:
-		// 1. factory template — `getExportInfo` creates `new ExportInfo(name, this)`,
-		//    so created export info extends its properties.
-		// 2. flags whether the whole exportsInfo can be statically analyzed.
-		// Its `used` reachable values:
-		// 	- NoInfo: no use analysis yet (`optimization#usedExports` off), or used without info
-		// 	- Unused: analyzed, no unlisted export needed
-		// 	- Unknown: used in unknown way
-		// 	- Used/OnlyPropertiesUsed: never reached
-		// Its `provided` reachable values:
-		// 	- undefined: provision not determined yet
-		// 	- false: determined, no unlisted export is provided
-		// 	- null: only runtime knows (dynamic/unknown exports)
-		// 	- true: never reached
+		// WHY: a fallback entry for the unlisted exports, in two roles — the factory
+		// template `getExportInfo` extends with `new ExportInfo(name, this)`, and the
+		// flag for whether this exportsInfo can be statically analyzed at all.
+		// Its reachable `used` values:
+		// - NoInfo: no use analysis yet (`optimization#usedExports` off), or used
+		//   without info
+		// - Unused: analyzed, no unlisted export needed
+		// - Unknown: used in an unknown way
+		// - Used/OnlyPropertiesUsed: never reached
+		// Its reachable `provided` values:
+		// - undefined: provision not determined yet
+		// - false: determined, no unlisted export is provided
+		// - null: only runtime knows (dynamic or unknown exports)
+		// - true: never reached
 		/** @type {ExportInfo} */
 		this._otherExportsInfo = new ExportInfo(null);
 		/** @type {ExportInfo} */
@@ -1671,7 +1671,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target, undefined when there is no target, false when no target is valid.
+	 * Walks the reexport chain and returns the first target whose module passes
+	 * `validTargetModuleFilter`. Returns undefined when there is no target, false
+	 * when the chain ends without a valid module.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
@@ -1736,7 +1738,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target.
+	 * Resolves the reexport chain as far as `resolveTargetFilter` allows and
+	 * returns where it ends. Returns undefined when there is no target, the
+	 * targets disagree, or the chain is circular.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @returns {TargetItemWithConnection | undefined} the target