webpack 5.111.1 → 5.112.1

package/lib/javascript/JavascriptParser.js

@@ -6,10 +6,9 @@
 "use strict";
 
 const { HookMap, SyncBailHook } = require("tapable");
-const NormalModule = require("../NormalModule");
-const Parser = require("../Parser");
 const WebpackError = require("../WebpackError");
-const StackedMap = require("../util/StackedMap");
+const Parser = require("../module/Parser");
+const binarySearchBounds = require("../util/binarySearchBounds");
 const {
 	CompilerHintNotationRegExp,
 	createMagicCommentContext,
@@ -17,7 +16,8 @@ const {
 	parseCommentOptionsInRange
 } = require("../util/magicComment");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
-const { nonASCIIwhitespace } = require("./parser");
+const StackedMap = require("./StackedMap");
+const { nonASCIIwhitespace } = require("./syntax-parser");
 const {
 	BLOCK_DECLARATIONS,
 	HOISTED_DECLARATIONS,
@@ -31,9 +31,10 @@ const {
 	isIdentifierChar,
 	overflowFrom,
 	positionAt
-} = require("./syntax");
+} = require("./syntax-parser");
 
-/** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax" */
+/** @import { BuiltJavascriptModule } from "./JavascriptModule" */
+/** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax-parser" */
 /**
  * @import {
  * 	AssignmentExpression,
@@ -108,38 +109,43 @@ const {
  * 	MaybeNamedClassDeclaration
  * } from "estree"
  */
-/** @import { DependencyLocation } from "../Dependency" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import { MagicCommentOptions } from "../util/magicComment" */
 /** @typedef {import("estree").Comment & { start: number, end: number, loc?: SourceLocation | null }} Comment */
 /**
  * Defines the shared type used by this module.
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
-/** @import { ParserState, PreparsedAst } from "../Parser" */
+/** @import { ParserState, PreparsedAst } from "../module/Parser" */
 
-/** @import LocalModule from "../dependencies/LocalModule" */
+/** @import LocalModule from "../dependencies/amd/LocalModule" */
 /**
  * @import {
- * 	HarmonyStarExportsList
- * } from "../dependencies/HarmonyExportImportedSpecifierDependency"
+ * 	ESMStarExportsList
+ * } from "../dependencies/esm/ESMExportImportedSpecifierDependency"
  */
 
 /**
  * Defines the known javascript parser state type used by this module.
+ * The `harmony*` properties forward to their `esm*` namesake.
  * @typedef {object} KnownJavascriptParserState
- * @property {Set<string>=} harmonyNamedExports
- * @property {InstanceType<HarmonyStarExportsList>=} harmonyStarExports
- * @property {number=} lastHarmonyImportOrder
+ * @property {Set<string>=} esmNamedExports
+ * @property {InstanceType<ESMStarExportsList>=} esmStarExports
+ * @property {number=} lastESMImportOrder
  * @property {LocalModule[]=} localModules
+ * @property {Set<string>=} harmonyNamedExports deprecated, use `esmNamedExports`
+ * @property {InstanceType<ESMStarExportsList>=} harmonyStarExports deprecated, use `esmStarExports`
+ * @property {number=} lastHarmonyImportOrder deprecated, use `lastESMImportOrder`
  */
 
-/** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
+/** @typedef {ParserState<BuiltJavascriptModule> & KnownJavascriptParserState} JavascriptParserState */
 
 /** @import Compilation from "../Compilation" */
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
-/** @typedef {{ consequent?: EXPECTED_OBJECT, alternate?: EXPECTED_OBJECT }} GuardCollection per-branch guard frames pushed onto the parser state guard stack */
+/** @typedef {{ consequent?: GuardFrame, alternate?: GuardFrame }} GuardCollection per-branch guard frames pushed onto the parser state guard stack */
 /** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
 /** @typedef {(ident: string) => void} OnIdentString */
 /** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
@@ -176,6 +182,7 @@ const EMPTY_MODULE_DECLARATIONS = [];
 // object pattern, so a tap on that type is not served from the list.
 const BLOCK_DECLARATION_TYPES = new Set([
 	"VariableDeclaration",
+	"FunctionDeclaration",
 	"ClassDeclaration",
 	"ExportNamedDeclaration",
 	"ExportDefaultDeclaration"
@@ -273,7 +280,10 @@ const getImportAttributes = (node) => {
 		result[key] = /** @type {string} */ (attribute.value.value);
 	}
 
