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

package/lib/javascript/syntax.js

@@ -75,24 +75,30 @@ const stringToNumber = (str, isLegacyOctal) =>
  */
 const stringToBigInt = (str) => BigInt(str.replace(/_/g, ""));
 
-/** @typedef {import("acorn").Options} Options */
-/** @typedef {import("acorn").Position} Position */
-/** @typedef {import("acorn").Node} Node */
-/** @typedef {import("acorn").Identifier} Identifier */
-/** @typedef {import("acorn").ImportAttribute} ImportAttribute */
-/** @typedef {import("acorn").ImportDefaultSpecifier} ImportDefaultSpecifier */
-/** @typedef {import("acorn").ImportExpression} ImportExpression */
-/** @typedef {import("acorn").Expression} Expression */
+/**
+ * @import {
+ * 	Options,
+ * 	Position,
+ * 	Node,
+ * 	Identifier,
+ * 	ImportAttribute,
+ * 	ImportDefaultSpecifier,
+ * 	ImportExpression,
+ * 	Expression,
+ * 	TokenType
+ * } from "acorn"
+ */
 /** @typedef {import("acorn").ImportSpecifier | import("acorn").ImportDefaultSpecifier | import("acorn").ImportNamespaceSpecifier} AnyImportSpecifier */
-/** @typedef {import("acorn").TokenType} TokenType */
-/** @typedef {TokenType & { beforeExpr: boolean, isAssign?: boolean, prefix?: boolean, postfix?: boolean, binop: number | null, updateContext?: (prevType: TokenType) => void }} TokenTypeInternal acorn's internal TokenType fields, absent from its public types */
-/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {TokenType & { beforeExpr: boolean, isAssign?: boolean, prefix?: boolean, postfix?: boolean, binop: number | null, updateContext: ((prevType: TokenType) => void) | null }} TokenTypeInternal acorn's internal TokenType fields, absent from its public types */
 /** @typedef {[number, number]} Range */
 /** @typedef {"defer" | "source"} ImportPhase */
 /** @typedef {import("estree").Comment & { start: number, end: number }} CollectedComment comment as JavascriptParser exposes it */
 
 // Symbol-keyed so they stay out of for-in, Object.keys and JSON.stringify
 // over AST nodes.
+// Per-TokContext "the owned token loop must step aside" flag, cached on the
+// context itself so the hot guard reads one slot instead of two.
+const kSlowContext = Symbol("slow context");
 const kSource = Symbol("source");
 const kRange = Symbol("range");
 const kText = Symbol("text");
@@ -102,12 +108,23 @@ const kTextStart = Symbol("text start");
 const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
 
 // acorn's binding types and scope flags, stable across acorn 8
+const BIND_NONE = 0;
 const BIND_VAR = 1;
 const BIND_LEXICAL = 2;
+const BIND_OUTSIDE = 5;
 const SCOPE_TOP = 1;
+const SCOPE_FUNCTION = 2;
+const SCOPE_ASYNC = 4;
+const SCOPE_GENERATOR = 8;
+const SCOPE_ARROW = 16;
 const SCOPE_SIMPLE_CATCH = 32;
 // SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK
+const SCOPE_SWITCH = 1024;
 const SCOPE_VAR = 0b100000011;
+// acorn's parseFunction statement bit flags
+const FUNC_STATEMENT = 1;
+const FUNC_HANGING_STATEMENT = 2;
+const FUNC_NULLABLE_ID = 4;
 
 // ASCII identifier-continuation chars ($ 0-9 A-Z _ a-z); css/html-style
 // Uint8Array table so the tokenizer fast path is one load per char
@@ -142,6 +159,18 @@ SIMPLE_PUNCT[123] = tokTypes.braceL;
 SIMPLE_PUNCT[125] = tokTypes.braceR;
 SIMPLE_PUNCT[58] = tokTypes.colon;
 
+// Characters that can only start a token which cannot continue an expression,
+// so an atom directly followed by one is the whole expression (see
+// `parseMaybeAssign`'s fast path). `}` included: it only ever closes a block,
+// an object or a template substitution.
+const EXPRESSION_END_CHAR = new Uint8Array(128);
+EXPRESSION_END_CHAR[41] = 1; // )
+EXPRESSION_END_CHAR[44] = 1; // ,
+EXPRESSION_END_CHAR[58] = 1; // :
+EXPRESSION_END_CHAR[59] = 1; // ;
+EXPRESSION_END_CHAR[93] = 1; // ]
+EXPRESSION_END_CHAR[125] = 1; // }
+
 // Char classification for the owned `nextToken` (yuku's ws_class): one table
 // load steers both the whitespace skip loop and the token dispatch. Token
 // classes sort below CLS_SPACE so the skip loop exits on a single compare.
@@ -631,6 +660,235 @@ class PropertyNode {
 	}
 }
 
+/**
+ * Single-shape `ForStatement`.
+ */
+class ForStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Node | null} init init statement or expression
+	 * @param {Expression | null} test loop condition
+	 * @param {Expression | null} update update expression
+	 * @param {Node} body loop body
+	 */
+	constructor(start, end, init, test, update, body) {
+		this.type = "ForStatement";
+		this.start = start;
+		this.end = end;
+		this.init = init;
+		this.test = test;
+		this.update = update;
+		this.body = body;
+	}
+}
+
+/**
+ * Single-shape `ForInStatement` (no `await` slot, matching acorn).
+ */
+class ForInStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Node} left loop target
+	 * @param {Expression} right iterated expression
+	 * @param {Node} body loop body
+	 */
+	constructor(start, end, left, right, body) {
+		this.type = "ForInStatement";
+		this.start = start;
+		this.end = end;
+		this.left = left;
+		this.right = right;
+		this.body = body;
+	}
+}
+
+/**
+ * Single-shape `ForOfStatement`; `await` leads, matching acorn's write order.
+ */
+class ForOfStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {boolean} isAwait whether this is `for await`
+	 * @param {Node} left loop target
+	 * @param {Expression} right iterated expression
+	 * @param {Node} body loop body
+	 */
+	constructor(start, end, isAwait, left, right, body) {
+		this.type = "ForOfStatement";
+		this.start = start;
+		this.end = end;
+		this.await = isAwait;
+		this.left = left;
+		this.right = right;
+		this.body = body;
+	}
+}
+
+/**
+ * Single-shape `WhileStatement`.
+ */
+class WhileStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Expression} test loop condition
+	 * @param {Node} body loop body
+	 */
+	constructor(start, end, test, body) {
+		this.type = "WhileStatement";
+		this.start = start;
+		this.end = end;
+		this.test = test;
+		this.body = body;
+	}
+}
+
+/**
+ * Single-shape `SwitchStatement`.
+ */
+class SwitchStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Expression} discriminant switched expression
+	 * @param {Node[]} cases case clauses
+	 */
+	constructor(start, end, discriminant, cases) {
+		this.type = "SwitchStatement";
+		this.start = start;
+		this.end = end;
+		this.discriminant = discriminant;
+		this.cases = cases;
+	}
+}
+
+/**
+ * Pre-shaped `SwitchCase`: filled in acorn's write order (`consequent` before
+ * `test`), finished via `finishNode` like acorn's.
+ */
+class SwitchCaseNode {
+	/**
+	 * @param {number} start start offset
+	 */
+	constructor(start) {
+		this.type = "";
+		this.start = start;
+		this.end = 0;
+		/** @type {Node[] | null} */
+		this.consequent = null;
+		/** @type {Expression | null} */
+		this.test = null;
+	}
+}
+
+/**
+ * Single-shape `ThrowStatement`.
+ */
+class ThrowStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Expression} argument thrown expression
+	 */
+	constructor(start, end, argument) {
+		this.type = "ThrowStatement";
+		this.start = start;
+		this.end = end;
+		this.argument = argument;
+	}
+}
+
+/**
+ * Single-shape `BreakStatement`/`ContinueStatement` — identical field sets, so
+ * both node types share one hidden class.
+ */
+class BreakContinueNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {"BreakStatement" | "ContinueStatement"} type node type
+	 * @param {Identifier | null} label target label
+	 */
+	constructor(start, end, type, label) {
+		this.type = type;
+		this.start = start;
+		this.end = end;
+		this.label = label;
+	}
+}
+
+/**
+ * Single-shape `TryStatement`.
+ */
+class TryStatementNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Node} block try block
+	 * @param {Node | null} handler catch clause
+	 * @param {Node | null} finalizer finally block
+	 */
+	constructor(start, end, block, handler, finalizer) {
+		this.type = "TryStatement";
+		this.start = start;
+		this.end = end;
+		this.block = block;
+		this.handler = handler;
+		this.finalizer = finalizer;
+	}
+}
+
+/**
+ * Single-shape `CatchClause`.
+ */
+class CatchClauseNode {
+	/**
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 * @param {Node | null} param catch parameter
+	 * @param {Node} body catch block
+	 */
+	constructor(start, end, param, body) {
+		this.type = "CatchClause";
+		this.start = start;
+		this.end = end;
+		this.param = param;
+		this.body = body;
+	}
+}
+
+/**
+ * Pre-shaped `FunctionDeclaration`/`FunctionExpression`/
+ * `ArrowFunctionExpression`: acorn fills function nodes through shared
+ * subroutines (`parseFunctionParams`/`parseFunctionBody`), so like
+ * `PropertyNode` the fields are all declared up-front — in acorn's exact write
+ * order (`initFunction` assigns `expression` before `generator`) so JSON key
+ * order is unchanged — and acorn's writes land in existing slots: one hidden
+ * class for all three function node types, no transitions.
+ */
+class FunctionNode {
+	/**
+	 * @param {number} start start offset
+	 */
+	constructor(start) {
+		this.type = "";
+		this.start = start;
+		this.end = 0;
+		/** @type {Identifier | null} */
+		this.id = null;
+		this.expression = false;
+		this.generator = false;
+		this.async = false;
+		/** @type {Node[] | null} */
+		this.params = null;
+		/** @type {Node | null} */
+		this.body = null;
+	}
+}
+
 /**
  * Single-shape `SpreadElement`/`RestElement` — identical field sets, so both
  * node types share one hidden class.
@@ -650,6 +908,10 @@ class RestSpreadNode {
 	}
 }
 
+// Mirrors of acorn's module-level `loopLabel`/`switchLabel`.
+const LOOP_LABEL = { kind: "loop" };
+const SWITCH_LABEL = { kind: "switch" };
+
 // Shared zero-length arguments array for `new X` without parens, mirroring
 // acorn's module-level `empty`.
 /** @type {Expression[]} */
