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

package/lib/javascript/syntax.js

@@ -36,6 +36,45 @@ const keywordTypes =
 		(/** @type {unknown} */ (require("acorn"))).keywordTypes
 	);
 
+// acorn exports these Unicode/character helpers at runtime but leaves them out
+// of its public types; the ported cold-path readers below reuse them so their
+// classification stays byte-identical to acorn's tokenizer.
+const {
+	isIdentifierChar,
+	isIdentifierStart,
+	isNewLine,
+	lineBreak,
+	nonASCIIwhitespace
+} =
+	/** @type {{ isIdentifierStart: (code: number, astral?: boolean) => boolean, isIdentifierChar: (code: number, astral?: boolean) => boolean, isNewLine: (code: number) => boolean, lineBreak: RegExp, nonASCIIwhitespace: RegExp }} */
+	(/** @type {unknown} */ (require("acorn")));
+
+/**
+ * @param {number} code code point
+ * @returns {string} the string for a single code point
+ */
+const codePointToString = (code) => String.fromCodePoint(code);
+
+/**
+ * acorn's `stringToNumber`: legacy octal parses in base 8, everything else via
+ * `parseFloat` after dropping `_` separators.
+ * @param {string} str numeric literal text (may contain `_` separators)
+ * @param {boolean} isLegacyOctal whether it is a legacy octal literal
+ * @returns {number} numeric value
+ */
+const stringToNumber = (str, isLegacyOctal) =>
+	isLegacyOctal
+		? Number.parseInt(str, 8)
+		: Number.parseFloat(str.replace(/_/g, ""));
+
+/**
+ * acorn's `stringToBigInt`, minus the pre-BigInt fallback (every supported
+ * Node has `BigInt`).
+ * @param {string} str numeric literal text (may contain `_` separators)
+ * @returns {bigint} bigint value
+ */
+const stringToBigInt = (str) => BigInt(str.replace(/_/g, ""));
+
 /** @typedef {import("acorn").Options} Options */
 /** @typedef {import("acorn").Position} Position */
 /** @typedef {import("acorn").Node} Node */
@@ -867,6 +906,18 @@ class Scope {
  * readNumber: (startsWithDot: boolean) => void,
  * readRadixNumber: (radix: number) => void,
  * readTmplToken: () => void,
+ * invalidStringToken: (position: number, message: string) => void,
+ * _readInt: (radix: number, len?: number, maybeLegacyOctal?: boolean) => number | null,
+ * _readCodePoint: () => number,
+ * _readHexChar: (len: number) => number,
+ * _readEscapedChar: (inTemplate: boolean) => string,
+ * _readStringCold: (quote: number) => void,
+ * _readTmplTokenCold: () => void,
+ * _readNumberCold: (startsWithDot: boolean) => void,
+ * _readRadixNumber: (radix: number) => void,
+ * _readWord1Cold: () => string,
+ * _skipSpaceCold: () => void,
+ * _getUnknownOrPrivate: (code: number) => void,
  * finishToken: (type: TokenType, value?: unknown) => void,
  * context: TokContextShim[],
  * pos: number,
@@ -1030,6 +1081,26 @@ const WORD_CACHE_MAX_LEN = 12;
 /** @type {Map<number, string>} */
 const OP_CACHE = new Map();
 
+// The regexp flag whitelist depends only on the ecmaVersion, so build one
+// string per version instead of a fresh one in every parser constructor.
+/** @type {Map<number, string>} */
+const VALID_REGEXP_FLAGS = new Map();
+
+/**
+ * @param {number} ecmaVersion normalized acorn ecmaVersion
+ * @returns {string} the regexp flags allowed at `ecmaVersion`
+ */
+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" : ""}`;
+		VALID_REGEXP_FLAGS.set(ecmaVersion, flags);
+	}
+	return flags;
+};
+
 // Sticky mirrors of acorn's `skipWhiteSpace` / string-literal / `lineBreak`
 // regexes for the owned `strictDirective` (they scan at an offset, no slice).
 const STRICT_SKIP_WS = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