-	if (/** @type {EXPECTED_ANY} */ (node.attributes)[LEGACY_ASSERT_ATTRIBUTES]) {
+	if (
+		/** @type {typeof node.attributes & { [LEGACY_ASSERT_ATTRIBUTES]?: boolean }} */
+		(node.attributes)[LEGACY_ASSERT_ATTRIBUTES]
+	) {
 		result._isLegacyAssert = true;
 	}
 
@@ -365,20 +375,22 @@ class VariableInfo {
 
 /**
  * @import {
- * 	HarmonySettings
- * } from "../dependencies/HarmonyImportDependencyParserPlugin"
+ * 	ESMSettings
+ * } from "../dependencies/esm/ESMImportDependencyParserPlugin"
  */
-/** @import { ImportSettings } from "../dependencies/ImportParserPlugin" */
+/** @import { ImportSettings } from "../dependencies/import/ImportParserPlugin" */
+/** @import { GuardFrame } from "../dependencies/esm/ESMImportGuard" */
 /**
  * @import {
  * 	CommonJsImportSettings
- * } from "../dependencies/CommonJsImportsParserPlugin"
+ * } from "../dependencies/commonjs/CommonJsImportsParserPlugin"
  */
-/** @import { CompatibilitySettings } from "../CompatibilityPlugin" */
+/** @import { CompatibilitySettings } from "./CompatibilityPlugin" */
 /** @import { TopLevelSymbol } from "../optimize/InnerGraph" */
 
-/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
-/** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
+/** @typedef {ESMSettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
+// The open branch is whatever a plugin tags a variable with.
+/** @typedef {KnownTagData | EXPECTED_OBJECT} TagData */
 
 /**
  * Defines the tag info type used by this module.
@@ -554,123 +566,138 @@ const valueAsExpression = (value, expr, sideEffects) => {
 };
 
 // The constant operators, shared so evaluating `a - b` allocates no handler.
+// JavaScript coerces any operand; each cast only lets TypeScript type the operator.
+
+/** @typedef {ReturnType<BasicEvaluatedExpression["asCompileTimeValue"]>} CompileTimeValue */
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SUBTRACT = (l, r) => l - r;
+const SUBTRACT = (l, r) =>
+	/** @type {number} */ (l) - /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const MULTIPLY = (l, r) => l * r;
+const MULTIPLY = (l, r) =>
+	/** @type {number} */ (l) * /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const DIVIDE = (l, r) => l / r;
+const DIVIDE = (l, r) => /** @type {number} */ (l) / /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const POWER = (l, r) => l ** r;
+const POWER = (l, r) => /** @type {number} */ (l) ** /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_AND = (l, r) => l & r;
+const BITWISE_AND = (l, r) =>
+	/** @type {number} */ (l) & /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_OR = (l, r) => l | r;
+const BITWISE_OR = (l, r) =>
+	/** @type {number} */ (l) | /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_XOR = (l, r) => l ^ r;
+const BITWISE_XOR = (l, r) =>
+	/** @type {number} */ (l) ^ /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number} the result
  */
-const UNSIGNED_SHIFT_RIGHT = (l, r) => l >>> r;
+const UNSIGNED_SHIFT_RIGHT = (l, r) =>
+	/** @type {number} */ (l) >>> /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SHIFT_RIGHT = (l, r) => l >> r;
+const SHIFT_RIGHT = (l, r) =>
+	/** @type {number} */ (l) >> /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {number | bigint} the result
  */
-const SHIFT_LEFT = (l, r) => l << r;
+const SHIFT_LEFT = (l, r) =>
+	/** @type {number} */ (l) << /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const LESS_THAN = (l, r) => l < r;
+const LESS_THAN = (l, r) =>
+	/** @type {number} */ (l) < /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const GREATER_THAN = (l, r) => l > r;
+const GREATER_THAN = (l, r) =>
+	/** @type {number} */ (l) > /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const LESS_THAN_OR_EQUAL = (l, r) => l <= r;
+const LESS_THAN_OR_EQUAL = (l, r) =>
+	/** @type {number} */ (l) <= /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} l left operand
- * @param {EXPECTED_ANY} r right operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} l left operand
+ * @param {CompileTimeValue} r right operand
+ * @returns {boolean} the result
  */