@@ -715,7 +977,18 @@ for (const NodeClass of [
 	TemplateElementNode,
 	ObjectNode,
 	PropertyNode,
-	RestSpreadNode
+	RestSpreadNode,
+	FunctionNode,
+	ForStatementNode,
+	ForInStatementNode,
+	ForOfStatementNode,
+	WhileStatementNode,
+	SwitchStatementNode,
+	SwitchCaseNode,
+	ThrowStatementNode,
+	BreakContinueNode,
+	TryStatementNode,
+	CatchClauseNode
 ]) {
 	for (const key of ["range"]) {
 		Object.defineProperty(
@@ -729,8 +1002,9 @@ for (const NodeClass of [
 
 /**
  * Comment collected without slicing its text out of the source: only magic
- * comments and pure annotations ever get their text read, so the slice is
- * deferred to the first `value` access and memoized like `loc`.
+ * comments and pure annotations ever get their text read, and only binary
+ * searches around magic-comment sites read `range`, so the text slice and the
+ * range array are both deferred to first access and memoized like `loc`.
  */
 class LazyComment {
 	/**
@@ -745,12 +1019,30 @@ class LazyComment {
 		this.type = block ? "Block" : "Line";
 		this.start = start;
 		this.end = end;
-		/** @type {Range} */
-		this.range = [start, end];
 		this[kSource] = source;
 		this[kTextStart] = textStart;
 	}
 
+	/**
+	 * Memoized like `LazyLocNode#range`; offsets are final at construction so
+	 * the slot is cached unconditionally.
+	 * @returns {Range} source range
+	 */
+	get range() {
+		const cached = this[kRange];
+		if (cached !== undefined) return cached;
+		/** @type {Range} */
+		const range = [this.start, this.end];
+		return (this[kRange] = range);
+	}
+
+	/**
+	 * @param {Range} value source range
+	 */
+	set range(value) {
+		this[kRange] = value;
+	}
+
 	/**
 	 * @returns {string} comment text without the delimiters
 	 */
@@ -825,9 +1117,10 @@ class Scope {
  * parseLiteral: (value: unknown) => Node,
  * awaitIdentPos: number,
  * lastTokStart: number,
+ * lastTokStartLoc?: Position,
  * yieldPos: number,
  * awaitPos: number,
- * parseExpression: () => Expression,
+ * parseExpression: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null) => Expression,
  * parseSpread: (refDestructuringErrors?: DestructuringErrorsShim | null) => Node,
  * braceIsBlock: (prevType: TokenType) => boolean,
  * _gapHasNewline: () => boolean,
@@ -839,10 +1132,11 @@ class Scope {
  * checkPatternErrors: (refDestructuringErrors: DestructuringErrorsShim, isAssign: boolean) => void,
  * checkYieldAwaitInDefaultParams: () => void,
  * checkExpressionErrors: (refDestructuringErrors?: DestructuringErrorsShim | null, andThrow?: boolean) => boolean,
- * parseSubscript: (base: Expression, startPos: number, startLoc: Position | undefined, noCalls: boolean | undefined, maybeAsyncArrow: boolean, optionalChained: boolean, forInit: boolean | string) => Expression,
+ * parseSubscript: (base: Expression, startPos: number, startLoc: Position | undefined, noCalls: boolean | undefined, maybeAsyncArrow: boolean, optionalChained: boolean, forInit?: boolean | string) => Expression,
  * parseExprAtom: (refDestructuringErrors?: DestructuringErrorsShim | null, forInit?: boolean | string, forNew?: boolean) => Expression,
  * buildBinary: (startPos: number, startLoc: Position | undefined, left: Expression, right: Expression, op: string, logical: boolean) => Expression,
  * parseMaybeAssign: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null, afterLeftParse?: (this: unknown, left: Expression, startPos: number, startLoc?: Position) => Expression) => Expression,
+ * _parseTrivialAtom: (forInit?: boolean | string) => Expression | null,
  * parseMaybeConditional: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null) => Expression,
  * parseMaybeUnary: (refDestructuringErrors: DestructuringErrorsShim | null, sawUnary: boolean, incDec: boolean, forInit?: boolean | string) => Expression,
  * parseExprSubscripts: (refDestructuringErrors?: DestructuringErrorsShim | null, forInit?: boolean | string) => Expression,
@@ -874,6 +1168,18 @@ class Scope {
  * _propHashDepth: number,
  * _acquireDestructuringErrors: () => DestructuringErrorsShim,
  * _releaseDestructuringErrors: () => void,
+ * _arrStack: EXPECTED_ANY[][],
+ * _arrDepth: number,
+ * _acquireScratch: () => EXPECTED_ANY[],
+ * _releaseScratch: (scratch: EXPECTED_ANY[], count: number) => EXPECTED_ANY[],
+ * parseRestBinding: () => Node,
+ * parseBindingListItem: (param: Node) => Node,
+ * parseAssignableListItem: (allowModifiers?: boolean) => Node,
+ * parseParenItem: (item: Expression | Node) => Expression,
+ * shouldParseArrow: (exprList: Expression[]) => boolean,
+ * parseParenArrowList: (startPos: number, startLoc: Position | undefined, exprList: Expression[], forInit?: boolean | string) => Expression,
+ * finishNodeAt: (node: Node, type: string, pos: number, loc?: Position) => Node,
+ * parseParenAndDistinguishExpression: (canBeArrow: boolean, forInit?: boolean | string) => Expression,
  * parseSubscripts: (base: Expression, startPos: number, startLoc: Position | undefined, noCalls?: boolean, forInit?: boolean | string) => Expression,
  * parseNew: () => Expression,
  * parseTemplateElement: (opts: { isTagged: boolean }) => Node,
@@ -890,7 +1196,9 @@ class Scope {
  * parseFunction: (node: Node, statement: number, allowExpressionBody?: boolean, isAsync?: boolean, forInit?: boolean | string) => Expression,
  * parseArrowExpression: (node: Node, params: Node[], isAsync: boolean, forInit?: boolean | string) => Expression,
  * _subscriptFastPath: boolean,
- * checkLValSimple: (expr: Node, bindingType?: number) => void,
+ * checkLValSimple: (expr: Node, bindingType?: number, checkClashes?: Record<string, boolean> | null) => void,
+ * checkLValInnerPattern: (expr: Node, bindingType?: number, checkClashes?: Record<string, boolean> | null) => void,
+ * declareName: (name: string, bindingType: number, pos: number) => void,
  * startNode: () => Node,
  * startNodeAt: (pos: number, loc?: Position) => Node,
  * finishNode: (node: Node, type: string) => Node,
@@ -916,6 +1224,7 @@ class Scope {
  * _readNumberCold: (startsWithDot: boolean) => void,
  * _readRadixNumber: (radix: number) => void,
  * _readWord1Cold: () => string,
+ * _finishWordSlow: (word: string) => void,
  * _skipSpaceCold: () => void,
  * _getUnknownOrPrivate: (code: number) => void,
  * finishToken: (type: TokenType, value?: unknown) => void,
@@ -953,6 +1262,20 @@ class Scope {
  * parseExprImport: (forNew: boolean) => Expression,
  * parseImportMeta: (node: Node) => Expression,
  * parseDynamicImport: (node: Node) => Expression,
+ * updateContext: (prevType: TokenType) => void,
+ * finishOp: (type: TokenType, size: number) => void,
+ * readToken_dot: () => void,
+ * readToken_slash: () => void,
+ * readToken_mult_modulo_exp: (code: number) => void,
+ * readToken_pipe_amp: (code: number) => void,
+ * readToken_caret: () => void,
+ * readToken_plus_min: (code: number) => void,
+ * readToken_lt_gt: (code: number) => void,
+ * readToken_eq_excl: (code: number) => void,
+ * readToken_question: () => void,
+ * readToken_numberSign: () => void,
+ * _tokenFastPath: boolean,
+ * _inlineFinish: boolean,
  * _lazy: boolean,
  * _importPhase: ImportPhase | null,
  * _importPhasesEnabled: boolean,
@@ -960,13 +1283,53 @@ class Scope {
  * _newlineBefore: 0 | 1 | 2,
  * _fullTokenFastPath: boolean,
  * _stmtFastPath: boolean,
+ * _lastArrow: Expression | null,
+ * _arrowFastPath: boolean,
+ * labels: { kind?: string | null, name?: string, statementStart?: number }[],
+ * initFunction: (node: Node) => void,
+ * parseFunctionStatement: (node: Node, isAsync: boolean, declarationPosition: boolean) => Node,
+ * parseFunctionBody: (node: Node, isArrowFunction: boolean, isMethod: boolean, forInit?: boolean | string) => void,
+ * parseFunctionParams: (node: Node) => void,
+ * isSimpleParamList: (params: Node[]) => boolean,
+ * checkParams: (node: Node, allowDuplicates: boolean) => void,
+ * adaptDirectivePrologue: (statements: Node[]) => void,
+ * toAssignableList: (exprList: Node[], isBinding: boolean) => Node[],
+ * parseBindingList: (close: TokenType, allowEmpty: boolean, allowTrailingComma: boolean, allowModifiers?: boolean) => Node[],
+ * strictDirective: (start: number) => boolean,
+ * _funcFastPath: boolean,
+ * _funcStmtOwn: boolean,
+ * _parseFunctionAt: (start: number, statement: number, allowExpressionBody: boolean, isAsync: boolean, forInit?: boolean | string) => Expression,
  * isLet: (context?: string | null) => boolean,
  * parseLabeledStatement: (node: Node, maybeName: string, expr: Identifier, context: string | null) => Node,
- * _parseVarInto: (declarations: Node[], isFor: boolean, kind: string, allowMissingInitializer?: boolean) => void,
+ * _parseVarInto: (declarations: Node[], isFor: boolean, kind: string, allowMissingInitializer?: boolean) => number,
  * _parseVarStatementAt: (start: number, kind: string, allowMissingInitializer?: boolean) => Node,
  * _parseIfStatementAt: (start: number) => Node,
  * _parseReturnStatementAt: (start: number) => Node,
  * _parseExpressionStatementAt: (start: number, expr: Expression) => Node,
+ * eatContextual: (name: string) => boolean,
+ * isUsing: (isFor: boolean) => boolean,
+ * isAwaitUsing: (isFor: boolean) => boolean,
+ * parseForStatement: (node: Node) => Node,
+ * parseFor: (node: Node, init: Node | null) => Node,
+ * parseForIn: (node: Node, init: Node) => Node,
+ * parseForAfterInit: (node: Node, init: Node, awaitAt: number) => Node,
+ * parseWhileStatement: (node: Node) => Node,
+ * parseSwitchStatement: (node: Node) => Node,
+ * parseThrowStatement: (node: Node) => Node,
+ * parseTryStatement: (node: Node) => Node,
+ * parseBreakContinueStatement: (node: Node, keyword: string) => Node,
+ * parseCatchClauseParam: () => Node,
+ * _stmt2FastPath: boolean,
+ * _exprFastPath: boolean,
+ * _parseForStatementAt: (start: number) => Node,
+ * _parseForAt: (start: number, init: Node | null) => Node,
+ * _parseForInAt: (start: number, isAwait: boolean, init: Node) => Node,
+ * _parseForAfterInitAt: (start: number, init: Node, awaitAt: number) => Node,
+ * _parseWhileStatementAt: (start: number) => Node,
+ * _parseSwitchStatementAt: (start: number) => Node,
+ * _parseThrowStatementAt: (start: number) => Node,
+ * _parseTryStatementAt: (start: number) => Node,
+ * _parseBreakContinueStatementAt: (start: number, keyword: string) => Node,
  * _moduleFallback: boolean,
  * _moduleSyntaxSeen: boolean,
  * _tryModuleFallback: () => boolean,
@@ -1044,6 +1407,10 @@ const createDestructuringErrors = () => {
  * @property {Map<string, ReservedKind>} reservedKinds identifier name → reserved kind
  * @property {number} reservedMaxLen longest key in `reservedKinds`
  * @property {{ test: (name: string) => boolean }} reservedBindTest strict-mode binding check, a Set-backed stand-in for acorn's `reservedWordsStrictBind` regexp
+ * @property {Set<string>} reservedBindSet strict-mode binding-reserved names
+ * @property {number} reservedBindMinLen shortest key in `reservedBindSet`
+ * @property {number} reservedBindMaxLen longest key in `reservedBindSet`
+ * @property {number} id owner tag for the shared `WORD_TYPES` classification memo
  */
 
 // One entry per distinct keyword/reserved-word set; webpack parses with a
@@ -1052,20 +1419,6 @@ const createDestructuringErrors = () => {
 /** @type {Map<string, WordLookups>} */
 const wordLookupsCache = new Map();
 
-/**
- * @param {string} word interned candidate
- * @param {string} input source code
- * @param {number} start word start offset
- * @param {number} len word length (already known equal to `word.length`)
- * @returns {boolean} whether the source span spells `word`
- */
-const sameWord = (word, input, start, len) => {
-	for (let i = 0; i < len; i++) {
-		if (word.charCodeAt(i) !== input.charCodeAt(start + i)) return false;
-	}
-	return true;
-};
-
 // Direct-mapped identifier cache for `readWord1`: one slot per hash, verified
 // by char compare, overwritten on collision. Shared across parses — hits are
 // content-checked, so a stale entry is merely a miss. Only words short enough
@@ -1075,6 +1428,34 @@ const WORD_CACHE_MASK = 0x1fff;
 const WORD_CACHE = Array.from({ length: WORD_CACHE_MASK + 1 }, () => null);
 const WORD_CACHE_MAX_LEN = 12;
 
+// Classification memo parallel to `WORD_CACHE`, same slot: every cache write
+// also writes the word's token type plus the id of the keyword set that
+// classified it, so a hit skips `classifyWord` and another option set (or a
+// `readWord1` write, owner 0) invalidates instead of mis-classifying. Keying
+// by the cache's own slot adds no extra string references — the memo can
+// never retain a word the cache itself dropped.
+/** @type {(TokenType | null)[]} */
+const WORD_TYPES = Array.from({ length: WORD_CACHE_MASK + 1 }, () => null);
+const WORD_TYPE_OWNERS = new Int32Array(WORD_CACHE_MASK + 1);
+let nextWordLookupsId = 1;
+
+/**
+ * Keyword-or-name classification: pure in (word, keywords), so it can be
+ * memoized per `WORD_CACHE` slot.
+ * @param {string} word word
+ * @param {Map<string, TokenType>} keywords keyword name → token type
+ * @returns {TokenType} token type for `word`
+ */
+const classifyWord = (word, keywords) => {
+	const len = word.length;
+	// every acorn keyword is 2-10 lowercase ASCII chars (`do`…`instanceof`)
+	if (len >= 2 && len <= 10) {
+		const first = word.charCodeAt(0);
+		if (first >= 97 && first <= 122) return keywords.get(word) || tokTypes.name;
+	}
+	return tokTypes.name;
+};
+
 // Multi-char operator strings for `finishOp` (`=>`, `===`, `&&=`, …), keyed by
 // their char codes packed 7 bits apart — collision-free for ASCII operators up
 // to acorn's maximum of 4 chars (`>>>=`), so the set stays ~40 entries.
@@ -1093,9 +1474,9 @@ const VALID_REGEXP_FLAGS = new Map();
 const getValidRegexpFlags = (ecmaVersion) => {
 	let flags = VALID_REGEXP_FLAGS.get(ecmaVersion);
 	if (flags === undefined) {
-		flags = `gim${ecmaVersion >= 6 ? "uy" : ""}${
-			ecmaVersion >= 9 ? "s" : ""
-		}${ecmaVersion >= 13 ? "d" : ""}${ecmaVersion >= 15 ? "v" : ""}`;
+		flags = `gim${ecmaVersion >= 6 ? "uy" : ""}${ecmaVersion >= 9 ? "s" : ""}${
+			ecmaVersion >= 13 ? "d" : ""
+		}${ecmaVersion >= 15 ? "v" : ""}`;
 		VALID_REGEXP_FLAGS.set(ecmaVersion, flags);
 	}
 	return flags;
@@ -1172,6 +1553,14 @@ const getWordLookups = (parser) => {
 	// keyword classification wins, matching acorn's keyword-first check
 	for (const name of keywords.keys()) reservedKinds.set(name, 1);
 	const reservedBind = wordsRegexpToSet(parser.reservedWordsStrictBind);
+	// length bounds so the owned checkLValSimple can skip the Set probe for
+	// most identifiers
+	let reservedBindMinLen = 0x7fffffff;
+	let reservedBindMaxLen = 0;
+	for (const name of reservedBind) {
+		if (name.length < reservedBindMinLen) reservedBindMinLen = name.length;
+		if (name.length > reservedBindMaxLen) reservedBindMaxLen = name.length;
+	}
 	let reservedMaxLen = 0;
 	for (const name of reservedKinds.keys()) {
 		if (name.length > reservedMaxLen) reservedMaxLen = name.length;
@@ -1181,7 +1570,11 @@ const getWordLookups = (parser) => {
 		keywords,
 		reservedKinds,
 		reservedMaxLen,
-		reservedBindTest: { test: (name) => reservedBind.has(name) }
+		reservedBindTest: { test: (name) => reservedBind.has(name) },
+		reservedBindSet: reservedBind,
+		reservedBindMinLen,
+		reservedBindMaxLen,
+		id: nextWordLookupsId++
 	};
 	wordLookupsCache.set(key, lookups);
 	lastWordLookups = lookups;
@@ -1260,9 +1653,50 @@ class WebpackParser extends BaseParser {
 		// the owned parseSubscript assumes optional chaining exists (it bakes
 		// `optional` into the node shape), so gate it on the normalized version
 		this._subscriptFastPath = lazy && this._ecmaVersion >= 11;
+		const proto = WebpackParser.prototype;
+		const self = /** @type {ParserInternals} */ (/** @type {unknown} */ (this));
+		// the owned per-token loop (nextToken/finishToken/next) also serves the
+		// public non-lazy tokenizer(): locations off, no onToken, and none of the
+		// acorn tokenizer methods it inlines or skips overridden by a plugin
+		// (`nextToken`'s punct/dot/eq shortcuts bypass `getTokenFromCode`,
+		// `finishOp`, `readToken_dot` and `readToken_eq_excl` even when the full
+		// token path below is off, so their overrides must gate this loop too)
+		this._tokenFastPath =
+			lazy ||
+			(this._noLocations &&
+				!normalizedOptions.onToken &&
+				this.nextToken === proto.nextToken &&
+				this.finishToken === proto.finishToken &&
+				this.next === proto.next &&
+				this.skipSpace === proto.skipSpace &&
+				this.getTokenFromCode === proto.getTokenFromCode &&
+				this.finishOp === proto.finishOp &&
+				self.readToken === base.readToken &&
+				self.updateContext === base.updateContext &&
+				self.readToken_dot === base.readToken_dot &&
+				self.readToken_eq_excl === base.readToken_eq_excl);
 		// the owned getTokenFromCode bakes in every ES2021 operator (?., ??=,
-		// &&=, ...), so it needs at least that version
-		this._fullTokenFastPath = lazy && this._ecmaVersion >= 12;
+		// &&=, ...), so it needs at least that version; outside lazy mode it also
+		// bypasses acorn's readToken_* family, so any override there turns it off
+		this._fullTokenFastPath =
+			this._ecmaVersion >= 12 &&
+			(lazy ||
+				(this._tokenFastPath &&
+					self.readToken_slash === base.readToken_slash &&
+					self.readToken_mult_modulo_exp === base.readToken_mult_modulo_exp &&
+					self.readToken_pipe_amp === base.readToken_pipe_amp &&
+					self.readToken_caret === base.readToken_caret &&
+					self.readToken_plus_min === base.readToken_plus_min &&
+					self.readToken_lt_gt === base.readToken_lt_gt &&
+					self.readToken_question === base.readToken_question &&
+					self.readToken_numberSign === base.readToken_numberSign &&
+					self.readRadixNumber === base.readRadixNumber));
+		// the owned nextToken/readWord finish the commonest tokens in place,
+		// which skips this.finishToken: needs the fast token loop (readWord runs
+		// in every mode) and no finishToken override by a plugin
+		this._inlineFinish =
+			this._tokenFastPath &&
+			this.finishToken === WebpackParser.prototype.finishToken;
 		// whether the gap before the current token holds a line terminator:
 		// 0 no, 1 yes, 2 unknown (canInsertSemicolon then scans the gap)
 		/** @type {0 | 1 | 2} */
@@ -1281,11 +1715,16 @@ class WebpackParser extends BaseParser {
 		/** @type {{ proto: boolean }[]} */
 		this._propHashStack = [];
 		this._propHashDepth = 0;
+		// LIFO pool of scratch arrays for list productions: elements are written
+		// by index, then copied out exactly sized — a push-grown array retains
+		// ~17 slots of capacity slack per list otherwise
+		/** @type {unknown[][]} */
+		this._arrStack = [];
+		this._arrDepth = 0;
 		// `readRegexp`'s flag whitelist depends only on the ecmaVersion
 		this._validRegexpFlags = getValidRegexpFlags(this._ecmaVersion);
 		// the owned parseStatement inlines these methods, so a parser plugin
 		// overriding any of them turns the statement fast path off
-		const proto = WebpackParser.prototype;
 		this._stmtFastPath =
 			lazy &&
 			this.parseVarStatement === proto.parseVarStatement &&
@@ -1293,6 +1732,62 @@ class WebpackParser extends BaseParser {
 			this.parseIfStatement === proto.parseIfStatement &&
 			this.parseReturnStatement === proto.parseReturnStatement &&
 			this.parseExpressionStatement === proto.parseExpressionStatement;
+		// last arrow finished by parseArrowExpression: `expr === this._lastArrow`
+		// replaces the megamorphic `expr.type === "ArrowFunctionExpression"`
+		// probes on the expression spine (arrows are created in exactly one place
+		// and never backtracked, so identity captures the type test)
+		/** @type {Expression | null} */
+		this._lastArrow = null;
+		// arrows must flow through parseArrowExpression for the identity probe;
+		// a plugin overriding it falls back to the type-based probes
+		this._arrowFastPath =
+			lazy && this.parseArrowExpression === proto.parseArrowExpression;
+		// the owned parseFunction/parseFunctionBody inline initFunction and
+		// isSimpleParamList; a plugin overriding either turns the fast path off
+		const internals = /** @type {ParserInternals} */ (
+			/** @type {unknown} */ (this)
+		);
+		this._funcFastPath =
+			lazy &&
+			this._ecmaVersion >= 9 &&
+			internals.initFunction === base.initFunction &&
+			internals.isSimpleParamList === base.isSimpleParamList;
+		// the owned parseStatement inlines parseFunctionStatement's body
+		this._funcStmtOwn =
+			this._funcFastPath &&
+			internals.parseFunctionStatement === base.parseFunctionStatement &&
+			this.parseFunction === proto.parseFunction;
+		// the owned parseStatement inlines these statement parsers too; any
+		// override falls back to acorn's dispatch for these heads
+		this._stmt2FastPath =
+			lazy &&
+			this._ecmaVersion >= 9 &&
+			internals.parseForStatement === base.parseForStatement &&
+			internals.parseFor === base.parseFor &&
+			internals.parseForIn === base.parseForIn &&
+			internals.parseForAfterInit === base.parseForAfterInit &&
+			this.parseVar === proto.parseVar &&
+			internals.parseWhileStatement === base.parseWhileStatement &&
+			internals.parseSwitchStatement === base.parseSwitchStatement &&
+			internals.parseThrowStatement === base.parseThrowStatement &&
+			internals.parseTryStatement === base.parseTryStatement &&
+			internals.parseBreakContinueStatement ===
+				base.parseBreakContinueStatement;
+		// `parseMaybeAssign`'s trivial-atom fast path returns the atom without
+		// descending the seven-layer expression chain, so every layer it skips
+		// must be the owned one
+		this._exprFastPath =
+			lazy &&
+			this.parseMaybeConditional === proto.parseMaybeConditional &&
+			this.parseExprOps === proto.parseExprOps &&
+			this.parseExprOp === proto.parseExprOp &&
+			this.parseMaybeUnary === proto.parseMaybeUnary &&
+			this.parseExprSubscripts === proto.parseExprSubscripts &&
+			this.parseSubscripts === proto.parseSubscripts &&
+			this.parseSubscript === proto.parseSubscript &&
+			this.parseExprAtom === proto.parseExprAtom &&
+			this.checkExpressionErrors === proto.checkExpressionErrors &&
+			internals.isContextual === base.isContextual;
 	}
 
 	/**
@@ -1327,15 +1822,42 @@ class WebpackParser extends BaseParser {
 		this._deDepth--;
 	}
 
+	/**
+	 * Fetches a scratch array for a list production: write elements by index,
+	 * then materialize with `_releaseScratch`. Entries past the caller's write
+	 * index are stale and meaningless.
+	 * @returns {EXPECTED_ANY[]} scratch array
+	 * @this {ParserInternals}
+	 */
+	_acquireScratch() {
+		const stack = this._arrStack;
+		const depth = this._arrDepth++;
+		const cached = stack[depth];
+		if (cached !== undefined) return cached;
+		return (stack[depth] = []);
+	}
+
+	/**
+	 * @param {EXPECTED_ANY[]} scratch scratch array from `_acquireScratch`
+	 * @param {number} count number of elements written
+	 * @returns {EXPECTED_ANY[]} exactly-sized copy of the first `count` entries
+	 * @this {ParserInternals}
+	 */
+	_releaseScratch(scratch, count) {
+		this._arrDepth--;
+		return scratch.slice(0, count);
+	}
+
 	// ----- tokenizer fast paths -----
 
 	/**
 	 * Owned per-token loop: acorn's `nextToken` chains `skipSpace` →
 	 * `fullCharCodeAtPos` → `readToken` → `isIdentifierStart` with a dead
-	 * `locations` check at each step. For the common lazy, non-template context
+	 * `locations` check at each step. For the common non-template context of
+	 * `_tokenFastPath` mode (lazy, or locations-off with no tokenizer overrides)
 	 * this folds whitespace and comment skipping and the ASCII token dispatch
 	 * into one function so nothing re-enters acorn's per-step option checks.
-	 * Template/`preserveSpace` contexts and non-lazy mode use acorn's tokenizer.
+	 * Template/`preserveSpace` contexts and other modes use acorn's tokenizer.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @returns {void}
 	 * @this {ParserInternals}
@@ -1343,12 +1865,19 @@ class WebpackParser extends BaseParser {
 	nextToken() {
 		const context = this.context;
 		const curContext = context[context.length - 1];
-		if (
-			!this._lazy ||
-			!curContext ||
-			curContext.preserveSpace ||
-			curContext.override
-		) {
+		let slow;
+		if (curContext !== undefined) {
+			const flagged =
+				/** @type {TokContextShim & { [kSlowContext]?: boolean }} */
+				(curContext);
+			slow = flagged[kSlowContext];
+			if (slow === undefined) {
+				slow = flagged[kSlowContext] = Boolean(
+					curContext.preserveSpace || curContext.override
+				);
+			}
+		}
+		if (!this._tokenFastPath || curContext === undefined || slow) {
 			this._newlineBefore = 2;
 			return base.nextToken.call(this);
 		}
@@ -1412,9 +1941,71 @@ class WebpackParser extends BaseParser {
 		switch (cls) {
 			case CLS_IDENT:
 				return this.readWord();
-			case CLS_PUNCT:
+			case CLS_PUNCT: {
+				const type = /** @type {TokenType} */ (SIMPLE_PUNCT[code]);
 				this.pos = pos + 1;
-				return this.finishToken(/** @type {TokenType} */ (SIMPLE_PUNCT[code]));
+				if (!this._inlineFinish) return this.finishToken(type);
+				// finishToken inlined for the simple punctuators (no value, and
+				// their context updates are per-char static)
+				this.end = pos + 1;
+				const prevType = this.type;
+				this.type = type;
+				this.value = undefined;
+				switch (code) {
+					case 41:
+					case 125: {
+						// parenR/braceR.updateContext, inlined
+						if (context.length === 1) {
+							this.exprAllowed = true;
+							break;
+						}
+						let out = /** @type {TokContextShim} */ (context.pop());
+						if (
+							out === CTX_B_STAT &&
+							/** @type {TokContextShim} */ (context[context.length - 1])
+								.token === "function"
+						) {
+							out = /** @type {TokContextShim} */ (context.pop());
+						}
+						this.exprAllowed = !out.isExpr;
+						break;
+					}
+					case 123:
+						// braceL.updateContext, inlined
+						context.push(this.braceIsBlock(prevType) ? CTX_B_STAT : CTX_B_EXPR);
+						this.exprAllowed = true;
+						break;
+					case 40: {
+						// parenL.updateContext, inlined
+						const statementParens =
+							prevType === tokTypes._if ||
+							prevType === tokTypes._for ||
+							prevType === tokTypes._with ||
+							prevType === tokTypes._while;
+						context.push(statementParens ? CTX_P_STAT : CTX_P_EXPR);
+						this.exprAllowed = true;
+						break;
+					}
+					case 58:
+						// colon.updateContext, inlined
+						if (
+							/** @type {TokContextShim} */ (context[context.length - 1])
+								.token === "function"
+						) {
+							context.pop();
+						}
+						this.exprAllowed = true;
+						break;
+					case 93:
+						// bracketR: no context hook, beforeExpr is false
+						this.exprAllowed = false;
+						break;
+					default:
+						// semi, comma, bracketL: no context hook, beforeExpr is true
+						this.exprAllowed = true;
+				}
+				return;
+			}
 			case CLS_DOT: {
 				// `.` not starting `.5` or `...`: skip readToken_dot's re-dispatch
 				const next = input.charCodeAt(pos + 1);
@@ -1441,10 +2032,10 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
-	 * Lazy-mode `finishToken`: acorn probes `options.locations` for a dead
-	 * `endLoc` write on every token and reaches `updateContext` through an extra
-	 * method call. Skip the probe and inline acorn's `updateContext` body — this
-	 * runs once per token. Other modes use acorn's.
+	 * `_tokenFastPath` `finishToken`: acorn probes `options.locations` for a
+	 * dead `endLoc` write on every token and reaches `updateContext` through an
+	 * extra method call. Skip the probe and inline acorn's `updateContext` body —
+	 * this runs once per token. Other modes use acorn's.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @param {TokenType} type token type
 	 * @param {unknown=} value token value
@@ -1452,7 +2043,7 @@ class WebpackParser extends BaseParser {
 	 * @this {ParserInternals}
 	 */
 	finishToken(type, value) {
-		if (!this._lazy) {
+		if (!this._tokenFastPath) {
 			return base.finishToken.call(this, type, value);
 		}
 		this.end = this.pos;
@@ -1471,41 +2062,53 @@ class WebpackParser extends BaseParser {
 					(value === "yield" && this.inGeneratorContext())) &&
 				prevType !== tokTypes.dot &&
 				this._ecmaVersion >= 6;
-		} else if (type.keyword && prevType === tokTypes.dot) {
-			this.exprAllowed = false;
-		} else if (type === tokTypes.parenR || type === tokTypes.braceR) {
-			// parenR/braceR.updateContext, inlined
-			const context = this.context;
-			if (context.length === 1) {
+		} else {
+			const update = internal.updateContext;
+			if (update === null) {
+				// no context hook (most punctuation, operators, literals and
+				// keywords): acorn's keyword-after-dot probe, else `beforeExpr` —
+				// checked first so this majority skips the per-type compares below
+				this.exprAllowed =
+					prevType === tokTypes.dot && internal.keyword !== undefined
+						? false
+						: internal.beforeExpr;
+			} else if (type === tokTypes.parenR || type === tokTypes.braceR) {
+				// parenR/braceR.updateContext, inlined
+				const context = this.context;
+				if (context.length === 1) {
+					this.exprAllowed = true;
+				} else {
+					let out = /** @type {TokContextShim} */ (context.pop());
+					if (
+						out === CTX_B_STAT &&
+						/** @type {TokContextShim} */ (context[context.length - 1])
+							.token === "function"
+					) {
+						out = /** @type {TokContextShim} */ (context.pop());
+					}
+					this.exprAllowed = !out.isExpr;
+				}
+			} else if (type === tokTypes.braceL) {
+				// braceL.updateContext, inlined
+				this.context.push(
+					this.braceIsBlock(prevType) ? CTX_B_STAT : CTX_B_EXPR
+				);
+				this.exprAllowed = true;
+			} else if (type === tokTypes.parenL) {
+				// parenL.updateContext, inlined
+				const statementParens =
+					prevType === tokTypes._if ||
+					prevType === tokTypes._for ||
+					prevType === tokTypes._with ||
+					prevType === tokTypes._while;
+				this.context.push(statementParens ? CTX_P_STAT : CTX_P_EXPR);
 				this.exprAllowed = true;
+			} else if (internal.keyword !== undefined && prevType === tokTypes.dot) {
+				// `.function` etc.: keyword-after-dot wins over the type's own hook
+				this.exprAllowed = false;
 			} else {
-				let out = /** @type {TokContextShim} */ (context.pop());
-				if (
-					out === CTX_B_STAT &&
-					/** @type {TokContextShim} */ (context[context.length - 1]).token ===
-						"function"
-				) {
-					out = /** @type {TokContextShim} */ (context.pop());
-				}
-				this.exprAllowed = !out.isExpr;
-			}
-		} else if (type === tokTypes.braceL) {
-			// braceL.updateContext, inlined
-			this.context.push(this.braceIsBlock(prevType) ? CTX_B_STAT : CTX_B_EXPR);
-			this.exprAllowed = true;
-		} else if (type === tokTypes.parenL) {
-			// parenL.updateContext, inlined
-			const statementParens =
-				prevType === tokTypes._if ||
-				prevType === tokTypes._for ||
-				prevType === tokTypes._with ||
-				prevType === tokTypes._while;
-			this.context.push(statementParens ? CTX_P_STAT : CTX_P_EXPR);
-			this.exprAllowed = true;
-		} else if (internal.updateContext) {
-			internal.updateContext.call(this, prevType);
-		} else {
-			this.exprAllowed = internal.beforeExpr;
+				update.call(this, prevType);
+			}
 		}
 	}
 
@@ -1585,19 +2188,21 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned per-token advance: acorn's `next` writes `lastTokEndLoc`/
 	 * `lastTokStartLoc` and probes `options.onToken` on every token, both dead in
-	 * lazy mode (locations off, no token stream), leaving only the two offset
-	 * writes and the keyword-escape guard. Other modes use acorn's.
+	 * `_tokenFastPath` mode (locations off, no token stream), leaving only the
+	 * two offset writes and the keyword-escape guard. Other modes use acorn's.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @param {boolean=} ignoreEscapeSequenceInKeyword whether an escape in a keyword is allowed here
 	 * @returns {void}
 	 * @this {ParserInternals}
 	 */
 	next(ignoreEscapeSequenceInKeyword) {
-		if (!this._lazy) {
+		if (!this._tokenFastPath) {
 			return base.next.call(this, ignoreEscapeSequenceInKeyword);
 		}
 		const type = this.type;
-		if (!ignoreEscapeSequenceInKeyword && type.keyword && this.containsEsc) {
+		// `containsEsc` is a parser field and almost always false; testing it first
+		// keeps the TokenType load off the common path.
+		if (this.containsEsc && !ignoreEscapeSequenceInKeyword && type.keyword) {
 			this.raiseRecoverable(
 				this.start,
 				`Escape sequence in keyword ${type.keyword}`
@@ -1986,12 +2591,15 @@ class WebpackParser extends BaseParser {
 			if (
 				cached !== null &&
 				cached.length === wordLen &&
-				sameWord(cached, input, start, wordLen)
+				// length already matched, so a prefix test is an exact compare —
+				// one builtin instead of a charCodeAt loop per cached character
+				input.startsWith(cached, start)
 			) {
 				return cached;
 			}
 			const word = input.slice(start, pos);
 			WORD_CACHE[slot] = word;
+			WORD_TYPE_OWNERS[slot] = 0;
 			return word;
 		}
 		return input.slice(start, pos);
@@ -2758,36 +3366,113 @@ class WebpackParser extends BaseParser {
 	// ----- word classification (Map/Set lookups, replaces acorn's regexps) -----
 
 	/**
-	 * Replaces acorn's `readWord`, whose `this.keywords.test(word)` runs an
-	 * anchored alternation regexp for every identifier and keyword token; a
-	 * Map lookup on the same keyword set is cheaper.
+	 * Replaces acorn's `readWord`: `readWord1`'s ASCII fast path inlined so the
+	 * token type can be memoized per `WORD_CACHE` slot (classification is pure in
+	 * the word and the per-option keyword set) — a cache hit serves the type by
+	 * identity compare instead of a keywords Map probe.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @returns {void}
 	 */
 	readWord() {
-		const word = this.readWord1();
-		let type = tokTypes.name;
-		const len = word.length;
-		// every acorn keyword is 2-10 lowercase ASCII chars (`do`…`instanceof`),
-		// so most identifiers skip the Map probe entirely (yuku gates its keyword
-		// switch the same way)
-		if (len >= 2 && len <= 10) {
-			const first = word.charCodeAt(0);
-			if (first >= 97 && first <= 122) {
-				type = this._wordLookups.keywords.get(word) || tokTypes.name;
+		const input = this.input;
+		const start = this.pos;
+		const len = input.length;
+		let hash = 0;
+		let pos = start;
+		while (pos < len) {
+			const ch = input.charCodeAt(pos);
+			if (ch < 128) {
+				if (IDENT_CHAR[ch] === 0) {
+					// backslash escape: restart cold so escape rules see the word
+					if (ch === 92) return this._finishWordSlow(this._readWord1Cold());
+					break;
+				}
+				hash = (Math.imul(hash, 33) + ch) | 0;
+				pos++;
+			} else {
+				return this._finishWordSlow(this._readWord1Cold());
 			}
 		}
-		this.finishToken(type, word);
-	}
-
-	/**
-	 * Mirror of acorn's `checkUnreserved` with its two per-identifier regexp
-	 * tests (`keywords` and `reservedWords`/`reservedWordsStrict`) folded into a
-	 * single `reservedKinds` lookup — one hash probe instead of two, and the
-	 * common plain identifier misses it and returns. Branches and error
-	 * messages match acorn exactly.
-	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+		this.containsEsc = false;
+		this.pos = pos;
+		const wordLen = pos - start;
+		if (wordLen >= 2 && wordLen <= WORD_CACHE_MAX_LEN) {
+			const slot = hash & WORD_CACHE_MASK;
+			const lookups = this._wordLookups;
+			const owner = lookups.id;
+			const cached = WORD_CACHE[slot];
+			/** @type {string} */
+			let word;
+			/** @type {TokenType} */
+			let type;
+			if (
+				cached !== null &&
+				cached.length === wordLen &&
+				// length already matched, so a prefix test is an exact compare —
+				// one builtin instead of a charCodeAt loop per cached character
+				input.startsWith(cached, start)
+			) {
+				word = cached;
+				if (WORD_TYPE_OWNERS[slot] === owner) {
+					type = /** @type {TokenType} */ (WORD_TYPES[slot]);
+				} else {
+					type = classifyWord(cached, lookups.keywords);
+					WORD_TYPES[slot] = type;
+					WORD_TYPE_OWNERS[slot] = owner;
+				}
+			} else {
+				word = input.slice(start, pos);
+				WORD_CACHE[slot] = word;
+				type = classifyWord(word, lookups.keywords);
+				WORD_TYPES[slot] = type;
+				WORD_TYPE_OWNERS[slot] = owner;
+			}
+			if (type === tokTypes.name && this._inlineFinish) {
+				// finishToken(name) inlined: offset/type/value stores plus
+				// name.updateContext (as in the owned finishToken)
+				this.end = pos;
+				const prevType = this.type;
+				this.type = type;
+				this.value = word;
+				this.exprAllowed =
+					((word === "of" && !this.exprAllowed) ||
+						(word === "yield" && this.inGeneratorContext())) &&
+					prevType !== tokTypes.dot &&
+					this._ecmaVersion >= 6;
+				return;
+			}
+			return this.finishToken(type, word);
+		}
+		// Every keyword is 2-10 chars, so a word outside the cacheable range is a
+		// plain name and can be neither `of` nor `yield`.
+		if (this._inlineFinish) {
+			this.end = pos;
+			this.type = tokTypes.name;
+			this.value = input.slice(start, pos);
+			this.exprAllowed = false;
+			return;
+		}
+		return this._finishWordSlow(input.slice(start, pos));
+	}
+
+	/**
+	 * Uncached tail of `readWord`: escaped/non-ASCII, 1-char and over-long words.
+	 * @this {ParserInternals}
+	 * @param {string} word the word
+	 * @returns {void}
+	 */
+	_finishWordSlow(word) {
+		this.finishToken(classifyWord(word, this._wordLookups.keywords), word);
+	}
+
+	/**
+	 * Mirror of acorn's `checkUnreserved` with its two per-identifier regexp
+	 * tests (`keywords` and `reservedWords`/`reservedWordsStrict`) folded into a
+	 * single `reservedKinds` lookup — one hash probe instead of two, and the
+	 * common plain identifier misses it and returns. Branches and error
+	 * messages match acorn exactly.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {Identifier} ref identifier node
 	 * @this {ParserInternals}
 	 */
@@ -2850,6 +3535,162 @@ class WebpackParser extends BaseParser {
 		}
 	}
 
+	/**
+	 * Owned `checkLValSimple`, an exact-semantics copy of acorn 8's with the
+	 * strict-bind probe inlined: the constructor-installed Set stand-in is one
+	 * `has` behind a length gate instead of a closure call per checked name.
+	 * A runtime-replaced `reservedWordsStrictBind` falls back to `.test()`.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @param {Node} expr assignment/binding target
+	 * @param {number=} bindingType acorn BIND_* binding type
+	 * @param {Record<string, boolean> | null=} checkClashes param-name clash record
+	 * @returns {void}
+	 * @this {ParserInternals}
+	 */
+	checkLValSimple(expr, bindingType, checkClashes) {
+		if (bindingType === undefined) bindingType = BIND_NONE;
+		const isBind = bindingType !== BIND_NONE;
+		const type = expr.type;
+		if (type === "Identifier") {
+			const name = /** @type {Identifier} */ (expr).name;
+			if (this.strict) {
+				const lookups = this._wordLookups;
+				let reserved;
+				if (this.reservedWordsStrictBind === lookups.reservedBindTest) {
+					const len = name.length;
+					reserved =
+						len >= lookups.reservedBindMinLen &&
+						len <= lookups.reservedBindMaxLen &&
+						lookups.reservedBindSet.has(name);
+				} else {
+					reserved = this.reservedWordsStrictBind.test(name);
+				}
+				if (reserved) {
+					this.raiseRecoverable(
+						expr.start,
+						`${isBind ? "Binding " : "Assigning to "}${name} in strict mode`
+					);
+				}
+			}
+			if (isBind) {
+				if (bindingType === BIND_LEXICAL && name === "let") {
+					this.raiseRecoverable(
+						expr.start,
+						"let is disallowed as a lexically bound name"
+					);
+				}
+				if (checkClashes) {
+					if (Object.prototype.hasOwnProperty.call(checkClashes, name)) {
+						this.raiseRecoverable(expr.start, "Argument name clash");
+					}
+					checkClashes[name] = true;
+				}
+				if (bindingType !== BIND_OUTSIDE) {
+					this.declareName(name, bindingType, expr.start);
+				}
+			}
+			return;
+		}
+		if (type === "ChainExpression") {
+			this.raiseRecoverable(
+				expr.start,
+				"Optional chaining cannot appear in left-hand side"
+			);
+			return;
+		}
+		if (type === "MemberExpression") {
+			if (isBind) {
+				this.raiseRecoverable(expr.start, "Binding member expression");
+			}
+			return;
+		}
+		if (type === "ParenthesizedExpression") {
+			if (isBind) {
+				this.raiseRecoverable(expr.start, "Binding parenthesized expression");
+			}
+			return this.checkLValSimple(
+				/** @type {Node} */ (
+					/** @type {Node & { expression?: Node }} */ (expr).expression
+				),
+				bindingType,
+				checkClashes
+			);
+		}
+		this.raise(expr.start, `${isBind ? "Binding" : "Assigning to"} rvalue`);
+	}
+
+	/**
+	 * Owned `checkLValPattern`, acorn's verbatim, so declarator/assignment
+	 * targets stay on owned code down to `checkLValSimple`/`declareName`.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @param {Node} expr binding pattern
+	 * @param {number=} bindingType acorn BIND_* binding type
+	 * @param {Record<string, boolean> | null=} checkClashes param-name clash record
+	 * @returns {void}
+	 * @this {ParserInternals}
+	 */
+	checkLValPattern(expr, bindingType, checkClashes) {
+		const type = expr.type;
+		if (type === "ObjectPattern") {
+			const properties = /** @type {Node & { properties: Node[] }} */ (expr)
+				.properties;
+			for (let i = 0; i < properties.length; i++) {
+				this.checkLValInnerPattern(properties[i], bindingType, checkClashes);
+			}
+		} else if (type === "ArrayPattern") {
+			const elements = /** @type {Node & { elements: (Node | null)[] }} */ (
+				expr
+			).elements;
+			for (let i = 0; i < elements.length; i++) {
+				const element = elements[i];
+				if (element) {
+					this.checkLValInnerPattern(element, bindingType, checkClashes);
+				}
+			}
+		} else {
+			this.checkLValSimple(expr, bindingType, checkClashes);
+		}
+	}
+
+	/**
+	 * Owned `checkLValInnerPattern`, acorn's verbatim.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @param {Node} expr pattern element
+	 * @param {number=} bindingType acorn BIND_* binding type
+	 * @param {Record<string, boolean> | null=} checkClashes param-name clash record
+	 * @returns {void}
+	 * @this {ParserInternals}
+	 */
+	checkLValInnerPattern(expr, bindingType, checkClashes) {
+		const type = expr.type;
+		if (type === "Property") {
+			// AssignmentProperty has type === "Property"
+			this.checkLValInnerPattern(
+				/** @type {Node} */ (
+					/** @type {Node & { value?: Node }} */ (expr).value
+				),
+				bindingType,
+				checkClashes
+			);
+		} else if (type === "AssignmentPattern") {
+			this.checkLValPattern(
+				/** @type {Node} */ (/** @type {Node & { left?: Node }} */ (expr).left),
+				bindingType,
+				checkClashes
+			);
+		} else if (type === "RestElement") {
+			this.checkLValPattern(
+				/** @type {Node} */ (
+					/** @type {Node & { argument?: Node }} */ (expr).argument
+				),
+				bindingType,
+				checkClashes
+			);
+		} else {
+			this.checkLValPattern(expr, bindingType, checkClashes);
+		}
+	}
+
 	/**
 	 * Replaces acorn's `canInsertSemicolon`, whose line-break check slices the
 	 * inter-token gap and runs a regexp on it for every ASI decision (hundreds
@@ -3016,6 +3857,79 @@ class WebpackParser extends BaseParser {
 		return node;
 	}
 
+	/**
+	 * Owned `parseSubscripts`, an exact-semantics copy of acorn 8's with the
+	 * async-arrow-head probe reordered cheapest-first (all operands are pure)
+	 * and the arrow exit probe served by `_lastArrow` identity instead of the
+	 * megamorphic `.type` load. Delegates when either fast path is off.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+	 * @param {Expression} baseExpr subscript base
+	 * @param {number} startPos expression start offset
+	 * @param {Position | undefined} startLoc expression start position
+	 * @param {boolean=} noCalls whether calls are forbidden (`new` callee)
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression} expression with subscripts applied
+	 * @this {ParserInternals}
+	 */
+	parseSubscripts(baseExpr, startPos, startLoc, noCalls, forInit) {
+		if (!this._subscriptFastPath || !this._arrowFastPath) {
+			return base.parseSubscripts.call(
+				this,
+				baseExpr,
+				startPos,
+				startLoc,
+				noCalls,
+				forInit
+			);
+		}
+		// acorn's probe order is (ecmaVersion, type, name, offsets, ASI,
+		// potentialArrowAt); every operand is pure, so the SMI compares run
+		// first and the megamorphic `.type` load only when `async` matched
+		const maybeAsyncArrow =
+			baseExpr.start === this.potentialArrowAt &&
+			baseExpr.end - baseExpr.start === 5 &&
+			this.lastTokEnd === baseExpr.end &&
+			this._ecmaVersion >= 8 &&
+			/** @type {Identifier} */ (baseExpr).name === "async" &&
+			baseExpr.type === "Identifier" &&
+			!this.canInsertSemicolon();
+		let optionalChained = false;
+		for (;;) {
+			const element = this.parseSubscript(
+				baseExpr,
+				startPos,
+				startLoc,
+				noCalls,
+				maybeAsyncArrow,
+				optionalChained,
+				forInit
+			);
+			if (
+				/** @type {Expression & { optional?: boolean }} */ (element).optional
+			) {
+				optionalChained = true;
+			}
+			if (element === baseExpr || element === this._lastArrow) {
+				if (optionalChained) {
+					const chainNode =
+						/** @type {Node & { expression?: Expression }} */
+						(this.startNodeAt(startPos, startLoc));
+					chainNode.expression = element;
+					return /** @type {Expression} */ (
+						/** @type {unknown} */ (
+							this.finishNode(
+								/** @type {Node} */ (chainNode),
+								"ChainExpression"
+							)
+						)
+					);
+				}
+				return element;
+			}
+			baseExpr = element;
+		}
+	}
+
 	/**
 	 * Owned `parseSubscript`, an exact-semantics copy of acorn 8's with the
 	 * node construction replaced: member and call nodes are built fully-formed
@@ -3201,17 +4115,65 @@ class WebpackParser extends BaseParser {
 			case tokTypes.braceL:
 				// the owned parseBlock never reads the started node
 				return this.parseBlock(true);
+			case tokTypes._function: {
+				if (!this._funcStmtOwn) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				// acorn's hanging-function guard (context = single-statement position)
+				if (
+					context &&
+					(this.strict || (context !== "if" && context !== "label"))
+				) {
+					this.unexpected();
+				}
+				// parseFunctionStatement, inlined without the started node
+				const start = this.start;
+				this.next();
+				return this._parseFunctionAt(
+					start,
+					FUNC_STATEMENT | (context ? FUNC_HANGING_STATEMENT : 0),
+					false,
+					false,
+					undefined
+				);
+			}
 			case tokTypes._break:
 			case tokTypes._continue:
-			case tokTypes._debugger:
-			case tokTypes._do:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseBreakContinueStatementAt(
+					this.start,
+					/** @type {string} */ (startType.keyword)
+				);
 			case tokTypes._for:
-			case tokTypes._function:
-			case tokTypes._class:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseForStatementAt(this.start);
 			case tokTypes._switch:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseSwitchStatementAt(this.start);
 			case tokTypes._throw:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseThrowStatementAt(this.start);
 			case tokTypes._try:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseTryStatementAt(this.start);
 			case tokTypes._while:
+				if (!this._stmt2FastPath) {
+					return base.parseStatement.call(this, context, topLevel, exports);
+				}
+				return this._parseWhileStatementAt(this.start);
+			case tokTypes._debugger:
+			case tokTypes._do:
+			case tokTypes._class:
 			case tokTypes._with:
 			case tokTypes.semi:
 			case tokTypes._export:
@@ -3294,9 +4256,14 @@ class WebpackParser extends BaseParser {
 	 */
 	_parseVarStatementAt(start, kind, allowMissingInitializer) {
 		this.next();
-		/** @type {Node[]} */
-		const declarations = [];
-		this._parseVarInto(declarations, false, kind, allowMissingInitializer);
+		const scratch = this._acquireScratch();
+		const count = this._parseVarInto(
+			scratch,
+			false,
+			kind,
+			allowMissingInitializer
+		);
+		const declarations = this._releaseScratch(scratch, count);
 		this.semicolon();
 		return /** @type {Node} */ (
 			/** @type {unknown} */ (
@@ -3328,13 +4295,23 @@ class WebpackParser extends BaseParser {
 				allowMissingInitializer
 			);
 		}
-		/** @type {Node[]} */
-		const declarations = [];
 		const target =
-			/** @type {Node & { declarations: Node[], kind: string }} */ (node);
-		target.declarations = declarations;
+			/** @type {Node & { declarations: Node[] | null, kind: string }} */ (
+				node
+			);
+		// null placeholder keeps acorn's declarations-then-kind key order while
+		// the list is built in scratch (the node is a local in every caller
+		// until this returns, so the placeholder is unobservable)
+		target.declarations = null;
 		target.kind = kind;
-		this._parseVarInto(declarations, isFor, kind, allowMissingInitializer);
+		const scratch = this._acquireScratch();
+		const count = this._parseVarInto(
+			scratch,
+			isFor,
+			kind,
+			allowMissingInitializer
+		);
+		target.declarations = this._releaseScratch(scratch, count);
 		return node;
 	}
 
@@ -3342,16 +4319,17 @@ class WebpackParser extends BaseParser {
 	 * The declarator loop of the owned `parseVar`, shared with the owned
 	 * `parseStatement`'s node-free statement path.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
-	 * @param {Node[]} declarations output array for the declarators
+	 * @param {Node[]} declarations scratch array for the declarators
 	 * @param {boolean} isFor whether parsing a `for` head
 	 * @param {string} kind declaration kind
 	 * @param {boolean=} allowMissingInitializer whether `const x;` is allowed
-	 * @returns {void}
+	 * @returns {number} number of declarators written
 	 * @this {ParserInternals}
 	 */
 	_parseVarInto(declarations, isFor, kind, allowMissingInitializer) {
 		const ecmaVersion = this._ecmaVersion;
 		const usingKind = kind === "using" || kind === "await using";
+		let count = 0;
 		for (;;) {
 			const declStart = this.start;
 			const id = usingKind ? this.parseIdent() : this.parseBindingAtom();
@@ -3394,15 +4372,14 @@ class WebpackParser extends BaseParser {
 					"Complex binding patterns require an initialization value"
 				);
 			}
-			declarations.push(
-				/** @type {Node} */ (
-					/** @type {unknown} */ (
-						new VariableDeclaratorNode(declStart, this.lastTokEnd, id, init)
-					)
+			declarations[count++] = /** @type {Node} */ (
+				/** @type {unknown} */ (
+					new VariableDeclaratorNode(declStart, this.lastTokEnd, id, init)
 				)
 			);
 			if (!this.eat(tokTypes.comma)) break;
 		}
+		return count;
 	}
 
 	/**
@@ -3460,19 +4437,23 @@ class WebpackParser extends BaseParser {
 		}
 		if (createNewLexicalScope === undefined) createNewLexicalScope = true;
 		const start = this.start;
-		/** @type {Node[]} */
-		const body = [];
+		const scratch = this._acquireScratch();
+		let count = 0;
 		this.expect(tokTypes.braceL);
 		if (createNewLexicalScope) this.enterScope(0);
 		while (this.type !== tokTypes.braceR) {
-			body.push(this.parseStatement(null));
+			scratch[count++] = this.parseStatement(null);
 		}
 		if (exitStrict) this.strict = false;
 		this.next();
 		if (createNewLexicalScope) this.exitScope();
 		return /** @type {Node} */ (
 			/** @type {unknown} */ (
-				new BlockStatementNode(start, this.lastTokEnd, body)
+				new BlockStatementNode(
+					start,
+					this.lastTokEnd,
+					this._releaseScratch(scratch, count)
+				)
 			)
 		);
 	}
@@ -3538,109 +4519,1159 @@ class WebpackParser extends BaseParser {
 	 */
 	_tryModuleFallback() {
 		if (
-			!this._moduleFallback ||
-			this._moduleSyntaxSeen ||
-			!(this.currentVarScope().flags & SCOPE_TOP)
+			!this._moduleFallback ||
+			this._moduleSyntaxSeen ||
+			!(this.currentVarScope().flags & SCOPE_TOP)
+		) {
+			return false;
+		}
+		this.options.allowReturnOutsideFunction = true;
+		// acorn stamps Program.sourceType from this at parseTopLevel's end
+		this.options.sourceType = "script";
+		this.strict = false;
+		this.inModule = false;
+		this._moduleFallback = false;
+		return true;
+	}
+
+	/**
+	 * `parseReturnStatement` without a started node.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} return statement
+	 * @this {ParserInternals}
+	 */
+	_parseReturnStatementAt(start) {
+		if (!this.allowReturn && !this._tryModuleFallback()) {
+			this.raise(this.start, "'return' outside of function");
+		}
+		this.next();
+		/** @type {Expression | null} */
+		let argument = null;
+		// `return` takes an optional argument, so eagerly look for a semicolon
+		if (!(this.eat(tokTypes.semi) || this.insertSemicolon())) {
+			argument = this.parseExpression();
+			this.semicolon();
+		}
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new ReturnStatementNode(start, this.lastTokEnd, argument)
+			)
+		);
+	}
+
+	/**
+	 * `parseBreakContinueStatement` without a started node, landing on
+	 * `BreakContinueNode`'s single shape.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @param {string} keyword `break` or `continue`
+	 * @returns {Node} break or continue statement
+	 * @this {ParserInternals}
+	 */
+	_parseBreakContinueStatementAt(start, keyword) {
+		const isBreak = keyword === "break";
+		this.next();
+		/** @type {Identifier | null} */
+		let label = null;
+		if (this.eat(tokTypes.semi) || this.insertSemicolon()) {
+			// no label
+		} else if (this.type !== tokTypes.name) {
+			this.unexpected();
+		} else {
+			label = this.parseIdent();
+			this.semicolon();
+		}
+		// verify there is an actual destination to break or continue to
+		const labels = this.labels;
+		let i = 0;
+		for (; i < labels.length; ++i) {
+			const lab = labels[i];
+			if (label === null || lab.name === label.name) {
+				if (
+					lab.kind !== null &&
+					lab.kind !== undefined &&
+					(isBreak || lab.kind === "loop")
+				) {
+					break;
+				}
+				if (label && isBreak) break;
+			}
+		}
+		if (i === labels.length) this.raise(start, `Unsyntactic ${keyword}`);
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new BreakContinueNode(
+					start,
+					this.lastTokEnd,
+					isBreak ? "BreakStatement" : "ContinueStatement",
+					label
+				)
+			)
+		);
+	}
+
+	/**
+	 * `parseForStatement` without a started node (fast-path gate guarantees
+	 * `ecmaVersion >= 9`, folding acorn's version probes).
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} for/for-in/for-of statement
+	 * @this {ParserInternals}
+	 */
+	_parseForStatementAt(start) {
+		this.next();
+		const awaitAt =
+			this.canAwait && this.eatContextual("await") ? this.lastTokStart : -1;
+		this.labels.push(LOOP_LABEL);
+		this.enterScope(0);
+		this.expect(tokTypes.parenL);
+		if (this.type === tokTypes.semi) {
+			if (awaitAt > -1) this.unexpected(awaitAt);
+			return this._parseForAt(start, null);
+		}
+		const isLet = this.isLet();
+		if (this.type === tokTypes._var || this.type === tokTypes._const || isLet) {
+			const initStart = this.start;
+			const kind = isLet ? "let" : /** @type {string} */ (this.value);
+			this.next();
+			const scratch = this._acquireScratch();
+			const count = this._parseVarInto(scratch, true, kind);
+			const declarations = this._releaseScratch(scratch, count);
+			const init = /** @type {Node} */ (
+				/** @type {unknown} */ (
+					new VariableDeclarationNode(
+						initStart,
+						this.lastTokEnd,
+						declarations,
+						kind
+					)
+				)
+			);
+			return this._parseForAfterInitAt(start, init, awaitAt);
+		}
+		const startsWithLet = this.isContextual("let");
+		let isForOf = false;
+		const usingKind = this.isUsing(true)
+			? "using"
+			: this.isAwaitUsing(true)
+				? "await using"
+				: null;
+		if (usingKind) {
+			const initStart = this.start;
+			this.next();
+			if (usingKind === "await using") {
+				if (!this.canAwait) {
+					this.raise(
+						this.start,
+						"Await using cannot appear outside of async function"
+					);
+				}
+				this.next();
+			}
+			const scratch = this._acquireScratch();
+			const count = this._parseVarInto(scratch, true, usingKind);
+			const declarations = this._releaseScratch(scratch, count);
+			const init = /** @type {Node} */ (
+				/** @type {unknown} */ (
+					new VariableDeclarationNode(
+						initStart,
+						this.lastTokEnd,
+						declarations,
+						usingKind
+					)
+				)
+			);
+			return this._parseForAfterInitAt(start, init, awaitAt);
+		}
+		const containsEsc = this.containsEsc;
+		const refDestructuringErrors = this._acquireDestructuringErrors();
+		const initPos = this.start;
+		const init =
+			awaitAt > -1
+				? this.parseExprSubscripts(refDestructuringErrors, "await")
+				: this.parseExpression(true, refDestructuringErrors);
+		if (this.type === tokTypes._in || (isForOf = this.isContextual("of"))) {
+			let isAwait = false;
+			if (awaitAt > -1) {
+				if (this.type === tokTypes._in) this.unexpected(awaitAt);
+				isAwait = true;
+			} else if (
+				isForOf &&
+				init.start === initPos &&
+				!containsEsc &&
+				init.type === "Identifier" &&
+				/** @type {Identifier} */ (init).name === "async"
+			) {
+				this.unexpected();
+			}
+			if (startsWithLet && isForOf) {
+				this.raise(
+					init.start,
+					"The left-hand side of a for-of loop may not start with 'let'."
+				);
+			}
+			this.toAssignable(init, false, refDestructuringErrors);
+			this.checkLValPattern(init);
+			this._releaseDestructuringErrors();
+			return this._parseForInAt(start, isAwait, /** @type {Node} */ (init));
+		}
+		this.checkExpressionErrors(refDestructuringErrors, true);
+		this._releaseDestructuringErrors();
+		if (awaitAt > -1) this.unexpected(awaitAt);
+		return this._parseForAt(start, /** @type {Node} */ (init));
+	}
+
+	/**
+	 * `parseForAfterInit` without a started node.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @param {Node} init parsed variable declaration
+	 * @param {number} awaitAt offset of a consumed `await`, or -1
+	 * @returns {Node} for/for-in/for-of statement
+	 * @this {ParserInternals}
+	 */
+	_parseForAfterInitAt(start, init, awaitAt) {
+		const target =
+			/** @type {Node & { declarations: Node[], kind: string }} */ (init);
+		if (
+			(this.type === tokTypes._in || this.isContextual("of")) &&
+			target.declarations.length === 1
+		) {
+			if (this.type === tokTypes._in) {
+				if (
+					(target.kind === "using" || target.kind === "await using") &&
+					!(
+						/** @type {Node & { init: Node | null }} */ (target.declarations[0])
+							.init
+					)
+				) {
+					this.raise(
+						this.start,
+						"Using declaration is not allowed in for-in loops"
+					);
+				}
+				if (awaitAt > -1) this.unexpected(awaitAt);
+				return this._parseForInAt(start, false, init);
+			}
+			return this._parseForInAt(start, awaitAt > -1, init);
+		}
+		if (awaitAt > -1) this.unexpected(awaitAt);
+		return this._parseForAt(start, init);
+	}
+
+	/**
+	 * `parseFor` without a started node, landing on `ForStatementNode`'s
+	 * single shape.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @param {Node | null} init init clause
+	 * @returns {Node} for statement
+	 * @this {ParserInternals}
+	 */
+	_parseForAt(start, init) {
+		this.expect(tokTypes.semi);
+		const test = this.type === tokTypes.semi ? null : this.parseExpression();
+		this.expect(tokTypes.semi);
+		const update =
+			this.type === tokTypes.parenR ? null : this.parseExpression();
+		this.expect(tokTypes.parenR);
+		const body = this.parseStatement("for");
+		this.exitScope();
+		this.labels.pop();
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new ForStatementNode(start, this.lastTokEnd, init, test, update, body)
+			)
+		);
+	}
+
+	/**
+	 * `parseForIn` without a started node, landing on `ForInStatementNode`/
+	 * `ForOfStatementNode`'s single shapes.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @param {boolean} isAwait whether this is `for await`
+	 * @param {Node} init loop target
+	 * @returns {Node} for-in or for-of statement
+	 * @this {ParserInternals}
+	 */
+	_parseForInAt(start, isAwait, init) {
+		const isForIn = this.type === tokTypes._in;
+		this.next();
+		if (
+			init.type === "VariableDeclaration" &&
+			/** @type {Node & { init: Node | null }} */ (
+				/** @type {Node & { declarations: Node[] }} */ (init).declarations[0]
+			).init !== null &&
+			(!isForIn ||
+				this.strict ||
+				/** @type {Node & { kind: string }} */ (init).kind !== "var" ||
+				/** @type {Node & { id: Node }} */ (
+					/** @type {Node & { declarations: Node[] }} */ (init).declarations[0]
+				).id.type !== "Identifier")
+		) {
+			this.raise(
+				init.start,
+				`${
+					isForIn ? "for-in" : "for-of"
+				} loop variable declaration may not have an initializer`
+			);
+		}
+		const right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+		this.expect(tokTypes.parenR);
+		const body = this.parseStatement("for");
+		this.exitScope();
+		this.labels.pop();
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				isForIn
+					? new ForInStatementNode(start, this.lastTokEnd, init, right, body)
+					: new ForOfStatementNode(
+							start,
+							this.lastTokEnd,
+							isAwait,
+							init,
+							right,
+							body
+						)
+			)
+		);
+	}
+
+	/**
+	 * `parseSwitchStatement` without a started node, landing on
+	 * `SwitchStatementNode`'s single shape with pre-shaped `SwitchCaseNode`s.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} switch statement
+	 * @this {ParserInternals}
+	 */
+	_parseSwitchStatementAt(start) {
+		this.next();
+		const discriminant = this.parseParenExpression();
+		/** @type {Node[]} */
+		const cases = [];
+		this.expect(tokTypes.braceL);
+		this.labels.push(SWITCH_LABEL);
+		this.enterScope(SCOPE_SWITCH);
+		/** @type {SwitchCaseNode | undefined} */
+		let cur;
+		for (let sawDefault = false; this.type !== tokTypes.braceR;) {
+			if (this.type === tokTypes._case || this.type === tokTypes._default) {
+				const isCase = this.type === tokTypes._case;
+				if (cur) this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+				cur = new SwitchCaseNode(this.start);
+				cases.push(/** @type {Node} */ (cur));
+				cur.consequent = [];
+				this.next();
+				if (isCase) {
+					cur.test = this.parseExpression();
+				} else {
+					if (sawDefault) {
+						this.raiseRecoverable(
+							this.lastTokStart,
+							"Multiple default clauses"
+						);
+					}
+					sawDefault = true;
+					cur.test = null;
+				}
+				this.expect(tokTypes.colon);
+			} else {
+				if (!cur) this.unexpected();
+				/** @type {Node[]} */ (
+					/** @type {SwitchCaseNode} */ (cur).consequent
+				).push(this.parseStatement(null));
+			}
+		}
+		this.exitScope();
+		if (cur) this.finishNode(/** @type {Node} */ (cur), "SwitchCase");
+		this.next(); // closing brace
+		this.labels.pop();
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new SwitchStatementNode(start, this.lastTokEnd, discriminant, cases)
+			)
+		);
+	}
+
+	/**
+	 * `parseThrowStatement` without a started node; the illegal-newline probe
+	 * runs on the tokenizer's newline flag instead of acorn's gap slice+regexp.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} throw statement
+	 * @this {ParserInternals}
+	 */
+	_parseThrowStatementAt(start) {
+		this.next();
+		if (this._gapHasNewline()) {
+			this.raise(this.lastTokEnd, "Illegal newline after throw");
+		}
+		const argument = this.parseExpression();
+		this.semicolon();
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new ThrowStatementNode(start, this.lastTokEnd, argument)
+			)
+		);
+	}
+
+	/**
+	 * `parseTryStatement` without a started node, landing on
+	 * `TryStatementNode`/`CatchClauseNode`'s single shapes.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} try statement
+	 * @this {ParserInternals}
+	 */
+	_parseTryStatementAt(start) {
+		this.next();
+		const block = this.parseBlock();
+		/** @type {Node | null} */
+		let handler = null;
+		if (this.type === tokTypes._catch) {
+			const clauseStart = this.start;
+			this.next();
+			/** @type {Node | null} */
+			let param;
+			if (this.eat(tokTypes.parenL)) {
+				param = this.parseCatchClauseParam();
+			} else {
+				if (this._ecmaVersion < 10) this.unexpected();
+				param = null;
+				this.enterScope(0);
+			}
+			const body = this.parseBlock(false);
+			this.exitScope();
+			handler = /** @type {Node} */ (
+				/** @type {unknown} */ (
+					new CatchClauseNode(clauseStart, this.lastTokEnd, param, body)
+				)
+			);
+		}
+		const finalizer = this.eat(tokTypes._finally) ? this.parseBlock() : null;
+		if (!handler && !finalizer) {
+			this.raise(start, "Missing catch or finally clause");
+		}
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new TryStatementNode(start, this.lastTokEnd, block, handler, finalizer)
+			)
+		);
+	}
+
+	/**
+	 * `parseWhileStatement` without a started node, landing on
+	 * `WhileStatementNode`'s single shape.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start statement start offset
+	 * @returns {Node} while statement
+	 * @this {ParserInternals}
+	 */
+	_parseWhileStatementAt(start) {
+		this.next();
+		const test = this.parseParenExpression();
+		this.labels.push(LOOP_LABEL);
+		const body = this.parseStatement("while");
+		this.labels.pop();
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new WhileStatementNode(start, this.lastTokEnd, test, body)
+			)
+		);
+	}
+
+	/**
+	 * Owned `parseSpread` landing on `RestSpreadNode`'s single shape.
+	 * Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
+	 * @returns {Node} spread element
+	 * @this {ParserInternals}
+	 */
+	parseSpread(refDestructuringErrors) {
+		if (!this._lazy) {
+			return base.parseSpread.call(this, refDestructuringErrors);
+		}
+		const start = this.start;
+		this.next();
+		const argument = this.parseMaybeAssign(false, refDestructuringErrors);
+		return /** @type {Node} */ (
+			/** @type {unknown} */ (
+				new RestSpreadNode(start, this.lastTokEnd, "SpreadElement", argument)
+			)
+		);
+	}
+
+	/**
+	 * Owned `parseMaybeConditional` landing on
+	 * `ConditionalExpressionNode`'s single shape. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
+	 * @returns {Expression} expression node
+	 * @this {ParserInternals}
+	 */
+	parseMaybeConditional(forInit, refDestructuringErrors) {
+		if (!this._lazy) {
+			return base.parseMaybeConditional.call(
+				this,
+				forInit,
+				refDestructuringErrors
+			);
+		}
+		const startPos = this.start;
+		const expr = this.parseExprOps(forInit, refDestructuringErrors);
+		if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
+		const isArrowAtStart = this._arrowFastPath
+			? expr === this._lastArrow && expr.start === startPos
+			: expr.type === "ArrowFunctionExpression" && expr.start === startPos;
+		if (!isArrowAtStart && this.eat(tokTypes.question)) {
+			const consequent = this.parseMaybeAssign();
+			this.expect(tokTypes.colon);
+			const alternate = this.parseMaybeAssign(forInit);
+			return /** @type {Expression} */ (
+				/** @type {unknown} */ (
+					new ConditionalExpressionNode(
+						startPos,
+						this.lastTokEnd,
+						expr,
+						consequent,
+						alternate
+					)
+				)
+			);
+		}
+		return expr;
+	}
+
+	/**
+	 * acorn's `parseArrowExpression` plus `_lastArrow` tracking — arrows are
+	 * created and returned only here, so the expression-spine probes can test
+	 * node identity instead of the megamorphic `.type` load. A plugin fabricating
+	 * arrow nodes in an overridden `parseExprAtom` bypasses the gate (same
+	 * acceptance class as `_stmtFastPath`).
+	 * @param {Node} node started node
+	 * @param {Node[]} params parameter expressions
+	 * @param {boolean} isAsync async arrow
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression} arrow function expression
+	 * @this {ParserInternals}
+	 */
+	parseArrowExpression(node, params, isAsync, forInit) {
+		if (!this._funcFastPath) {
+			const result = base.parseArrowExpression.call(
+				this,
+				node,
+				params,
+				isAsync,
+				forInit
+			);
+			this._lastArrow = result;
+			return result;
+		}
+		// acorn's body with the started node replaced by the pre-shaped
+		// FunctionNode (initFunction's writes are its constructor defaults)
+		const functionNode = /** @type {Node} */ (
+			/** @type {unknown} */ (new FunctionNode(node.start))
+		);
+		const oldYieldPos = this.yieldPos;
+		const oldAwaitPos = this.awaitPos;
+		const oldAwaitIdentPos = this.awaitIdentPos;
+		this.enterScope(SCOPE_FUNCTION | (isAsync ? SCOPE_ASYNC : 0) | SCOPE_ARROW);
+		/** @type {Node & { async: boolean, params?: Node[] }} */ (
+			functionNode
+		).async = Boolean(isAsync);
+		this.yieldPos = 0;
+		this.awaitPos = 0;
+		this.awaitIdentPos = 0;
+		/** @type {Node & { params?: Node[] }} */ (functionNode).params =
+			/** @type {Node[]} */ (this.toAssignableList(params, true));
+		this.parseFunctionBody(functionNode, true, false, forInit);
+		this.yieldPos = oldYieldPos;
+		this.awaitPos = oldAwaitPos;
+		this.awaitIdentPos = oldAwaitIdentPos;
+		const result = /** @type {Expression} */ (
+			/** @type {unknown} */ (
+				this.finishNode(functionNode, "ArrowFunctionExpression")
+			)
+		);
+		this._lastArrow = result;
+		return result;
+	}
+
+	/**
+	 * Owned `parseFunction`, an exact-semantics copy of acorn 8's landing on
+	 * `FunctionNode`'s pre-declared shape (the passed started node is discarded,
+	 * matching acorn's observable output; `initFunction`'s writes are the
+	 * constructor defaults). Non-lazy mode and plugin overrides delegate.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {Node} node started node from the caller
+	 * @param {number} statement FUNC_* statement bit flags
+	 * @param {boolean=} allowExpressionBody whether an expression body is allowed
+	 * @param {boolean=} isAsync whether the function is async
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression} function declaration or expression
+	 * @this {ParserInternals}
+	 */
+	parseFunction(node, statement, allowExpressionBody, isAsync, forInit) {
+		if (!this._funcFastPath) {
+			return base.parseFunction.call(
+				this,
+				node,
+				statement,
+				allowExpressionBody,
+				isAsync,
+				forInit
+			);
+		}
+		return this._parseFunctionAt(
+			node.start,
+			statement,
+			allowExpressionBody === true,
+			isAsync === true,
+			forInit
+		);
+	}
+
+	/**
+	 * `parseFunction` without a started node (fast-path gate guarantees
+	 * `ecmaVersion >= 9`, folding acorn's version probes).
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {number} start function start offset
+	 * @param {number} statement FUNC_* statement bit flags
+	 * @param {boolean} allowExpressionBody whether an expression body is allowed
+	 * @param {boolean} isAsync whether the function is async
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression} function declaration or expression
+	 * @this {ParserInternals}
+	 */
+	_parseFunctionAt(start, statement, allowExpressionBody, isAsync, forInit) {
+		const node =
+			/** @type {Node & { id: Identifier | null, generator: boolean, async: boolean }} */ (
+				/** @type {unknown} */ (new FunctionNode(start))
+			);
+		if (this.type === tokTypes.star && statement & FUNC_HANGING_STATEMENT) {
+			this.unexpected();
+		}
+		node.generator = this.eat(tokTypes.star);
+		node.async = isAsync;
+		if (statement & FUNC_STATEMENT) {
+			node.id =
+				statement & FUNC_NULLABLE_ID && this.type !== tokTypes.name
+					? null
+					: this.parseIdent();
+			if (node.id && !(statement & FUNC_HANGING_STATEMENT)) {
+				// Annex B: sloppy-mode function declarations bind like vars
+				this.checkLValSimple(
+					node.id,
+					this.strict || node.generator || node.async
+						? this.treatFunctionsAsVar
+							? BIND_VAR
+							: BIND_LEXICAL
+						: /* BIND_FUNCTION */ 3
+				);
+			}
+		}
+		const oldYieldPos = this.yieldPos;
+		const oldAwaitPos = this.awaitPos;
+		const oldAwaitIdentPos = this.awaitIdentPos;
+		this.yieldPos = 0;
+		this.awaitPos = 0;
+		this.awaitIdentPos = 0;
+		this.enterScope(
+			SCOPE_FUNCTION |
+				(node.async ? SCOPE_ASYNC : 0) |
+				(node.generator ? SCOPE_GENERATOR : 0)
+		);
+		if (!(statement & FUNC_STATEMENT)) {
+			node.id = this.type === tokTypes.name ? this.parseIdent() : null;
+		}
+		this.parseFunctionParams(node);
+		this.parseFunctionBody(node, allowExpressionBody, false, forInit);
+		this.yieldPos = oldYieldPos;
+		this.awaitPos = oldAwaitPos;
+		this.awaitIdentPos = oldAwaitIdentPos;
+		return /** @type {Expression} */ (
+			/** @type {unknown} */ (
+				this.finishNode(
+					node,
+					statement & FUNC_STATEMENT
+						? "FunctionDeclaration"
+						: "FunctionExpression"
+				)
+			)
+		);
+	}
+
+	/**
+	 * Owned `parseFunctionBody`, an exact-semantics copy of acorn 8's with
+	 * `isSimpleParamList` inlined and computed once (acorn walks the params
+	 * twice) — the fast-path gate pins it to acorn's own implementation.
+	 * Non-lazy mode and plugin overrides delegate.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
+	 * @param {Node} node function node being filled
+	 * @param {boolean} isArrowFunction whether this is an arrow function
+	 * @param {boolean} isMethod whether this is an object/class method
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {void}
+	 * @this {ParserInternals}
+	 */
+	parseFunctionBody(node, isArrowFunction, isMethod, forInit) {
+		if (!this._funcFastPath) {
+			return base.parseFunctionBody.call(
+				this,
+				node,
+				isArrowFunction,
+				isMethod,
+				forInit
+			);
+		}
+		const target =
+			/** @type {Node & { id: Identifier | null, params: Node[], body: Node, expression: boolean }} */ (
+				node
+			);
+		const isExpression = isArrowFunction && this.type !== tokTypes.braceL;
+		const oldStrict = this.strict;
+		let useStrict = false;
+		if (isExpression) {
+			target.body = this.parseMaybeAssign(forInit);
+			target.expression = true;
+			this.checkParams(node, false);
+		} else {
+			// acorn's isSimpleParamList, inlined and shared by both its call sites
+			const params = target.params;
+			let simpleParams = true;
+			for (let i = 0; i < params.length; i++) {
+				if (params[i].type !== "Identifier") {
+					simpleParams = false;
+					break;
+				}
+			}
+			if (!oldStrict || !simpleParams) {
+				useStrict = this.strictDirective(this.end);
+				if (useStrict && !simpleParams) {
+					this.raiseRecoverable(
+						node.start,
+						"Illegal 'use strict' directive in function with non-simple parameter list"
+					);
+				}
+			}
+			const oldLabels = this.labels;
+			this.labels = [];
+			if (useStrict) this.strict = true;
+			this.checkParams(
+				node,
+				!oldStrict &&
+					!useStrict &&
+					!isArrowFunction &&
+					!isMethod &&
+					simpleParams
+			);
+			if (this.strict && target.id) {
+				this.checkLValSimple(target.id, BIND_OUTSIDE);
+			}
+			target.body = this.parseBlock(false, undefined, useStrict && !oldStrict);
+			target.expression = false;
+			this.adaptDirectivePrologue(
+				/** @type {Node & { body: Node[] }} */ (target.body).body
+			);
+			this.labels = oldLabels;
+		}
+		this.exitScope();
+	}
+
+	/**
+	 * Owned `parseBindingAtom`: acorn's exact dispatch minus the per-call
+	 * normalized-options read. Non-lazy mode and pre-ES6 delegate.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @returns {Node} binding atom (identifier or pattern)
+	 * @this {ParserInternals}
+	 */
+	parseBindingAtom() {
+		if (!this._lazy || this._ecmaVersion < 6) {
+			return base.parseBindingAtom.call(this);
+		}
+		const type = this.type;
+		if (type === tokTypes.bracketL) {
+			const node = /** @type {Node & { elements?: Node[] }} */ (
+				this.startNode()
+			);
+			this.next();
+			node.elements = this.parseBindingList(tokTypes.bracketR, true, true);
+			return this.finishNode(node, "ArrayPattern");
+		}
+		if (type === tokTypes.braceL) return this.parseObj(true);
+		return this.parseIdent();
+	}
+
+	/**
+	 * Owned `parseExprSubscripts`, an exact copy of acorn 8's with the arrow
+	 * probe served by `_lastArrow` identity. Delegates when the fast path is off.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression} expression node
+	 * @this {ParserInternals}
+	 */
+	parseExprSubscripts(refDestructuringErrors, forInit) {
+		if (!this._arrowFastPath) {
+			return base.parseExprSubscripts.call(
+				this,
+				refDestructuringErrors,
+				forInit
+			);
+		}
+		const startPos = this.start;
+		const startLoc = this.startLoc;
+		const expr = this.parseExprAtom(refDestructuringErrors, forInit);
+		if (
+			expr === this._lastArrow &&
+			this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")"
+		) {
+			return expr;
+		}
+		const result = this.parseSubscripts(
+			expr,
+			startPos,
+			startLoc,
+			false,
+			forInit
+		);
+		if (refDestructuringErrors && result.type === "MemberExpression") {
+			if (refDestructuringErrors.parenthesizedAssign >= result.start) {
+				refDestructuringErrors.parenthesizedAssign = -1;
+			}
+			if (refDestructuringErrors.parenthesizedBind >= result.start) {
+				refDestructuringErrors.parenthesizedBind = -1;
+			}
+			if (refDestructuringErrors.trailingComma >= result.start) {
+				refDestructuringErrors.trailingComma = -1;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Owned `parseExprList`, an exact-semantics copy of acorn 8's built in a
+	 * scratch array and materialized exactly sized. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+	 * @param {TokenType} close closing token type
+	 * @param {boolean} allowTrailingComma whether a trailing comma is allowed
+	 * @param {boolean} allowEmpty whether holes are allowed
+	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
+	 * @returns {Expression[]} parsed elements (`null` for holes)
+	 * @this {ParserInternals}
+	 */
+	parseExprList(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+		if (!this._lazy) {
+			return base.parseExprList.call(
+				this,
+				close,
+				allowTrailingComma,
+				allowEmpty,
+				refDestructuringErrors
+			);
+		}
+		const scratch = this._acquireScratch();
+		let count = 0;
+		let first = true;
+		while (!this.eat(close)) {
+			if (!first) {
+				this.expect(tokTypes.comma);
+				if (allowTrailingComma && this.afterTrailingComma(close)) break;
+			} else {
+				first = false;
+			}
+			let elt;
+			if (allowEmpty && this.type === tokTypes.comma) {
+				elt = null;
+			} else if (this.type === tokTypes.ellipsis) {
+				elt = this.parseSpread(refDestructuringErrors);
+				if (
+					refDestructuringErrors &&
+					this.type === tokTypes.comma &&
+					refDestructuringErrors.trailingComma < 0
+				) {
+					refDestructuringErrors.trailingComma = this.start;
+				}
+			} else {
+				elt = this.parseMaybeAssign(false, refDestructuringErrors);
+			}
+			scratch[count++] = elt;
+		}
+		return this._releaseScratch(scratch, count);
+	}
+
+	/**
+	 * Owned `parseBindingList`, an exact-semantics copy of acorn 8's built in a
+	 * scratch array and materialized exactly sized. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
+	 * @param {TokenType} close closing token type
+	 * @param {boolean} allowEmpty whether holes are allowed
+	 * @param {boolean} allowTrailingComma whether a trailing comma is allowed
+	 * @param {boolean=} allowModifiers passed through to `parseAssignableListItem`
+	 * @returns {Node[]} parsed bindings (`null` for holes)
+	 * @this {ParserInternals}
+	 */
+	parseBindingList(close, allowEmpty, allowTrailingComma, allowModifiers) {
+		if (!this._lazy) {
+			return base.parseBindingList.call(
+				this,
+				close,
+				allowEmpty,
+				allowTrailingComma,
+				allowModifiers
+			);
+		}
+		const scratch = this._acquireScratch();
+		let count = 0;
+		let first = true;
+		while (!this.eat(close)) {
+			if (first) first = false;
+			else this.expect(tokTypes.comma);
+			if (allowEmpty && this.type === tokTypes.comma) {
+				scratch[count++] = null;
+			} else if (allowTrailingComma && this.afterTrailingComma(close)) {
+				break;
+			} else if (this.type === tokTypes.ellipsis) {
+				const rest = this.parseRestBinding();
+				this.parseBindingListItem(rest);
+				scratch[count++] = rest;
+				if (this.type === tokTypes.comma) {
+					this.raiseRecoverable(
+						this.start,
+						"Comma is not permitted after the rest element"
+					);
+				}
+				this.expect(close);
+				break;
+			} else {
+				scratch[count++] = this.parseAssignableListItem(allowModifiers);
+			}
+		}
+		return this._releaseScratch(scratch, count);
+	}
+
+	/**
+	 * Owned `parseParenAndDistinguishExpression`, an exact-semantics copy of
+	 * acorn 8's with the per-paren `DestructuringErrors` record pooled and the
+	 * expression list built in a scratch array. Non-lazy mode delegates (the
+	 * copy assumes ES6+, which `_lazy` guarantees via `ecmaVersion: "latest"`).
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
+	 * @param {boolean} canBeArrow whether this may be an arrow head
+	 * @param {boolean | string} forInit for-init context flag
+	 * @returns {Expression} expression node
+	 * @this {ParserInternals}
+	 */
+	parseParenAndDistinguishExpression(canBeArrow, forInit) {
+		if (!this._lazy || this._ecmaVersion < 6) {
+			return base.parseParenAndDistinguishExpression.call(
+				this,
+				canBeArrow,
+				forInit
+			);
+		}
+		const startPos = this.start;
+		const startLoc = this.startLoc;
+		const allowTrailingComma = this._ecmaVersion >= 8;
+		this.next();
+
+		const innerStartPos = this.start;
+		const innerStartLoc = this.startLoc;
+		const scratch = this._acquireScratch();
+		let count = 0;
+		let first = true;
+		let lastIsComma = false;
+		const refDestructuringErrors = this._acquireDestructuringErrors();
+		const oldYieldPos = this.yieldPos;
+		const oldAwaitPos = this.awaitPos;
+		let spreadStart;
+		this.yieldPos = 0;
+		this.awaitPos = 0;
+		// Do not save awaitIdentPos to allow checking awaits nested in parameters
+		while (this.type !== tokTypes.parenR) {
+			if (first) first = false;
+			else this.expect(tokTypes.comma);
+			if (
+				allowTrailingComma &&
+				this.afterTrailingComma(tokTypes.parenR, true)
+			) {
+				lastIsComma = true;
+				break;
+			} else if (this.type === tokTypes.ellipsis) {
+				spreadStart = this.start;
+				scratch[count++] = this.parseParenItem(this.parseRestBinding());
+				if (this.type === tokTypes.comma) {
+					this.raiseRecoverable(
+						this.start,
+						"Comma is not permitted after the rest element"
+					);
+				}
+				break;
+			} else {
+				scratch[count++] = this.parseMaybeAssign(
+					false,
+					refDestructuringErrors,
+					this.parseParenItem
+				);
+			}
+		}
+		const exprList = this._releaseScratch(scratch, count);
+		const innerEndPos = this.lastTokEnd;
+		this.expect(tokTypes.parenR);
+
+		if (
+			canBeArrow &&
+			this.shouldParseArrow(exprList) &&
+			this.eat(tokTypes.arrow)
 		) {
-			return false;
+			this.checkPatternErrors(refDestructuringErrors, false);
+			this.checkYieldAwaitInDefaultParams();
+			// last read of the pooled record was above, so the arrow body parse
+			// below can already reuse its pool slot
+			this._releaseDestructuringErrors();
+			this.yieldPos = oldYieldPos;
+			this.awaitPos = oldAwaitPos;
+			return this.parseParenArrowList(startPos, startLoc, exprList, forInit);
 		}
-		this.options.allowReturnOutsideFunction = true;
-		// acorn stamps Program.sourceType from this at parseTopLevel's end
-		this.options.sourceType = "script";
-		this.strict = false;
-		this.inModule = false;
-		this._moduleFallback = false;
-		return true;
+
+		if (exprList.length === 0 || lastIsComma) {
+			this.unexpected(this.lastTokStart);
+		}
+		if (spreadStart) this.unexpected(spreadStart);
+		this.checkExpressionErrors(refDestructuringErrors, true);
+		this._releaseDestructuringErrors();
+		this.yieldPos = oldYieldPos || this.yieldPos;
+		this.awaitPos = oldAwaitPos || this.awaitPos;
+
+		/** @type {Expression} */
+		let val;
+		if (exprList.length > 1) {
+			const seq = /** @type {Node & { expressions?: Expression[] }} */ (
+				this.startNodeAt(innerStartPos, innerStartLoc)
+			);
+			seq.expressions = exprList;
+			this.finishNodeAt(
+				/** @type {Node} */ (seq),
+				"SequenceExpression",
+				innerEndPos,
+				undefined
+			);
+			val = /** @type {Expression} */ (/** @type {unknown} */ (seq));
+		} else {
+			val = exprList[0];
+		}
+
+		if (this.options.preserveParens) {
+			const par = /** @type {Node & { expression?: Expression }} */ (
+				this.startNodeAt(startPos, startLoc)
+			);
+			par.expression = val;
+			return /** @type {Expression} */ (
+				/** @type {unknown} */ (
+					this.finishNode(/** @type {Node} */ (par), "ParenthesizedExpression")
+				)
+			);
+		}
+		return val;
 	}
 
 	/**
-	 * `parseReturnStatement` without a started node.
-	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
-	 * @param {number} start statement start offset
-	 * @returns {Node} return statement
+	 * Owned `afterTrailingComma`, acorn's verbatim (mode-independent), so the
+	 * owned list parsers do not bounce through the dist for each element.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/parseutil.js
+	 * @param {TokenType} tokType closing token type
+	 * @param {boolean=} notNext whether to leave the closing token unconsumed
+	 * @returns {boolean} true when the list ended on a trailing comma
 	 * @this {ParserInternals}
 	 */
-	_parseReturnStatementAt(start) {
-		if (!this.allowReturn && !this._tryModuleFallback()) {
-			this.raise(this.start, "'return' outside of function");
-		}
-		this.next();
-		/** @type {Expression | null} */
-		let argument = null;
-		// `return` takes an optional argument, so eagerly look for a semicolon
-		if (!(this.eat(tokTypes.semi) || this.insertSemicolon())) {
-			argument = this.parseExpression();
-			this.semicolon();
+	afterTrailingComma(tokType, notNext) {
+		if (this.type === tokType) {
+			const onTrailingComma =
+				/** @type {Options & { onTrailingComma?: (pos: number, loc?: Position) => void }} */
+				(this.options).onTrailingComma;
+			if (onTrailingComma) {
+				onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
+			}
+			if (!notNext) this.next();
+			return true;
 		}
-		return /** @type {Node} */ (
-			/** @type {unknown} */ (
-				new ReturnStatementNode(start, this.lastTokEnd, argument)
-			)
-		);
+		return false;
 	}
 
 	/**
-	 * Owned `parseSpread` landing on `RestSpreadNode`'s single shape.
-	 * Non-lazy mode delegates.
-	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/lval.js
-	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
-	 * @returns {Node} spread element
+	 * Owned `checkExpressionErrors`, acorn's verbatim (mode-independent): it
+	 * runs several times per expression from the owned spine.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/parseutil.js
+	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors record to inspect
+	 * @param {boolean=} andThrow whether to throw on error
+	 * @returns {boolean} whether an error position was set
 	 * @this {ParserInternals}
 	 */
-	parseSpread(refDestructuringErrors) {
-		if (!this._lazy) {
-			return base.parseSpread.call(this, refDestructuringErrors);
+	checkExpressionErrors(refDestructuringErrors, andThrow) {
+		if (!refDestructuringErrors) return false;
+		const shorthandAssign = refDestructuringErrors.shorthandAssign;
+		const doubleProto = refDestructuringErrors.doubleProto;
+		if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0;
+		if (shorthandAssign >= 0) {
+			this.raise(
+				shorthandAssign,
+				"Shorthand property assignments are valid only in destructuring patterns"
+			);
 		}
-		const start = this.start;
-		this.next();
-		const argument = this.parseMaybeAssign(false, refDestructuringErrors);
-		return /** @type {Node} */ (
-			/** @type {unknown} */ (
-				new RestSpreadNode(start, this.lastTokEnd, "SpreadElement", argument)
-			)
-		);
+		if (doubleProto >= 0) {
+			this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property");
+		}
+		return false;
 	}
 
 	/**
-	 * Owned `parseMaybeConditional` landing on
-	 * `ConditionalExpressionNode`'s single shape. Non-lazy mode delegates.
+	 * Owned `parseExpression`: acorn wraps every call in `catchStackOverflow`,
+	 * allocating a fresh closure per expression; inline the try/catch instead
+	 * (same overflow-message translation, no closure). Non-lazy mode delegates.
 	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean | string=} forInit for-init context flag
 	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
 	 * @returns {Expression} expression node
 	 * @this {ParserInternals}
 	 */
-	parseMaybeConditional(forInit, refDestructuringErrors) {
+	parseExpression(forInit, refDestructuringErrors) {
 		if (!this._lazy) {
-			return base.parseMaybeConditional.call(
-				this,
-				forInit,
-				refDestructuringErrors
-			);
+			return base.parseExpression.call(this, forInit, refDestructuringErrors);
 		}
-		const startPos = this.start;
-		const expr = this.parseExprOps(forInit, refDestructuringErrors);
-		if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
-		if (
-			!(expr.type === "ArrowFunctionExpression" && expr.start === startPos) &&
-			this.eat(tokTypes.question)
-		) {
-			const consequent = this.parseMaybeAssign();
-			this.expect(tokTypes.colon);
-			const alternate = this.parseMaybeAssign(forInit);
-			return /** @type {Expression} */ (
-				/** @type {unknown} */ (
-					new ConditionalExpressionNode(
-						startPos,
-						this.lastTokEnd,
-						expr,
-						consequent,
-						alternate
-					)
-				)
-			);
+		try {
+			const startPos = this.start;
+			const startLoc = this.startLoc;
+			const expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
+			if (this.type === tokTypes.comma) {
+				const node =
+					/** @type {Node & { expressions?: Expression[] }} */
+					(this.startNodeAt(startPos, startLoc));
+				node.expressions = [expr];
+				while (this.eat(tokTypes.comma)) {
+					node.expressions.push(
+						this.parseMaybeAssign(forInit, refDestructuringErrors)
+					);
+				}
+				return /** @type {Expression} */ (
+					/** @type {unknown} */ (this.finishNode(node, "SequenceExpression"))
+				);
+			}
+			return expr;
+		} catch (err) {
+			// acorn's catchStackOverflow: translate an engine stack-overflow error
+			if (
+				err instanceof Error &&
+				(/\bstack\b.*\b(exceeded|overflow)\b/i.test(err.message) ||
+					/\btoo much recursion\b/i.test(err.message))
+			) {
+				this.raise(this.start, "Not enough stack space to parse input");
+			}
+			throw err;
 		}
-		return expr;
 	}
 
 	/**
@@ -3786,27 +5817,31 @@ class WebpackParser extends BaseParser {
 		const isTagged = (opts !== undefined && opts.isTagged) === true;
 		const start = this.start;
 		this.next();
-		/** @type {Expression[]} */
-		const expressions = [];
+		const exprScratch = this._acquireScratch();
+		const quasiScratch = this._acquireScratch();
+		let exprCount = 0;
+		let quasiCount = 0;
 		// one options object for all chunks (only `isTagged` is ever read)
 		const eltOpts = { isTagged };
 		let curElt = /** @type {Node & { tail?: boolean }} */ (
 			this.parseTemplateElement(eltOpts)
 		);
-		const quasis = [/** @type {Node} */ (curElt)];
+		quasiScratch[quasiCount++] = curElt;
 		while (!curElt.tail) {
 			if (this.type === tokTypes.eof) {
 				this.raise(this.pos, "Unterminated template literal");
 			}
 			this.expect(tokTypes.dollarBraceL);
-			expressions.push(this.parseExpression());
+			exprScratch[exprCount++] = this.parseExpression();
 			this.expect(tokTypes.braceR);
 			curElt = /** @type {Node & { tail?: boolean }} */ (
 				this.parseTemplateElement(eltOpts)
 			);
-			quasis.push(/** @type {Node} */ (curElt));
+			quasiScratch[quasiCount++] = curElt;
 		}
 		this.next();
+		const quasis = this._releaseScratch(quasiScratch, quasiCount);
+		const expressions = this._releaseScratch(exprScratch, exprCount);
 		return /** @type {Node} */ (
 			/** @type {unknown} */ (
 				new TemplateLiteralNode(start, this.lastTokEnd, expressions, quasis)
@@ -3931,6 +5966,57 @@ class WebpackParser extends BaseParser {
 		return expr;
 	}
 
+	/**
+	 * Collapses the commonest expression shape — a name/number/string/keyword
+	 * literal or `this` whose next source character can only begin a token that
+	 * cannot continue an expression — into the atom, skipping the seven-layer
+	 * `parseMaybeAssign` → `parseExprAtom` descent and its destructuring-error
+	 * bookkeeping (which is a net no-op for a bare atom).
+	 * @param {boolean | string=} forInit for-init context flag
+	 * @returns {Expression | null} the atom, or `null` when the shape does not apply
+	 * @this {ParserInternals}
+	 */
+	_parseTrivialAtom(forInit) {
+		const code = this.input.charCodeAt(this.end);
+		if (code >= 128 || EXPRESSION_END_CHAR[code] !== 1) return null;
+		const type = this.type;
+		if (type === tokTypes.name) {
+			// both steer the chain themselves (`yield x`, `await x`)
+			const name = /** @type {string} */ (this.value);
+			if (name === "yield" || name === "await") return null;
+			this.potentialArrowAt = this.start;
+			this.potentialArrowInForAwait = forInit === "await";
+			return /** @type {Expression} */ (
+				/** @type {unknown} */ (this.parseIdent(false))
+			);
+		}
+		if (type === tokTypes.num || type === tokTypes.string) {
+			return /** @type {Expression} */ (
+				/** @type {unknown} */ (this.parseLiteral(this.value))
+			);
+		}
+		if (type === tokTypes._this) {
+			const node = new ThisNode(this.start, this.end);
+			this.next();
+			return /** @type {Expression} */ (/** @type {unknown} */ (node));
+		}
+		if (
+			type === tokTypes._null ||
+			type === tokTypes._true ||
+			type === tokTypes._false
+		) {
+			const node = new LiteralNode(
+				this.start,
+				this.end,
+				type === tokTypes._null ? null : type === tokTypes._true,
+				/** @type {string} */ (type.keyword)
+			);
+			this.next();
+			return /** @type {Expression} */ (/** @type {unknown} */ (node));
+		}
+		return null;
+	}
+
 	/**
 	 * Owned `parseMaybeAssign`, an exact-semantics copy of acorn 8's: the
 	 * operator is captured before `next()` and the `AssignmentExpression` is
@@ -3952,6 +6038,10 @@ class WebpackParser extends BaseParser {
 				afterLeftParse
 			);
 		}
+		if (this._exprFastPath && afterLeftParse === undefined) {
+			const atom = this._parseTrivialAtom(forInit);
+			if (atom !== null) return atom;
+		}
 		if (this.isContextual("yield")) {
 			if (this.inGenerator) return this.parseYield(forInit);
 			// the tokenizer assumed an expression follows `yield`, but this
@@ -4052,7 +6142,10 @@ class WebpackParser extends BaseParser {
 			forInit
 		);
 		if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
-		return expr.start === startPos && expr.type === "ArrowFunctionExpression"
+		const isArrow = this._arrowFastPath
+			? expr === this._lastArrow && expr.start === startPos
+			: expr.start === startPos && expr.type === "ArrowFunctionExpression";
+		return isArrow
 			? expr
 			: this.parseExprOp(expr, startPos, startLoc, -1, forInit);
 	}
@@ -4346,8 +6439,8 @@ class WebpackParser extends BaseParser {
 		} else {
 			propHash = {};
 		}
-		/** @type {Node[]} */
-		const properties = [];
+		const scratch = this._acquireScratch();
+		let count = 0;
 		this.next();
 		while (!this.eat(tokTypes.braceR)) {
 			if (!first) {
@@ -4360,7 +6453,7 @@ class WebpackParser extends BaseParser {
 			if (!isPattern) {
 				this.checkPropClash(prop, propHash, refDestructuringErrors);
 			}
-			properties.push(prop);
+			scratch[count++] = prop;
 		}
 		if (pooled) this._propHashDepth--;
 		return /** @type {Node} */ (
@@ -4369,7 +6462,7 @@ class WebpackParser extends BaseParser {
 					start,
 					this.lastTokEnd,
 					isPattern ? "ObjectPattern" : "ObjectExpression",
-					properties
+					this._releaseScratch(scratch, count)
 				)
 			)
 		);
@@ -4956,7 +7049,7 @@ class WebpackParser extends BaseParser {
 	}
 }
 
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @import { SourcePosition } from "../Dependency" */
 
 /**
  * Whether a raw string literal contains a legacy octal (`\47`, `\0` followed by
@@ -4990,13 +7083,13 @@ const hasOctalEscape = (raw) => {
 // these two helpers.
 
 /**
- * Offset of each line's first character. Char-code scan matching acorn's
- * `lineBreak` semantics (CRLF is one break): a regex `exec` loop here
- * allocates a match array per line.
+ * Exact char-code scan matching acorn's `lineBreak` semantics (CRLF is one
+ * break). Kept as the fallback for the terminators `buildLineStarts` cannot
+ * find with a native search.
  * @param {string} source source code
  * @returns {number[]} line start offsets
  */
-const buildLineStarts = (source) => {
+const scanLineStarts = (source) => {
 	const len = source.length;
 	const lineStarts = [0];
 	for (let i = 0; i < len; i++) {
@@ -5013,6 +7106,33 @@ const buildLineStarts = (source) => {
 	return lineStarts;
 };
 
+/**
+ * Offset of each line's first character. `indexOf` searches the source natively,
+ * which beats a char-code loop by ~3x; CRLF needs no special case because it
+ * starts the next line after its `\n` either way. A lone `\r` or a unicode
+ * separator does break that equivalence, so those fall back to the char scan.
+ * @param {string} source source code
+ * @returns {number[]} line start offsets
+ */
+const buildLineStarts = (source) => {
+	if (!source.includes("\u2028") && !source.includes("\u2029")) {
+		let cr = source.indexOf("\r");
+		while (cr !== -1 && source.charCodeAt(cr + 1) === 10) {
+			cr = source.indexOf("\r", cr + 2);
+		}
+		if (cr === -1) {
+			const lineStarts = [0];
+			let i = source.indexOf("\n");
+			while (i !== -1) {
+				lineStarts.push(i + 1);
+				i = source.indexOf("\n", i + 1);
+			}
+			return lineStarts;
+		}
+	}
+	return scanLineStarts(source);
+};
+
 /**
  * Binary search for the line containing the offset.
  * @param {number[]} lineStarts line start offsets
@@ -5030,8 +7150,334 @@ const positionAt = (lineStarts, offset) => {
 	return { line: lo + 1, column: offset - lineStarts[lo] };
 };
 
+const KEYWORDS_BEFORE_REGEXP = new Set([
+	"await",
+	"case",
+	"delete",
+	"do",
+	"else",
+	"in",
+	"instanceof",
+	"new",
+	"of",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+
+/**
+ * Whether a `/` at this point starts a regexp rather than division, decided by
+ * what precedes it: after a value (name, number, `)`, `]`) it divides, after an
+ * operator or a keyword it opens a regexp. `)` and `]` are always read as
+ * division — telling `if (a) /re/` from `(a) / b` needs paren-context tracking
+ * this single pass does not carry.
+ * @param {string} source source code
+ * @param {number} slash offset of the `/`
+ * @returns {boolean} true when a regexp literal starts here
+ */
+const startsRegExp = (source, slash) => {
+	let i = slash - 1;
+	while (i >= 0) {
+		const code = source.charCodeAt(i);
+		if (code === 32 || code === 9 || code === 10 || code === 13) i--;
+		else break;
+	}
+	if (i < 0) return true;
+	const code = source.charCodeAt(i);
+	if (code === 41 || code === 93) return false;
+	if (!isIdentifierChar(code)) return true;
+	// a keyword before `/` is an operator position (`return /re/`), a name is not
+	let start = i;
+	while (start >= 0 && isIdentifierChar(source.charCodeAt(start))) start--;
+	return KEYWORDS_BEFORE_REGEXP.has(source.slice(start + 1, i + 1));
+};
+
+/**
+ * Skips whitespace and comments, returning the next code offset.
+ * @param {string} source source code
+ * @param {number} i offset to start at
+ * @returns {number} offset of the next significant character
+ */
+const skipTrivia = (source, i) => {
+	while (i < source.length) {
+		const code = source.charCodeAt(i);
+		if (code === 32 || code === 9 || code === 10 || code === 13) {
+			i++;
+		} else if (code === 47 && source.charCodeAt(i + 1) === 47) {
+			const end = source.indexOf("\n", i + 2);
+			i = end === -1 ? source.length : end + 1;
+		} else if (code === 47 && source.charCodeAt(i + 1) === 42) {
+			const end = source.indexOf("*/", i + 2);
+			i = end === -1 ? source.length : end + 2;
+		} else {
+			break;
+		}
+	}
+	return i;
+};
+
+/** @type {Map<number, string>} */
+const SINGLE_CHARACTER_ESCAPES = new Map([
+	[110, "\n"],
+	[114, "\r"],
+	[116, "\t"],
+	[98, "\b"],
+	[118, "\u000B"],
+	[102, "\f"]
+]);
+
+/**
+ * Reads the hex digits of a `\x`/`\u` escape.
+ * @param {string} source source code
+ * @param {number} i offset of the first digit
+ * @param {number} length how many digits to read
+ * @returns {number} the code point, or `-1` when a digit is missing
+ */
+const readHexEscapeValue = (source, i, length) => {
+	let value = 0;
+	for (let j = i; j < i + length; j++) {
+		const digit = Number.parseInt(source[j], 16);
+		if (Number.isNaN(digit)) return -1;
+		value = value * 16 + digit;
+	}
+	return value;
+};
+
+/**
+ * Cooks one escape sequence, sloppy-mode script semantics (legacy octal included).
+ * @param {string} source source code
+ * @param {number} i offset just past the backslash
+ * @returns {{ value: string, end: number } | undefined} the cooked text, or `undefined` when malformed
+ */
+const readEscape = (source, i) => {
+	if (i >= source.length) return;
+	const code = source.charCodeAt(i);
+	const single = SINGLE_CHARACTER_ESCAPES.get(code);
+	if (single !== undefined) return { value: single, end: i + 1 };
+	// a line continuation cooks to nothing; `\r\n` counts as one terminator
+	if (code === 13) {
+		return { value: "", end: source.charCodeAt(i + 1) === 10 ? i + 2 : i + 1 };
+	}
+	if (code === 10 || code === 0x2028 || code === 0x2029) {
+		return { value: "", end: i + 1 };
+	}
+	if (code === 120) {
+		const value = readHexEscapeValue(source, i + 1, 2);
+		if (value === -1) return;
+		return { value: String.fromCodePoint(value), end: i + 3 };
+	}
+	if (code === 117) {
+		if (source.charCodeAt(i + 1) === 123) {
+			const end = source.indexOf("}", i + 2);
+			if (end === -1 || end === i + 2) return;
+			const value = readHexEscapeValue(source, i + 2, end - i - 2);
+			if (value === -1 || value > 0x10ffff) return;
+			return { value: String.fromCodePoint(value), end: end + 1 };
+		}
+		const value = readHexEscapeValue(source, i + 1, 4);
+		if (value === -1) return;
+		return { value: String.fromCodePoint(value), end: i + 5 };
+	}
+	if (code >= 48 && code <= 55) {
+		let digits = /** @type {RegExpMatchArray} */ (
+			source.slice(i, i + 3).match(/^[0-7]+/)
+		)[0];
+		if (Number.parseInt(digits, 8) > 255) digits = digits.slice(0, -1);
+		return {
+			value: String.fromCharCode(Number.parseInt(digits, 8)),
+			end: i + digits.length
+		};
+	}
+	return { value: source[i], end: i + 1 };
+};
+
+/**
+ * Reads a `'`/`"` string starting at `i`, cooking its escapes the way the ast
+ * this replaces did — a `Literal` node carries the cooked value, so a specifier
+ * written `"\x2e/a"` is the same dependency as `"./a"`. Templates are not
+ * specifiers here: the ast only matched `Literal` nodes.
+ * @param {string} source source code
+ * @param {number} i offset of the opening quote
+ * @returns {{ value: string, end: number } | undefined} the literal
+ */
+const readStringLiteral = (source, i) => {
+	const quote = source.charCodeAt(i);
+	if (quote !== 34 && quote !== 39) return;
+	for (let j = i + 1; j < source.length; j++) {
+		const code = source.charCodeAt(j);
+		if (code === 10 || code === 13) return;
+		if (code === 92) return readEscapedStringLiteral(source, i, j);
+		if (code === quote) return { value: source.slice(i + 1, j), end: j + 1 };
+	}
+};
+
+/**
+ * Continues `readStringLiteral` from its first escape, so the unescaped case
+ * stays a single slice.
+ * @param {string} source source code
+ * @param {number} i offset of the opening quote
+ * @param {number} firstEscape offset of the first backslash
+ * @returns {{ value: string, end: number } | undefined} the literal
+ */
+const readEscapedStringLiteral = (source, i, firstEscape) => {
+	const quote = source.charCodeAt(i);
+	let value = "";
+	let segment = i + 1;
+	for (let j = firstEscape; j < source.length; j++) {
+		const code = source.charCodeAt(j);
+		if (code === 10 || code === 13) return;
+		if (code === quote) {
+			return { value: value + source.slice(segment, j), end: j + 1 };
+		}
+		if (code !== 92) continue;
+		const escape = readEscape(source, j + 1);
+		if (escape === undefined) return;
+		value += source.slice(segment, j) + escape.value;
+		segment = escape.end;
+		j = escape.end - 1;
+	}
+};
+
+/**
+ * Scans a template body from `i` (just past a backtick or a `}` resuming one).
+ * @param {string} source source code
+ * @param {number} i offset inside the template
+ * @returns {{ end: number, substitution: boolean }} where the body stops
+ */
+const skipTemplateBody = (source, i) => {
+	for (; i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code === 92) {
+			i++;
+		} else if (code === 96) {
+			return { end: i, substitution: false };
+		} else if (code === 36 && source.charCodeAt(i + 1) === 123) {
+			return { end: i + 1, substitution: true };
+		}
+	}
+	return { end: source.length, substitution: false };
+};
+
+/**
+ * Collects the specifiers of static `require("…")` calls. A scan rather than a
+ * parse: it only has to skip what could hide or fake a call — comments, strings,
+ * templates and regexps — so it costs one pass and builds no ast. Template
+ * substitutions are scanned as the code they are, which is why the brace depth
+ * of each open `${` is tracked.
+ * @param {string} source source code
+ * @returns {Set<string>} required specifiers
+ */
+const collectCjsRequireSpecifiers = (source) => {
+	/** @type {Set<string>} */
+	const specifiers = new Set();
+	/** @type {number[]} */
+	const templateBraceDepths = [];
+	let braceDepth = 0;
+	for (let i = 0; i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code === 96) {
+			const body = skipTemplateBody(source, i + 1);
+			i = body.end;
+			if (body.substitution) {
+				templateBraceDepths.push(braceDepth);
+				braceDepth++;
+			}
+			continue;
+		}
+		if (code === 123) {
+			braceDepth++;
+			continue;
+		}
+		if (code === 125) {
+			braceDepth--;
+			if (
+				templateBraceDepths.length > 0 &&
+				templateBraceDepths[templateBraceDepths.length - 1] === braceDepth
+			) {
+				templateBraceDepths.pop();
+				const body = skipTemplateBody(source, i + 1);
+				i = body.end;
+				if (body.substitution) {
+					templateBraceDepths.push(braceDepth);
+					braceDepth++;
+				}
+			}
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			for (i++; i < source.length; i++) {
+				const inner = source.charCodeAt(i);
+				if (inner === 92) i++;
+				else if (inner === code) break;
+			}
+			continue;
+		}
+		if (code === 47) {
+			const next = source.charCodeAt(i + 1);
+			if (next === 47) {
+				const end = source.indexOf("\n", i + 2);
+				i = end === -1 ? source.length : end;
+				continue;
+			}
+			if (next === 42) {
+				const end = source.indexOf("*/", i + 2);
+				i = end === -1 ? source.length : end + 1;
+				continue;
+			}
+			if (!startsRegExp(source, i)) continue;
+			let inClass = false;
+			for (i++; i < source.length; i++) {
+				const inner = source.charCodeAt(i);
+				if (inner === 92) i++;
+				else if (inner === 91) inClass = true;
+				else if (inner === 93) inClass = false;
+				else if (inner === 10) break;
+				else if (inner === 47 && !inClass) break;
+			}
+			continue;
+		}
+		// `r` of `require`, as a whole word that is not a member access
+		if (code !== 114 || !source.startsWith("require", i)) continue;
+		if (isIdentifierChar(source.charCodeAt(i + 7))) continue;
+		if (i > 0) {
+			const before = source.charCodeAt(i - 1);
+			if (isIdentifierChar(before) || before === 46) continue;
+		}
+		let j = skipTrivia(source, i + 7);
+		if (source.charCodeAt(j) !== 40) continue;
+		j = skipTrivia(source, j + 1);
+		// a cast wraps the specifier in its own parens: `require(/** … */ ("x"))`
+		let parens = 0;
+		while (source.charCodeAt(j) === 40) {
+			parens++;
+			j = skipTrivia(source, j + 1);
+		}
+		const literal = readStringLiteral(source, j);
+		if (literal === undefined) {
+			i += 6;
+			continue;
+		}
+		j = skipTrivia(source, literal.end);
+		while (parens > 0 && source.charCodeAt(j) === 41) {
+			parens--;
+			j = skipTrivia(source, j + 1);
+		}
+		if (parens !== 0 || source.charCodeAt(j) !== 41) {
+			i += 6;
+			continue;
+		}
+		specifiers.add(literal.value);
+		i = j;
+	}
+	return specifiers;
+};
+
 module.exports.LEGACY_ASSERT_ATTRIBUTES = LEGACY_ASSERT_ATTRIBUTES;
 module.exports.WebpackParser = WebpackParser;
 module.exports.buildLineStarts = buildLineStarts;
+module.exports.collectCjsRequireSpecifiers = collectCjsRequireSpecifiers;
 module.exports.hasOctalEscape = hasOctalEscape;
+module.exports.isIdentifierChar = isIdentifierChar;
 module.exports.positionAt = positionAt;