@@ -1211,9 +1282,7 @@ class WebpackParser extends BaseParser {
 		this._propHashStack = [];
 		this._propHashDepth = 0;
 		// `readRegexp`'s flag whitelist depends only on the ecmaVersion
-		this._validRegexpFlags = `gim${this._ecmaVersion >= 6 ? "uy" : ""}${
-			this._ecmaVersion >= 9 ? "s" : ""
-		}${this._ecmaVersion >= 13 ? "d" : ""}${this._ecmaVersion >= 15 ? "v" : ""}`;
+		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;
@@ -1267,6 +1336,7 @@ class WebpackParser extends BaseParser {
 	 * 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.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @returns {void}
 	 * @this {ParserInternals}
 	 */
@@ -1300,9 +1370,9 @@ class WebpackParser extends BaseParser {
 			cls = CHAR_CLASS[code];
 			if (cls < CLS_SPACE) {
 				if (cls === CLS_UNICODE) {
-					// unicode whitespace / line terminators: acorn consumes the rest
+					// unicode whitespace / line terminators: the cold reader consumes them
 					this.pos = pos;
-					base.skipSpace.call(this);
+					this._skipSpaceCold();
 					pos = this.pos;
 					if (newline === 0) newline = 2;
 					code = pos < len ? input.charCodeAt(pos) : 0;
@@ -1375,6 +1445,7 @@ class WebpackParser extends BaseParser {
 	 * `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
 	 * @returns {void}
@@ -1442,6 +1513,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `braceIsBlock`, acorn's verbatim except the line-terminator probe:
 	 * acorn slices the inter-token gap and runs a regexp; `_gapHasNewline`
 	 * answers from the tokenizer's newline flag (scanning only when unknown).
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokencontext.js
 	 * @param {TokenType} prevType type of the previous token
 	 * @returns {boolean} whether a `{` opens a block in this context
 	 * @this {ParserInternals}
@@ -1515,6 +1587,7 @@ class WebpackParser extends BaseParser {
 	 * `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.
+	 * 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}
@@ -1540,6 +1613,7 @@ class WebpackParser extends BaseParser {
 	 * every operator token, allocating a fresh 2-4 char string per `=>`, `===`,
 	 * `&&` etc. Serve those from `OP_CACHE` instead; single-char operators keep
 	 * the direct slice, which V8 serves from its single-character table.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @param {TokenType} type token type
 	 * @param {number} size operator length
 	 * @returns {void}
@@ -1571,7 +1645,9 @@ class WebpackParser extends BaseParser {
 	 * `readToken_*` methods that each end in `finishOp`'s source slice. Resolve
 	 * every operator by direct char peeks to a static string instead (yuku's
 	 * `scanPunctuation`) — no method chain, no slice, no `OP_CACHE` probe. The
-	 * HTML-comment forms (`<!--`, `-->`), `#`, and unknown chars delegate.
+	 * HTML-comment forms (`<!--`, `-->`) inline acorn's line-comment handling;
+	 * `#` and unknown chars use the owned cold reader.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @param {number} code current char code
 	 * @returns {void}
 	 * @this {ParserInternals}
@@ -1697,8 +1773,17 @@ class WebpackParser extends BaseParser {
 				// '-': --, -= or -; `-->` may open an HTML line comment
 				const next = input.charCodeAt(pos + 1);
 				if (next === 45) {
-					if (input.charCodeAt(pos + 2) === 62 && !this.inModule) {
-						return base.getTokenFromCode.call(this, code);
+					// `-->` opens an HTML line comment only at the start of a line
+					// (acorn readToken_plus_min): https://github.com/acornjs/acorn/blob/8.15.0/acorn/src/tokenize.js#L599-L618
+					if (
+						input.charCodeAt(pos + 2) === 62 &&
+						!this.inModule &&
+						(this.lastTokEnd === 0 ||
+							lineBreak.test(input.slice(this.lastTokEnd, pos)))
+					) {
+						this.skipLineComment(3);
+						this.skipSpace();
+						return this.nextToken();
 					}
 					this.pos = pos + 2;
 					return this.finishToken(tokTypes.incDec, "--");
@@ -1727,7 +1812,11 @@ class WebpackParser extends BaseParser {
 					input.charCodeAt(pos + 2) === 45 &&
 					input.charCodeAt(pos + 3) === 45
 				) {
-					return base.getTokenFromCode.call(this, code);
+					// `<!--` opens an HTML line comment (acorn readToken_lt_gt):
+					// https://github.com/acornjs/acorn/blob/8.15.0/acorn/src/tokenize.js#L620-L649
+					this.skipLineComment(4);
+					this.skipSpace();
+					return this.nextToken();
 				}
 				if (next === 61) {
 					this.pos = pos + 2;
@@ -1828,9 +1917,9 @@ class WebpackParser extends BaseParser {
 			case 48: {
 				// '0': radix literals split off before the decimal reader
 				const next = input.charCodeAt(pos + 1);
-				if (next === 120 || next === 88) return this.readRadixNumber(16);
-				if (next === 111 || next === 79) return this.readRadixNumber(8);
-				if (next === 98 || next === 66) return this.readRadixNumber(2);
+				if (next === 120 || next === 88) return this._readRadixNumber(16);
+				if (next === 111 || next === 79) return this._readRadixNumber(8);
+				if (next === 98 || next === 66) return this._readRadixNumber(2);
 				return this.readNumber(false);
 			}
 			case 49:
@@ -1847,18 +1936,19 @@ class WebpackParser extends BaseParser {
 			case 39:
 				return this.readString(code);
 			default:
-				return base.getTokenFromCode.call(this, code);
+				return this._getUnknownOrPrivate(code);
 		}
 	}
 
 	/**
 	 * ASCII fast path for acorn's `readWord1`, which pays a surrogate-aware
 	 * method call and a range-check helper per character. Escapes, non-ASCII
-	 * and astral input restart the base implementation from the word start.
+	 * and astral input restart the owned cold reader from the word start.
 	 * Words are deduplicated through `WORD_CACHE` so repeated identifiers —
 	 * which dominate real code — reuse one string instead of slicing a fresh
 	 * one per occurrence; sharing also keeps their cached string hashes warm
 	 * for the keyword/scope Map lookups downstream.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @returns {string} the word
 	 */
@@ -1876,13 +1966,13 @@ class WebpackParser extends BaseParser {
 			if (ch < 128) {
 				if (IDENT_CHAR[ch] === 0) {
 					// backslash escape: restart cold so escape rules see the word
-					if (ch === 92) return base.readWord1.call(this);
+					if (ch === 92) return this._readWord1Cold();
 					break;
 				}
 				hash = (Math.imul(hash, 33) + ch) | 0;
 				pos++;
 			} else {
-				return base.readWord1.call(this);
+				return this._readWord1Cold();
 			}
 		}
 		this.containsEsc = false;
@@ -1908,11 +1998,12 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
-	 * String fast path: one scan that both finds the closing quote and vets the
-	 * span (the former `indexOf` + verify-loop pair read every string twice).
-	 * Escapes, newlines in the span, old ecmaVersions (LS/PS terminate strings
-	 * there) and location tracking restart acorn's implementation, which also
-	 * produces its exact errors.
+	 * String fast path: one scan finds the closing quote and cooks the common
+	 * single-char escapes (`\n \t \\ \" \'` …) and line continuations inline.
+	 * Hex/unicode/octal escapes (`\x`, `\u`, `\0`-`\9`) restart the owned cold
+	 * reader, which owns their readers and strict-mode errors; old ecmaVersions
+	 * (LS/PS terminate strings there) and location tracking use acorn's own.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @param {number} quote quote char code
 	 * @returns {void}
@@ -1923,33 +2014,94 @@ class WebpackParser extends BaseParser {
 		}
 		const input = this.input;
 		const len = input.length;
-		const start = this.pos + 1;
+		const quotePos = this.pos;
+		const start = quotePos + 1;
 		let pos = start;
+		// spans between escapes accumulate here; a plain string never touches
+		// `out` and slices once at the end
+		let out = "";
+		let chunkStart = start;
 		for (;;) {
 			if (pos >= len) this.raise(this.start, "Unterminated string constant");
 			const ch = input.charCodeAt(pos);
 			if (ch === quote) break;
-			// backslash, LF, CR
-			if (ch === 92 || ch === 10 || ch === 13) {
-				return base.readString.call(this, quote);
+			if (ch === 92) {
+				const esc = input.charCodeAt(pos + 1);
+				// hex/unicode/octal escapes (and a trailing `\`) need the cold
+				// reader's escape handling; restart from the quote (this.pos unmoved)
+				if (
+					pos + 1 >= len ||
+					esc === 120 ||
+					esc === 117 ||
+					(esc >= 48 && esc <= 57)
+				) {
+					this.pos = quotePos;
+					return this._readStringCold(quote);
+				}
+				let rep;
+				let advance = 2;
+				switch (esc) {
+					case 110:
+						rep = "\n";
+						break;
+					case 114:
+						rep = "\r";
+						break;
+					case 116:
+						rep = "\t";
+						break;
+					case 98:
+						rep = "\b";
+						break;
+					case 102:
+						rep = "\f";
+						break;
+					case 118:
+						rep = "\u000B";
+						break;
+					case 13:
+						// `\` + CR(LF): line continuation cooked away
+						rep = "";
+						if (input.charCodeAt(pos + 2) === 10) advance = 3;
+						break;
+					case 10:
+					case 0x2028:
+					case 0x2029:
+						rep = "";
+						break;
+					default:
+						// any other escape is the escaped code unit verbatim (`\\`, `\q`)
+						rep = input[pos + 1];
+				}
+				out += input.slice(chunkStart, pos) + rep;
+				pos += advance;
+				chunkStart = pos;
+			} else if (ch === 10 || ch === 13) {
+				// bare LF/CR is unterminated; LS/PS stay valid at ES2019+
+				this.raise(this.start, "Unterminated string constant");
+			} else {
+				pos++;
 			}
-			pos++;
 		}
 		this.pos = pos + 1;
-		this.finishToken(tokTypes.string, input.slice(start, pos));
+		if (chunkStart === start) {
+			return this.finishToken(tokTypes.string, input.slice(start, pos));
+		}
+		this.finishToken(tokTypes.string, out + input.slice(chunkStart, pos));
 	}
 
 	/**
 	 * Number fast path: plain integer literals (no leading zero, up to 15
 	 * digits so the float is exact) are accumulated numerically — no slice,
 	 * no parseFloat, no separator handling. Everything else (dots, exponents,
-	 * bigints, separators, octal forms) restarts acorn's implementation.
+	 * bigints, separators, octal forms) restarts the owned cold reader.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @param {boolean} startsWithDot whether the number started with a dot
 	 * @returns {void}
 	 */
 	readNumber(startsWithDot) {
-		if (startsWithDot) return base.readNumber.call(this, startsWithDot);
+		if (startsWithDot) return this._readNumberCold(startsWithDot);
 		const input = this.input;
 		const start = this.pos;
 		const len = input.length;
@@ -1962,7 +2114,7 @@ class WebpackParser extends BaseParser {
 				pos = start + 1;
 			} else if (c1 > 127 || IDENT_CHAR[c1] === 1) {
 				// 0x/0o/0b, 0e…, 0n, 0_, legacy `0NN`, or `0`+identifier: acorn
-				return base.readNumber.call(this, startsWithDot);
+				return this._readNumberCold(startsWithDot);
 			} else {
 				// bare `0` before punctuation/operator/whitespace/EOF
 				this.pos = start + 1;
@@ -1993,18 +2145,18 @@ class WebpackParser extends BaseParser {
 					after > 127 ||
 					IDENT_CHAR[after] === 1
 				) {
-					return base.readNumber.call(this, startsWithDot);
+					return this._readNumberCold(startsWithDot);
 				}
 				// 15 digits always fit exactly into a double
 				if (pos - start > 15) {
-					return base.readNumber.call(this, startsWithDot);
+					return this._readNumberCold(startsWithDot);
 				}
 				this.pos = pos;
 				return this.finishToken(tokTypes.num, value);
 			}
 			// a fraction follows the integer part
 		} else {
-			return base.readNumber.call(this, startsWithDot);
+			return this._readNumberCold(startsWithDot);
 		}
 		// decimal fraction: `pos` is at the '.'
 		pos++;
@@ -2024,7 +2176,7 @@ class WebpackParser extends BaseParser {
 			after > 127 ||
 			IDENT_CHAR[after] === 1
 		) {
-			return base.readNumber.call(this, startsWithDot);
+			return this._readNumberCold(startsWithDot);
 		}
 		this.pos = pos;
 		this.finishToken(tokTypes.num, Number.parseFloat(input.slice(start, pos)));
@@ -2035,6 +2187,7 @@ class WebpackParser extends BaseParser {
 	 * `this.input.slice(start)` — a fresh sliced string per (sloppy-mode)
 	 * function body. Sticky regexes at the offset scan the same grammar with no
 	 * slice. Same directive-prologue semantics, including the ASI tail checks.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/parseutil.js
 	 * @param {number} start offset of the function body's first statement
 	 * @returns {boolean} true when a 'use strict' directive leads the prologue
 	 * @this {ParserInternals & { input: string, options: { ecmaVersion: number } }}
@@ -2079,9 +2232,10 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * Template fast path: when the chunk contains no backslash and no CR, the
-	 * cooked value is one slice (LF/LS/PS cook to themselves). Escapes, CR
-	 * normalization and location tracking restart acorn's implementation,
-	 * which also produces its exact errors.
+	 * cooked value is one slice (LF/LS/PS cook to themselves). Escapes and CR
+	 * normalization restart the owned cold reader (its exact errors); location
+	 * tracking uses acorn's own.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @returns {void}
 	 */
@@ -2109,9 +2263,9 @@ class WebpackParser extends BaseParser {
 				this.pos = pos;
 				return this.finishToken(tokTypes.template, input.slice(start, pos));
 			}
-			// backslash and CR need acorn's cooked-string building
+			// backslash and CR need the cooked-string building of the cold reader
 			if (ch === 92 || ch === 13) {
-				return base.readTmplToken.call(this);
+				return this._readTmplTokenCold();
 			}
 			pos++;
 		}
@@ -2119,8 +2273,9 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
-	 * Fast path for the common run of plain ASCII whitespace; comments,
-	 * unicode whitespace and location tracking delegate to acorn.
+	 * Fast path for the common run of plain ASCII whitespace; comments and
+	 * unicode whitespace use the owned cold reader, location tracking acorn's.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals & { pos: number }}
 	 * @returns {void}
 	 */
@@ -2135,9 +2290,9 @@ class WebpackParser extends BaseParser {
 			if (ch === 32 || (ch > 8 && ch < 14)) {
 				pos++;
 			} else if (ch === 47 || ch > 127) {
-				// comments or unicode whitespace: let acorn handle the rest
+				// comments or unicode whitespace: hand off to the cold reader
 				this.pos = pos;
-				return base.skipSpace.call(this);
+				return this._skipSpaceCold();
 			} else {
 				break;
 			}
@@ -2145,12 +2300,468 @@ class WebpackParser extends BaseParser {
 		this.pos = pos;
 	}
 
+	// ----- cold-path readers (ported from acorn's tokenizer, reached only from
+	// the lazy fast paths above; non-lazy mode keeps acorn's own prototype
+	// methods so plugins that patch them still see acorn's tokenizer) -----
+
+	/**
+	 * acorn `readInt`: reads `radix`-base digits (optionally exactly `len` of
+	 * them), honoring ES2021 `_` separators.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {number} radix numeric radix
+	 * @param {number=} len fixed digit count (for escapes), else read greedily
+	 * @param {boolean=} maybeLegacyOctal whether a leading zero disallows separators
+	 * @returns {number | null} the integer value, or null when no digits matched
+	 */
+	_readInt(radix, len, maybeLegacyOctal) {
+		const input = this.input;
+		const allowSeparators = this._ecmaVersion >= 12 && len === undefined;
+		const isLegacyOctal =
+			maybeLegacyOctal === true && input.charCodeAt(this.pos) === 48;
+		const start = this.pos;
+		let total = 0;
+		let lastCode = 0;
+		for (
+			let i = 0, e = len === undefined ? Infinity : len;
+			i < e;
+			++i, ++this.pos
+		) {
+			const code = input.charCodeAt(this.pos);
+			let val;
+			if (allowSeparators && code === 95) {
+				if (isLegacyOctal) {
+					this.raiseRecoverable(
+						this.pos,
+						"Numeric separator is not allowed in legacy octal numeric literals"
+					);
+				}
+				if (lastCode === 95) {
+					this.raiseRecoverable(
+						this.pos,
+						"Numeric separator must be exactly one underscore"
+					);
+				}
+				if (i === 0) {
+					this.raiseRecoverable(
+						this.pos,
+						"Numeric separator is not allowed at the first of digits"
+					);
+				}
+				lastCode = code;
+				continue;
+			}
+			if (code >= 97) val = code - 97 + 10;
+			else if (code >= 65) val = code - 65 + 10;
+			else if (code >= 48 && code <= 57) val = code - 48;
+			else val = Infinity;
+			if (val >= radix) break;
+			lastCode = code;
+			total = total * radix + val;
+		}
+		if (allowSeparators && lastCode === 95) {
+			this.raiseRecoverable(
+				this.pos - 1,
+				"Numeric separator is not allowed at the last of digits"
+			);
+		}
+		if (this.pos === start || (len !== undefined && this.pos - start !== len)) {
+			return null;
+		}
+		return total;
+	}
+
+	/**
+	 * acorn `readRadixNumber`: `0x`/`0o`/`0b` integer or bigint literals.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {number} radix numeric radix (2/8/16)
+	 * @returns {void}
+	 */
+	_readRadixNumber(radix) {
+		const input = this.input;
+		const start = this.pos;
+		this.pos += 2;
+		let val = this._readInt(radix);
+		if (val === null) {
+			this.raise(this.start + 2, `Expected number in radix ${radix}`);
+		}
+		if (this._ecmaVersion >= 11 && input.charCodeAt(this.pos) === 110) {
+			val = /** @type {EXPECTED_ANY} */ (
+				stringToBigInt(input.slice(start, this.pos))
+			);
+			++this.pos;
+		} else if (isIdentifierStart(this.fullCharCodeAtPos())) {
+			this.raise(this.pos, "Identifier directly after number");
+		}
+		return this.finishToken(tokTypes.num, val);
+	}
+
+	/**
+	 * acorn `readNumber`: decimal/float/legacy-octal/bigint literals (the fast
+	 * path handles only plain integers and simple fractions).
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {boolean} startsWithDot whether the literal started with `.`
+	 * @returns {void}
+	 */
+	_readNumberCold(startsWithDot) {
+		const input = this.input;
+		const start = this.pos;
+		if (!startsWithDot && this._readInt(10, undefined, true) === null) {
+			this.raise(start, "Invalid number");
+		}
+		let octal = this.pos - start >= 2 && input.charCodeAt(start) === 48;
+		if (octal && this.strict) this.raise(start, "Invalid number");
+		let next = input.charCodeAt(this.pos);
+		if (!octal && !startsWithDot && this._ecmaVersion >= 11 && next === 110) {
+			const val = stringToBigInt(input.slice(start, this.pos));
+			++this.pos;
+			if (isIdentifierStart(this.fullCharCodeAtPos())) {
+				this.raise(this.pos, "Identifier directly after number");
+			}
+			return this.finishToken(tokTypes.num, /** @type {EXPECTED_ANY} */ (val));
+		}
+		if (octal && /[89]/.test(input.slice(start, this.pos))) octal = false;
+		if (next === 46 && !octal) {
+			++this.pos;
+			this._readInt(10);
+			next = input.charCodeAt(this.pos);
+		}
+		if ((next === 69 || next === 101) && !octal) {
+			next = input.charCodeAt(++this.pos);
+			if (next === 43 || next === 45) ++this.pos;
+			if (this._readInt(10) === null) this.raise(start, "Invalid number");
+		}
+		if (isIdentifierStart(this.fullCharCodeAtPos())) {
+			this.raise(this.pos, "Identifier directly after number");
+		}
+		const val = stringToNumber(input.slice(start, this.pos), octal);
+		return this.finishToken(tokTypes.num, val);
+	}
+
+	/**
+	 * acorn `readCodePoint`: a `\u{...}` or `\uXXXX` escape.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @returns {number} the escaped code point
+	 */
+	_readCodePoint() {
+		const input = this.input;
+		const ch = input.charCodeAt(this.pos);
+		let code;
+		if (ch === 123) {
+			if (this._ecmaVersion < 6) this.unexpected();
+			const codePos = ++this.pos;
+			code = this._readHexChar(input.indexOf("}", this.pos) - this.pos);
+			++this.pos;
+			if (code > 0x10ffff) {
+				this.invalidStringToken(codePos, "Code point out of bounds");
+			}
+		} else {
+			code = this._readHexChar(4);
+		}
+		return code;
+	}
+
+	/**
+	 * acorn `readHexChar`: exactly `len` hex digits.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {number} len number of hex digits
+	 * @returns {number} the parsed code
+	 */
+	_readHexChar(len) {
+		const codePos = this.pos;
+		const n = this._readInt(16, len);
+		if (n === null) {
+			this.invalidStringToken(codePos, "Bad character escape sequence");
+		}
+		return /** @type {number} */ (n);
+	}
+
+	/**
+	 * acorn `readString`: the escape-bearing string reader (the fast path cooks
+	 * only the common single-char escapes inline).
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {number} quote quote char code
+	 * @returns {void}
+	 */
+	_readStringCold(quote) {
+		const input = this.input;
+		let out = "";
+		let chunkStart = ++this.pos;
+		for (;;) {
+			if (this.pos >= input.length) {
+				this.raise(this.start, "Unterminated string constant");
+			}
+			const ch = input.charCodeAt(this.pos);
+			if (ch === quote) break;
+			if (ch === 92) {
+				out += input.slice(chunkStart, this.pos);
+				out += this._readEscapedChar(false);
+				chunkStart = this.pos;
+			} else if (ch === 0x2028 || ch === 0x2029) {
+				if (this._ecmaVersion < 10) {
+					this.raise(this.start, "Unterminated string constant");
+				}
+				++this.pos;
+			} else {
+				if (isNewLine(ch)) {
+					this.raise(this.start, "Unterminated string constant");
+				}
+				++this.pos;
+			}
+		}
+		out += input.slice(chunkStart, this.pos++);
+		return this.finishToken(tokTypes.string, out);
+	}
+
+	/**
+	 * acorn `readTmplToken`: the escape/CR-normalizing template reader. Invalid
+	 * escapes throw acorn's sentinel via `invalidStringToken`, which acorn's own
+	 * `tryReadTemplateToken` (not overridden here) catches to re-read raw.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @returns {void}
+	 */
+	_readTmplTokenCold() {
+		const input = this.input;
+		let out = "";
+		let chunkStart = this.pos;
+		for (;;) {
+			if (this.pos >= input.length) {
+				this.raise(this.start, "Unterminated template");
+			}
+			const ch = input.charCodeAt(this.pos);
+			if (ch === 96 || (ch === 36 && input.charCodeAt(this.pos + 1) === 123)) {
+				if (
+					this.pos === this.start &&
+					(this.type === tokTypes.template ||
+						this.type === tokTypes.invalidTemplate)
+				) {
+					if (ch === 36) {
+						this.pos += 2;
+						return this.finishToken(tokTypes.dollarBraceL);
+					}
+					++this.pos;
+					return this.finishToken(tokTypes.backQuote);
+				}
+				out += input.slice(chunkStart, this.pos);
+				return this.finishToken(tokTypes.template, out);
+			}
+			if (ch === 92) {
+				out += input.slice(chunkStart, this.pos);
+				out += this._readEscapedChar(true);
+				chunkStart = this.pos;
+			} else if (isNewLine(ch)) {
+				out += input.slice(chunkStart, this.pos);
+				++this.pos;
+				if (ch === 13 && input.charCodeAt(this.pos) === 10) ++this.pos;
+				out += "\n";
+				chunkStart = this.pos;
+			} else {
+				++this.pos;
+			}
+		}
+	}
+
+	/**
+	 * acorn `readEscapedChar`: cooks one backslash escape in a string/template.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {boolean} inTemplate whether the escape is in a template literal
+	 * @returns {string} the cooked replacement (may be `""`)
+	 */
+	_readEscapedChar(inTemplate) {
+		const input = this.input;
+		let ch = input.charCodeAt(++this.pos);
+		++this.pos;
+		switch (ch) {
+			case 110:
+				return "\n";
+			case 114:
+				return "\r";
+			case 120:
+				return String.fromCharCode(this._readHexChar(2));
+			case 117:
+				return codePointToString(this._readCodePoint());
+			case 116:
+				return "\t";
+			case 98:
+				return "\b";
+			case 118:
+				return "\u000B";
+			case 102:
+				return "\f";
+			case 13:
+				if (input.charCodeAt(this.pos) === 10) ++this.pos;
+			// falls through
+			case 10:
+				return "";
+			case 56:
+			case 57:
+				if (this.strict) {
+					this.invalidStringToken(this.pos - 1, "Invalid escape sequence");
+				}
+				if (inTemplate) {
+					this.invalidStringToken(
+						this.pos - 1,
+						"Invalid escape sequence in template string"
+					);
+				}
+			// falls through
+			default:
+				if (ch >= 48 && ch <= 55) {
+					let octalStr = /** @type {RegExpMatchArray} */ (
+						input.slice(this.pos - 1, this.pos + 2).match(/^[0-7]+/)
+					)[0];
+					let octal = Number.parseInt(octalStr, 8);
+					if (octal > 255) {
+						octalStr = octalStr.slice(0, -1);
+						octal = Number.parseInt(octalStr, 8);
+					}
+					this.pos += octalStr.length - 1;
+					ch = input.charCodeAt(this.pos);
+					if (
+						(octalStr !== "0" || ch === 56 || ch === 57) &&
+						(this.strict || inTemplate)
+					) {
+						this.invalidStringToken(
+							this.pos - 1 - octalStr.length,
+							inTemplate
+								? "Octal literal in template string"
+								: "Octal literal in strict mode"
+						);
+					}
+					return String.fromCharCode(octal);
+				}
+				if (isNewLine(ch)) return "";
+				return String.fromCharCode(ch);
+		}
+	}
+
+	/**
+	 * acorn `readWord1`: the escape-/astral-aware identifier reader (the fast
+	 * path handles pure-ASCII words).
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @returns {string} the (possibly escape-cooked) word
+	 */
+	_readWord1Cold() {
+		const input = this.input;
+		this.containsEsc = false;
+		let word = "";
+		let first = true;
+		let chunkStart = this.pos;
+		const astral = this._ecmaVersion >= 6;
+		while (this.pos < input.length) {
+			const ch = this.fullCharCodeAtPos();
+			if (isIdentifierChar(ch, astral)) {
+				this.pos += ch <= 0xffff ? 1 : 2;
+			} else if (ch === 92) {
+				this.containsEsc = true;
+				word += input.slice(chunkStart, this.pos);
+				const escStart = this.pos;
+				if (input.charCodeAt(++this.pos) !== 117) {
+					this.invalidStringToken(
+						this.pos,
+						"Expecting Unicode escape sequence \\uXXXX"
+					);
+				}
+				++this.pos;
+				const esc = this._readCodePoint();
+				if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) {
+					this.invalidStringToken(escStart, "Invalid Unicode escape");
+				}
+				word += codePointToString(esc);
+				chunkStart = this.pos;
+			} else {
+				break;
+			}
+			first = false;
+		}
+		return word + input.slice(chunkStart, this.pos);
+	}
+
+	/**
+	 * acorn `skipSpace` (location-free): unicode whitespace and comments. Only
+	 * reached from the lazy fast paths, which keep no line bookkeeping.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @returns {void}
+	 */
+	_skipSpaceCold() {
+		const input = this.input;
+		const len = input.length;
+		loop: while (this.pos < len) {
+			const ch = input.charCodeAt(this.pos);
+			switch (ch) {
+				case 32:
+				case 160:
+					++this.pos;
+					break;
+				case 13:
+					if (input.charCodeAt(this.pos + 1) === 10) ++this.pos;
+				// falls through
+				case 10:
+				case 8232:
+				case 8233:
+					++this.pos;
+					break;
+				case 47:
+					switch (input.charCodeAt(this.pos + 1)) {
+						case 42:
+							this.skipBlockComment();
+							break;
+						case 47:
+							this.skipLineComment(2);
+							break;
+						default:
+							break loop;
+					}
+					break;
+				default:
+					if (
+						(ch > 8 && ch < 14) ||
+						(ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch)))
+					) {
+						++this.pos;
+					} else {
+						break loop;
+					}
+			}
+		}
+	}
+
+	/**
+	 * acorn `readToken_numberSign` plus `getTokenFromCode`'s default: a private
+	 * identifier (`#x`) or an unexpected-character error.
+	 * https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
+	 * @this {ParserInternals}
+	 * @param {number} code current char code
+	 * @returns {void}
+	 */
+	_getUnknownOrPrivate(code) {
+		if (code === 35 && this._ecmaVersion >= 13) {
+			++this.pos;
+			const next = this.fullCharCodeAtPos();
+			if (isIdentifierStart(next, true) || next === 92) {
+				return this.finishToken(tokTypes.privateId, this.readWord1());
+			}
+			this.raise(this.pos, `Unexpected character '${codePointToString(next)}'`);
+		}
+		this.raise(this.pos, `Unexpected character '${codePointToString(code)}'`);
+	}
+
 	// ----- 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.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @returns {void}
 	 */
@@ -2176,6 +2787,7 @@ class WebpackParser extends BaseParser {
 	 * 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}
 	 */
@@ -2243,6 +2855,7 @@ class WebpackParser extends BaseParser {
 	 * inter-token gap and runs a regexp on it for every ASI decision (hundreds
 	 * of thousands per file). Scan the gap for a line terminator instead — no
 	 * slice, no regexp.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/parseutil.js
 	 * @returns {boolean} whether a semicolon may be inserted here
 	 * @this {ParserInternals}
 	 */
@@ -2261,6 +2874,7 @@ class WebpackParser extends BaseParser {
 	 * Replaces acorn's `skipLineComment` when comments are collected lazily:
 	 * the same scan, but no text slice and no position objects. Acorn calls
 	 * this for `//`, hashbangs and HTML-style comments (varying `startSkip`).
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @param {number} startSkip length of the comment opener
 	 * @returns {void}
@@ -2287,6 +2901,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Replaces acorn's `skipBlockComment` when comments are collected lazily.
 	 * Locations are always off in lazy mode, so line breaks need no handling.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals}
 	 * @returns {void}
 	 */
@@ -2307,6 +2922,7 @@ class WebpackParser extends BaseParser {
 	// ----- lazy range -----
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/node.js
 	 * @returns {Node} new node
 	 * @this {ParserInternals}
 	 */
@@ -2316,6 +2932,7 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/node.js
 	 * @param {number} pos start offset
 	 * @param {Position=} loc start position when acorn tracks locations
 	 * @returns {Node} new node
@@ -2330,6 +2947,7 @@ class WebpackParser extends BaseParser {
 	 * Lazy-mode `finishNode`: acorn's `locations`/`ranges` writes are dead when
 	 * `range` is served lazily and `loc` not at all, so skip them and the `finishNodeAt`
 	 * indirection. Runs once per node.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/node.js
 	 * @param {Node} node node to finish
 	 * @param {string} type node type
 	 * @returns {Node} the finished node
@@ -2345,6 +2963,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Mirror of acorn's `copyNode`, which bypasses `startNodeAt` via
 	 * `new Node(...)` and would otherwise produce non-lazy nodes.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/node.js
 	 * @param {Node} node node to copy
 	 * @returns {Node} copied node
 	 * @this {ParserInternals}
@@ -2369,6 +2988,7 @@ class WebpackParser extends BaseParser {
 	 * `IdentifierNode` directly, skipping acorn's `parseIdentNode`/`startNode`/
 	 * `finishNode` chain and its keyword branches. Keyword-as-identifier
 	 * (`obj.class`) and non-lazy mode delegate to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean=} liberal whether reserved words are allowed
 	 * @returns {Identifier} identifier node
 	 * @this {ParserInternals}
@@ -2403,6 +3023,7 @@ class WebpackParser extends BaseParser {
 	 * reachable during it), landing on `MemberExpressionNode`/
 	 * `CallExpressionNode`'s single shapes. Pre-optional-chaining ecmaVersions
 	 * and non-lazy mode delegate to acorn.
+	 * 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
@@ -2554,6 +3175,7 @@ class WebpackParser extends BaseParser {
 	 * blocks and plain expression statements) without it; everything rarer, the
 	 * `name`-token ambiguities (`let`/`async`/`using`/`await` heads) and
 	 * plugin-overridden parsers delegate to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {string | null} context statement context
 	 * @param {boolean=} topLevel whether parsing top-level statements
 	 * @param {unknown=} exports export tracking object
@@ -2641,6 +3263,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseVarStatement`: the passed started node is filled by
 	 * `parseVar` as acorn expects, then the finished statement lands on
 	 * `VariableDeclarationNode`'s single shape. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node started statement node from `parseStatement`
 	 * @param {string} kind declaration kind
 	 * @param {boolean=} allowMissingInitializer whether `const x;` is allowed
@@ -2662,6 +3285,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Statement-position `var`/`let`/`const` without a started node: the
 	 * declaration lands directly on `VariableDeclarationNode`'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} kind declaration kind
 	 * @param {boolean=} allowMissingInitializer whether `const x;` is allowed
@@ -2686,6 +3310,7 @@ class WebpackParser extends BaseParser {
 	 * declarator fully-formed on `VariableDeclaratorNode`'s single shape. The
 	 * passed node keeps receiving `declarations`/`kind` because
 	 * `parseForStatement` finishes it itself. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node declaration node to fill
 	 * @param {boolean} isFor whether parsing a `for` head
 	 * @param {string} kind declaration kind
@@ -2716,6 +3341,7 @@ 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 {boolean} isFor whether parsing a `for` head
 	 * @param {string} kind declaration kind
@@ -2783,6 +3409,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseExpressionStatement`: the statement lands on
 	 * `ExpressionStatementNode`'s single shape (the passed started node is
 	 * discarded, matching acorn's observable output). Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node started statement node from `parseStatement`
 	 * @param {Expression} expr the parsed expression
 	 * @returns {Node} expression statement
@@ -2797,6 +3424,7 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * `parseExpressionStatement` 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 {Expression} expr the parsed expression
 	 * @returns {Node} expression statement
@@ -2814,6 +3442,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseBlock`, an exact-semantics copy of acorn 8's landing on
 	 * `BlockStatementNode`'s single shape. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {boolean=} createNewLexicalScope whether the block opens a scope
 	 * @param {Node=} node started statement node, when called from `parseStatement`
 	 * @param {boolean=} exitStrict whether to restore sloppy mode at the end
@@ -2851,6 +3480,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseIfStatement` landing on `IfStatementNode`'s single shape.
 	 * Non-lazy mode delegates to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node started statement node from `parseStatement`
 	 * @returns {Node} if statement
 	 * @this {ParserInternals}
@@ -2862,6 +3492,7 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * `parseIfStatement` 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} if statement
 	 * @this {ParserInternals}
@@ -2884,6 +3515,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseReturnStatement` landing on `ReturnStatementNode`'s single
 	 * shape. Non-lazy mode delegates to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node started statement node from `parseStatement`
 	 * @returns {Node} return statement
 	 * @this {ParserInternals}
@@ -2923,6 +3555,7 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * `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}
@@ -2949,6 +3582,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * 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}
@@ -2970,6 +3604,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * 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
@@ -3013,6 +3648,7 @@ class WebpackParser extends BaseParser {
 	 * lands on `NewExpressionNode`'s single shape (zero-argument calls share
 	 * one empty array like acorn's `empty`); the rare `new.target` path keeps
 	 * the generic node. Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @returns {Expression} new expression or meta property
 	 * @this {ParserInternals}
 	 */
@@ -3084,6 +3720,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseTemplateElement` landing on `TemplateElementNode`'s single
 	 * shape; matches acorn's CRLF normalization and invalid-escape handling.
 	 * Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {{ isTagged: boolean }} opts whether the template is tagged
 	 * @returns {Node} template element
 	 * @this {ParserInternals}
@@ -3134,6 +3771,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseTemplate` landing on `TemplateLiteralNode`'s single shape.
 	 * Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {{ isTagged?: boolean }=} opts whether the template is tagged
 	 * @returns {Node} template literal
 	 * @this {ParserInternals}
@@ -3180,6 +3818,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseMaybeUnary`, an exact-semantics copy of acorn 8's: prefix
 	 * unary/update and postfix update nodes are built fully-formed on
 	 * `UnaryNode`'s shared single shape. Non-lazy mode delegates to acorn.
+	 * 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} sawUnary whether a unary operator was already consumed
 	 * @param {boolean} incDec whether the caller was an update operator
@@ -3297,6 +3936,7 @@ class WebpackParser extends BaseParser {
 	 * operator is captured before `next()` and the `AssignmentExpression` is
 	 * built fully-formed on `AssignmentNode`'s single shape after the
 	 * right-hand parse. Yield and non-lazy mode delegate to acorn.
+	 * 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
 	 * @param {((this: unknown, left: Expression, startPos: number, startLoc?: Position) => Expression)=} afterLeftParse hook applied to the parsed left side
@@ -3393,6 +4033,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseExprOps`, an exact copy of acorn 8's, so the hot expression
 	 * spine (`parseMaybeAssign` → here → `parseMaybeUnary`) stays monomorphic
 	 * on owned code. 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
@@ -3421,6 +4062,7 @@ class WebpackParser extends BaseParser {
 	 * same-precedence continuation turned from tail recursion into a loop —
 	 * `a + b + c + d` runs one frame instead of one per operator. Non-lazy mode
 	 * delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {Expression} left left operand
 	 * @param {number} leftStartPos expression start offset
 	 * @param {Position | undefined} leftStartLoc expression start position
@@ -3497,6 +4139,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `buildBinary` (acorn calls it only from `parseExprOp`): binary and
 	 * logical nodes are built fully-formed on `BinaryNode`'s single shape.
 	 * Non-lazy mode delegates to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {number} startPos expression start offset
 	 * @param {Position | undefined} startLoc expression start position
 	 * @param {Expression} left left operand
@@ -3544,6 +4187,7 @@ class WebpackParser extends BaseParser {
 	 * async-function/async-arrow detection), number/string literals, keyword
 	 * literals (`true`/`false`/`null` — on the same `LiteralNode` shape as the
 	 * rest) and `this`. Everything else, and non-lazy mode, delegates to acorn.
+	 * 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
 	 * @param {boolean=} forNew whether parsed as a `new` callee
@@ -3670,6 +4314,7 @@ class WebpackParser extends BaseParser {
 	 * Owned `parseObj`, an exact-semantics copy of acorn 8's landing on
 	 * `ObjectNode`'s single shape (the ES5 trailing-comma gate is dropped —
 	 * the fast path requires ES11+). Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean} isPattern whether parsing a binding pattern
 	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
 	 * @returns {Node} object expression or pattern
@@ -3736,6 +4381,7 @@ class WebpackParser extends BaseParser {
 	 * `PropertyNode`, which acorn's shared `parsePropertyName`/
 	 * `parsePropertyValue` then fill in place (ES9+ semantics assumed via the
 	 * ES11 fast-path gate). Non-lazy mode delegates.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean} isPattern whether parsing a binding pattern
 	 * @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
 	 * @returns {Node} property, spread element or rest element
@@ -3829,6 +4475,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseLiteral`: builds the finished `LiteralNode` directly; the
 	 * `bigint` branch matches acorn's. Non-lazy mode delegates to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {unknown} value literal value
 	 * @returns {Node} literal node
 	 * @this {ParserInternals}
@@ -3854,6 +4501,7 @@ class WebpackParser extends BaseParser {
 	 * then builds the value with a second `new RegExp`. This override scans
 	 * like acorn, keeps acorn's flag validation (for its exact messages) and
 	 * lets one `new RegExp` be both the V8-backed validation and the value.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/tokenize.js
 	 * @this {ParserInternals & { regexpState: unknown }}
 	 * @returns {void}
 	 */
@@ -3926,6 +4574,7 @@ class WebpackParser extends BaseParser {
 	 * that validation costs several percent of parse time. Raise from V8's
 	 * verdict instead — invalid patterns still fail the module build, only
 	 * exotic engine-specific message texts may differ.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/regexp.js
 	 * @param {{ start: number, source: string, flags: string }} state acorn regexp validation state
 	 * @this {ParserInternals}
 	 */
@@ -3941,6 +4590,7 @@ class WebpackParser extends BaseParser {
 	// ----- scope tracking (Set-based, replaces acorn's array + indexOf) -----
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/scope.js
 	 * @param {number} flags scope flags
 	 * @this {ParserInternals}
 	 */
@@ -3950,6 +4600,7 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * Set-backed replacement for acorn's `declareName` on Set-backed scopes.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/scope.js
 	 * @param {string} name declared name
 	 * @param {number} bindingType acorn BIND_* binding type
 	 * @param {number} pos source offset for redeclaration errors
@@ -4020,6 +4671,7 @@ class WebpackParser extends BaseParser {
 
 	/**
 	 * Set-backed replacement for acorn's `checkLocalExport` on Set-backed scopes.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/scope.js
 	 * @param {Identifier} id exported identifier
 	 * @this {ParserInternals}
 	 */
@@ -4095,6 +4747,7 @@ class WebpackParser extends BaseParser {
 	// ----- import phases (`import defer/source`, `import.defer/source()`) -----
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node & { phase?: ImportPhase }} node import declaration node
 	 * @returns {Node} finished node
 	 * @this {ParserInternals}
@@ -4110,6 +4763,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseExport` only to flag module syntax for the auto-fallback guard;
 	 * parsing itself delegates to acorn.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @param {Node} node started export node
 	 * @param {unknown} exports export-name tracking object
 	 * @returns {Node} export declaration
@@ -4123,6 +4777,7 @@ class WebpackParser extends BaseParser {
 	/**
 	 * Owned `parseAwait` only to flag top-level await (module-only) for the
 	 * auto-fallback guard; await inside a function is not module syntax.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean | string=} forInit for-loop init context flag
 	 * @returns {Expression} await expression
 	 * @this {ParserInternals}
@@ -4135,6 +4790,7 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/statement.js
 	 * @returns {AnyImportSpecifier[]} import specifiers
 	 * @this {ParserInternals}
 	 */
@@ -4211,6 +4867,7 @@ class WebpackParser extends BaseParser {
 	}
 
 	/**
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.17.0/acorn/src/expression.js
 	 * @param {boolean} forNew whether parsed as the operand of `new`
 	 * @returns {Expression} expression node
 	 * @this {ParserInternals}