-const GREATER_THAN_OR_EQUAL = (l, r) => l >= r;
+const GREATER_THAN_OR_EQUAL = (l, r) =>
+	/** @type {number} */ (l) >= /** @type {number} */ (r);
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number | bigint} the result
  */
-const BITWISE_NOT = (v) => ~v;
+const BITWISE_NOT = (v) => ~(/** @type {number} */ (v));
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number} the result
  */
 // eslint-disable-next-line no-implicit-coercion
-const TO_NUMBER = (v) => +v;
+const TO_NUMBER = (v) => +(/** @type {number} */ (v));
 
 /**
- * @param {EXPECTED_ANY} v operand
- * @returns {EXPECTED_ANY} the result
+ * @param {CompileTimeValue} v operand
+ * @returns {number | bigint} the result
  */
-const NEGATE = (v) => -v;
+const NEGATE = (v) => -(/** @type {number} */ (v));
 
 /**
  * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
@@ -1061,7 +1088,9 @@ const collectHoistedDeclaration = (statement, hoisted) => {
  */
 const moduleDeclarationsOf = (ast, trusted) => {
 	if (trusted) {
-		const recorded = /** @type {EXPECTED_ANY} */ (ast)[MODULE_DECLARATIONS];
+		const recorded =
+			/** @type {Program & { [MODULE_DECLARATIONS]?: ModuleDeclarations }} */
+			(ast)[MODULE_DECLARATIONS];
 		if (recorded !== undefined) return recorded;
 	}
 	/** @type {ModuleDeclarations} */
@@ -1086,12 +1115,43 @@ const moduleDeclarationsOf = (ast, trusted) => {
  */
 const hoistedDeclarationsOf = (node, trusted) => {
 	if (trusted) {
-		const recorded = /** @type {EXPECTED_ANY} */ (node)[HOISTED_DECLARATIONS];
+		const recorded =
+			/** @type {(Program | BlockStatement) & { [HOISTED_DECLARATIONS]?: HoistedDeclarations }} */
+			(node)[HOISTED_DECLARATIONS];
 		if (recorded !== undefined) return recorded;
 	}
 	return collectHoistedDeclarations(node.body, EMPTY_HOISTED_DECLARATIONS);
 };
 
+/**
+ * Whether a statement is one of the list's own, or the declaration of an
+ * `export` that is, rather than nested in one of them. It is found by its start
+ * offset since the list is in source order.
+ * @param {(Statement | ModuleDeclaration)[]} statements the list
+ * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration} statement the statement to find
+ * @returns {boolean} whether the list holds it directly
+ */
+const holdsStatement = (statements, statement) => {
+	const start = /** @type {Range} */ (statement.range)[0];
+	let low = 0;
+	let high = statements.length - 1;
+	while (low <= high) {
+		const middle = (low + high) >>> 1;
+		const candidate = statements[middle];
+		if (candidate === statement) return true;
+		if (/** @type {Range} */ (candidate.range)[0] < start) low = middle + 1;
+		else high = middle - 1;
+	}
+	// the last statement starting before it is the one that could hold it
+	const holder = high >= 0 ? statements[high] : undefined;
+	return (
+		holder !== undefined &&
+		(holder.type === "ExportNamedDeclaration" ||
+			holder.type === "ExportDefaultDeclaration") &&
+		holder.declaration === statement
+	);
+};
+
 /**
  * Which statements of a list declare into its block scope, scanned for an AST
  * some other parser built. The parser's own record is read instead when there
@@ -1112,6 +1172,14 @@ const collectBlockDeclarations = (statements) => {
 	return overflow === undefined ? mask : overflow;
 };
 
+/**
+ * @param {Comment} comment comment to compare
+ * @param {number} position source offset
+ * @returns {number} comparison of the comment end with the offset
+ */
+const compareCommentEnd = (comment, position) =>
+	/** @type {Range} */ (comment.range)[1] - position;
+
 /**
  * Whether the source between two offsets is whitespace only.
  * @param {string} source the module source
@@ -1157,6 +1225,9 @@ const STRICT_MODE_OUTPUT_REASON =
 const MODULE_GOAL_OUTPUT_REASON =
 	'The output is an ES module, where "await" is a reserved word.';
 
+/**
+ * @extends {Parser<BuiltJavascriptModule>}
+ */
 class JavascriptParser extends Parser {
 	/**
 	 * Creates an instance of JavascriptParser.
@@ -1202,13 +1273,13 @@ class JavascriptParser extends Parser {
 			 * Every statement the hoisting pass reads, which a tap on this turns
 			 * back into a walk of them all. Tap `preStatementByType` instead.
 			 * @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>}
-			 * @deprecated TODO webpack 6: remove, with the statement walk it turns on
+			 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
 			 */
 			preStatement: new SyncBailHook(["statement"]),
 			/**
 			 * Each declaration the parser records: a variable, function or class
 			 * one. Any other type turns the pass back into a walk of every
-			 * statement, and goes away with that walk in webpack 6.
+			 * statement, and goes away with that walk in the next major release.
 			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
 			 * @since 5.109.0
 			 */
@@ -1218,13 +1289,13 @@ class JavascriptParser extends Parser {
 			 * Every statement the block pass reads, which a tap on this turns back
 			 * into a walk of them all. Tap `blockPreStatementByType` instead.
 			 * @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>}
-			 * @deprecated TODO webpack 6: remove, with the statement walk it turns on
+			 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
 			 */
 			blockPreStatement: new SyncBailHook(["declaration"]),
 			/**
 			 * Each statement the parser records for the block pass: a variable, class
 			 * or export declaration. Any other type turns the pass back into a walk
-			 * of every statement, and goes away with that walk in webpack 6.
+			 * of every statement, and goes away with that walk in the next major release.
 			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
 			 * @since 5.109.0
 			 */
@@ -1423,9 +1494,13 @@ class JavascriptParser extends Parser {
 		this.options = options;
 
 		/** @type {ScopeInfo} */
-		this.scope = /** @type {EXPECTED_ANY} */ (undefined);
+		this.scope = /** @type {ScopeInfo} */ (
+			/** @type {ScopeInfo | undefined} */ (undefined)
+		);
 		/** @type {JavascriptParserState} */
-		this.state = /** @type {EXPECTED_ANY} */ (undefined);
+		this.state = /** @type {JavascriptParserState} */ (
+			/** @type {JavascriptParserState | undefined} */ (undefined)
+		);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
 		// ASI overrides keyed by statement-end offset: true forces an ASI
@@ -1439,6 +1514,9 @@ class JavascriptParser extends Parser {
 		this.prevStatement = undefined;
 		/** @type {boolean} */
 		this._hasParserRecord = false;
+		// the statements of the scope last hoisted into, which its block pass reads next
+		/** @type {(Statement | ModuleDeclaration)[] | undefined} */
+		this._scopeStatements = undefined;
 		// BACKWARD-COMPAT START
 
 		// WHY: the hoisting pass reaches declarations alone, so a tap that
@@ -2102,7 +2180,7 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo &&
+				(JavascriptParser.isVariableInfo(info) &&
 					(info.isFree() ||
 						info.isTagged() ||
 						// Walk `tagInfo` in `callHooksForInfo` if tagInfo is present.
@@ -2121,7 +2199,8 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
+				(JavascriptParser.isVariableInfo(info) &&
+					(info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -2683,6 +2762,7 @@ class JavascriptParser extends Parser {
 	 * @param {Program | BlockStatement} node the node owning the scope
 	 */
 	_preWalkScope(node) {
+		this._scopeStatements = node.body;
 		// BACKWARD-COMPAT START
 		if (this._needsFullPreWalk || this.hooks.preStatement.taps.length !== 0) {
 			if (node.type === "Program") this.preWalkStatements(node.body);
@@ -2710,12 +2790,31 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Whether a function declaration stays in its block rather than hoisting to
+	 * the scope last pre-walked, which only sloppy-mode Annex B lets it do.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 * @returns {boolean} whether its block, not the scope, binds it
+	 */
+	_isBlockScopedFunction(statement) {
+		const statements = this._scopeStatements;
+		// WHY: strictness is read here, not in the parser: `javascript/auto`
+		// reads a script as a strict module first.
+		return (
+			statements !== undefined &&
+			(this.scope.isStrict ||
+				statement.generator === true ||
+				statement.async === true) &&
+			!holdsStatement(statements, statement)
+		);
+	}
+
 	// BACKWARD-COMPAT START
 	/**
 	 * Walk every statement of a scope to declare what hoists to it. Only a tap
 	 * on the deprecated `preStatement` hook asks for this.
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
@@ -2726,7 +2825,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk block statement.
 	 * @param {BlockStatement} statement block statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkBlockStatement(statement) {
 		this.preWalkStatements(statement.body);
@@ -2735,7 +2834,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk if statement.
 	 * @param {IfStatement} statement if statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkIfStatement(statement) {
 		this.preWalkStatement(statement.consequent);
@@ -2747,7 +2846,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk labeled statement.
 	 * @param {LabeledStatement} statement labeled statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkLabeledStatement(statement) {
 		this.preWalkStatement(statement.body);
@@ -2756,7 +2855,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk with statement.
 	 * @param {WithStatement} statement with statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkWithStatement(statement) {
 		this.preWalkStatement(statement.body);
@@ -2765,7 +2864,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk switch statement.
 	 * @param {SwitchStatement} statement switch statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkSwitchStatement(statement) {
 		this.preWalkSwitchCases(statement.cases);
@@ -2774,7 +2873,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk switch cases.
 	 * @param {SwitchCase[]} switchCases switch cases
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkSwitchCases(switchCases) {
 		for (let index = 0, len = switchCases.length; index < len; index++) {
@@ -2785,7 +2884,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk try statement.
 	 * @param {TryStatement} statement try statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkTryStatement(statement) {
 		this.preWalkStatement(statement.block);
@@ -2796,7 +2895,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk catch clause.
 	 * @param {CatchClause} catchClause catch clause
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkCatchClause(catchClause) {
 		this.preWalkStatement(catchClause.body);
@@ -2805,7 +2904,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk while statement.
 	 * @param {WhileStatement} statement while statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkWhileStatement(statement) {
 		this.preWalkStatement(statement.body);
@@ -2814,7 +2913,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk do while statement.
 	 * @param {DoWhileStatement} statement do while statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkDoWhileStatement(statement) {
 		this.preWalkStatement(statement.body);
@@ -2823,7 +2922,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk for statement.
 	 * @param {ForStatement} statement for statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkForStatement(statement) {
 		if (statement.init && statement.init.type === "VariableDeclaration") {
@@ -2835,7 +2934,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk for in statement.
 	 * @param {ForInStatement} statement for in statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkForInStatement(statement) {
 		if (statement.left.type === "VariableDeclaration") {
@@ -2847,7 +2946,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Pre walk for of statement. `for await` is reported by the walk, not here.
 	 * @param {ForOfStatement} statement for of statement
-	 * @deprecated TODO webpack 6: remove, with the `preStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
 	 */
 	preWalkForOfStatement(statement) {
 		if (statement.left.type === "VariableDeclaration") {
@@ -2859,7 +2958,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Scan every top-level statement for the program's module declarations.
 	 * The parser records them now, so nothing inside webpack scans for them.
-	 * @deprecated TODO webpack 6: remove
+	 * @deprecated TODO in the next major release: remove
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	modulePreWalkStatements(statements) {
@@ -2883,7 +2982,7 @@ class JavascriptParser extends Parser {
 	 * Walk every statement of a list to declare what it binds. Only a tap on the
 	 * deprecated `blockPreStatement` hook asks for this.
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
-	 * @deprecated TODO webpack 6: remove, with the `blockPreStatement` hook
+	 * @deprecated TODO in the next major release: remove, with the `blockPreStatement` hook
 	 */
 	blockPreWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
@@ -2912,7 +3011,9 @@ class JavascriptParser extends Parser {
 		/** @type {BlockDeclarations | undefined} */
 		let recorded;
 		if (this._hasParserRecord) {
-			recorded = /** @type {EXPECTED_ANY} */ (node)[BLOCK_DECLARATIONS];
+			recorded =
+				/** @type {typeof node & { [BLOCK_DECLARATIONS]?: BlockDeclarations }} */
+				(node)[BLOCK_DECLARATIONS];
 			// 72.8% of the lists a build reads declare nothing, and saying so is
 			// the whole pass for them
 			if (recorded === 0) return;
@@ -2993,8 +3094,18 @@ class JavascriptParser extends Parser {
 		let bail =
 			preStatement.taps.length !== 0 ? preStatement.call(statement) : undefined;
 		if (!bail) {
-			const typed = preStatementByType.get(statement.type);
-			if (typed !== undefined) bail = typed.call(statement);
+			// WHY: a block-scoped function is the block pass's; the full pre-walk
+			// still shows it to `preStatement`, but not to the typed hooks, which
+			// would declare it in the scope (`InnerGraphPlugin` tags it top-level).
+			if (
+				statement.type === "FunctionDeclaration" &&
+				this._isBlockScopedFunction(statement)
+			) {
+				bail = true;
+			} else {
+				const typed = preStatementByType.get(statement.type);
+				if (typed !== undefined) bail = typed.call(statement);
+			}
 		}
 		if (bail) {
 			this.prevStatement =
@@ -3084,6 +3195,9 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
+			case "FunctionDeclaration":
+				this.blockPreWalkFunctionDeclaration(statement);
+				break;
 			case "ExportNamedDeclaration":
 				this.blockPreWalkExportNamedDeclaration(statement);
 				break;
@@ -3217,7 +3331,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Walks a conditional branch with its guard frame (if any) pushed onto the
 	 * parser-state guard stack for the duration of the branch body.
-	 * @param {EXPECTED_OBJECT | undefined | null} frame guard frame, or falsy when the branch is unguarded
+	 * @param {GuardFrame | undefined | null} frame guard frame, or falsy when the branch is unguarded
 	 * @param {() => void} walk branch walk
 	 * @returns {void}
 	 */
@@ -3530,6 +3644,17 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Bind a function declaration in the block holding it, when it does not
+	 * hoist to the enclosing scope.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 */
+	blockPreWalkFunctionDeclaration(statement) {
+		if (statement.id && this._isBlockScopedFunction(statement)) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
 	/**
 	 * Walk function declaration.
 	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
@@ -4370,7 +4495,7 @@ class JavascriptParser extends Parser {
 	 * @param {Literal} expression literal
 	 */
 	_checkStrictModeLiteral(expression) {
-		const raw = /** @type {string | undefined} */ (expression.raw);
+		const raw = expression.raw;
 		if (raw === undefined) return;
 		if (typeof expression.value === "number") {
 			// Legacy octal (`0777`) or non-octal decimal (`08`) integer literal.
@@ -4627,7 +4752,7 @@ class JavascriptParser extends Parser {
 					this._walkPatternWriteMembers(
 						property.type === "RestElement"
 							? property.argument
-							: /** @type {Pattern} */ (property.value),
+							: property.value,
 						node
 					);
 				}
@@ -5600,7 +5725,7 @@ class JavascriptParser extends Parser {
 		if (typeof info === "string") {
 			name = info;
 		} else {
-			if (!(info instanceof VariableInfo)) {
+			if (!JavascriptParser.isVariableInfo(info)) {
 				if (defined !== undefined) {
 					return defined();
 				}
@@ -5646,7 +5771,7 @@ class JavascriptParser extends Parser {
 	 */
 	_hasHooksForInfo(hookMap, info) {
 		if (typeof info === "string") return hookMap.get(info) !== undefined;
-		if (!(info instanceof VariableInfo)) return false;
+		if (!JavascriptParser.isVariableInfo(info)) return false;
 		let tagInfo = info.tagInfo;
 		while (tagInfo !== undefined) {
 			if (hookMap.get(tagInfo.tag) !== undefined) return true;
@@ -5710,7 +5835,7 @@ class JavascriptParser extends Parser {
 		if (typeof info === "string") {
 			name = info;
 		} else {
-			if (!(info instanceof VariableInfo)) {
+			if (!JavascriptParser.isVariableInfo(info)) {
 				return;
 			}
 			let tagInfo = info.tagInfo;
@@ -5887,6 +6012,37 @@ class JavascriptParser extends Parser {
 		return oldScope;
 	}
 
+	/**
+	 * The directive a statement spells, or `undefined` when it is not one. An
+	 * AST webpack did not parse may leave the metadata off a directive, so the
+	 * spelling is recovered from the literal itself there.
+	 * @param {Directive | Statement | ModuleDeclaration} statement statement
+	 * @returns {string | undefined} the spelling between the quotes
+	 */
+	getDirective(statement) {
+		if (statement.type !== "ExpressionStatement") return undefined;
+		const directive = /** @type {Directive} */ (statement).directive;
+		if (directive !== undefined || this._hasParserRecord) return directive;
+		const expression = statement.expression;
+		if (expression.type !== "Literal" || typeof expression.value !== "string") {
+			return undefined;
+		}
+		// a parenthesized string is an expression rather than a directive, and
+		// only the statement says so — the literal starts inside the parentheses
+		if (
+			statement.range !== undefined &&
+			expression.range !== undefined &&
+			statement.range[0] !== expression.range[0]
+		) {
+			return undefined;
+		}
+		// the raw text keeps an escape unexpanded, which is what separates a
+		// directive from a string that merely reads like one
+		return expression.raw === undefined
+			? expression.value
+			: expression.raw.slice(1, -1);
+	}
+
 	/**
 	 * Processes the provided statement.
 	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
@@ -5901,11 +6057,17 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		const value = /** @type {Literal} */ (statement.expression).value;
-		if (value === "use strict") {
-			this.scope.isStrict = true;
-		} else if (value === "use asm") {
+		if (value === "use asm") {
 			this.scope.isAsmJs = true;
 		}
+		for (const directiveStatement of statements) {
+			const directive = this.getDirective(directiveStatement);
+			if (directive === undefined) break;
+			if (directive === "use strict") {
+				this.scope.isStrict = true;
+				break;
+			}
+		}
 	}
 
 	/**
@@ -6240,7 +6402,7 @@ class JavascriptParser extends Parser {
 			terminated: undefined,
 			definitions: new StackedMap()
 		};
-		this.state = state;
+		this.state = /** @type {JavascriptParserState} */ (state);
 		this.comments = comments;
 		this.semicolons = undefined;
 		// evaluating a defined, untagged identifier can only fall through when
@@ -6627,7 +6789,9 @@ class JavascriptParser extends Parser {
 		}
 		const loc = node.loc;
 		if (!loc) {
-			return /** @type {DependencyLocation} */ (/** @type {unknown} */ (loc));
+			return /** @type {DependencyLocation} */ (
+				/** @type {DependencyLocation | null | undefined} */ (loc)
+			);
 		}
 		// a plain copy: a foreign parser's location class must not reach the cache
 		return {
@@ -6672,7 +6836,11 @@ class JavascriptParser extends Parser {
 		const comments = this.comments;
 		if (comments === undefined) return position;
 		const source = this._source;
-		for (let index = comments.length - 1; index >= 0; index--) {
+		for (
+			let index = binarySearchBounds.le(comments, position, compareCommentEnd);
+			index >= 0;
+			index--
+		) {
 			const range = /** @type {Range} */ (comments[index].range);
 			if (range[1] > position) continue;
 			// with no source to read, nothing can be ruled out, so the run is
@@ -6870,7 +7038,7 @@ class JavascriptParser extends Parser {
 	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			let tagInfo = info.tagInfo;
 			while (tagInfo !== undefined) {
 				if (tagInfo.tag === tag) return tagInfo.data;
@@ -6896,7 +7064,7 @@ class JavascriptParser extends Parser {
 				data,
 				next: undefined
 			});
-		} else if (oldInfo instanceof VariableInfo) {
+		} else if (JavascriptParser.isVariableInfo(oldInfo)) {
 			newInfo = new VariableInfo(
 				oldInfo.declaredScope,
 				oldInfo.name,
@@ -6926,7 +7094,7 @@ class JavascriptParser extends Parser {
 		const oldInfo = this.scope.definitions.get(name);
 		// Don't redefine variable in same scope to keep existing tags
 		if (
-			oldInfo instanceof VariableInfo &&
+			JavascriptParser.isVariableInfo(oldInfo) &&
 			oldInfo.declaredScope === this.scope
 		) {
 			return;
@@ -6952,7 +7120,7 @@ class JavascriptParser extends Parser {
 	isVariableDefined(name) {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			return !info.isFree();
 		}
 		return true;
@@ -6968,7 +7136,7 @@ class JavascriptParser extends Parser {
 	_isDefinedPlainVariable(name) {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
+		if (JavascriptParser.isVariableInfo(info)) {
 			return !(info.isFree() || info.isTagged() || info.tagInfo !== undefined);
 		}
 		return true;
@@ -7031,7 +7199,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Parses comment options.
 	 * @param {Range} range range of the comment
-	 * @returns {{ options: Record<string, EXPECTED_ANY> | null, errors: (Error & { comment: Comment })[] | null }} result
+	 * @returns {{ options: MagicCommentOptions | null, errors: (Error & { comment: Comment })[] | null }} result
 	 */
 	parseCommentOptions(range) {
 		return parseCommentOptionsInRange(
@@ -7131,7 +7299,7 @@ class JavascriptParser extends Parser {
 		const info = this.getVariableInfo(varName);
 		/** @type {string} */
 		let name;
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree()) return;
 			name = info.name;
 		} else if (typeof info !== "string") {
@@ -7151,7 +7319,7 @@ class JavascriptParser extends Parser {
 		const info = this.getVariableInfo(varName);
 		/** @type {string} */
 		let name;
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree() && !info.isTagged()) return;
 			name = info.name;
 		} else if (typeof info !== "string") {
@@ -7262,7 +7430,7 @@ class JavascriptParser extends Parser {
 	 */
 	_resolveMemberRoot(rootName) {
 		const info = this.getVariableInfo(rootName);
-		if (info instanceof VariableInfo && info.name) {
+		if (JavascriptParser.isVariableInfo(info) && info.name) {
 			if (!info.isFree() && !info.isTagged()) return;
 			this._memberRootInfo = info;
 			return info.name;
@@ -7393,6 +7561,15 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * Whether a definition is a variable rather than a free name or a scope.
+	 * @param {ExportedVariableInfo | undefined} value a scope definition
+	 * @returns {value is VariableInfo} true when the value is a variable
+	 */
+	static isVariableInfo(value) {
+		return value instanceof VariableInfo;
+	}
+
 	/**
 	 * Get module parse function.
 	 * @param {Compilation} compilation compilation
@@ -7401,10 +7578,7 @@ class JavascriptParser extends Parser {
 	 */
 	static _getModuleParseFunction(compilation, module) {
 		// Get from module if available
-		if (
-			module instanceof NormalModule &&
-			module.parser instanceof JavascriptParser
-		) {
+		if (module.is("normal") && module.parser instanceof JavascriptParser) {
 			return module.parser.options.parse;
 		}