@@ -16315,6 +16315,99 @@ const installEstree = (modules) => {
1631516315 AST_Lambda.prototype.to_mozilla_ast = AST_Function.prototype.to_mozilla_ast;
1631616316};
1631716317
16318+ /**
16319+ * A token of webpack's parse: where it sits in the source, and the parse that
16320+ * read it. terser's `AST_Token` keeps what this reads off that parse — its
16321+ * line, its kind, the comments beside it — in nine fields of its own, which a
16322+ * tree of a million nodes cannot afford.
16323+ */
16324+ class SourceToken {
16325+ /**
16326+ * @param {EXPECTED_ANY} tokens the parse that read it
16327+ * @param {number} index which of its tokens this is
16328+ */
16329+ constructor(tokens, index) {
16330+ this.tokens = tokens;
16331+ this.index = index;
16332+ Object.seal(this);
16333+ }
16334+
16335+ /** @returns {number} where it starts */
16336+ get pos() {
16337+ return this.tokens.positionOf(this.index);
16338+ }
16339+
16340+ /** @returns {string} terser's name for its kind */
16341+ get type() {
16342+ return this.tokens.kindOf(this.index);
16343+ }
16344+
16345+ /** @returns {EXPECTED_ANY} what it holds */
16346+ get value() {
16347+ return this.tokens.valueOf(this.index);
16348+ }
16349+
16350+ /** @returns {number} its line, from 1 */
16351+ get line() {
16352+ return this.tokens.lineOf(this.index);
16353+ }
16354+
16355+ /** @returns {number} its column, from 0 */
16356+ get col() {
16357+ return this.tokens.columnOf(this.index);
16358+ }
16359+
16360+ /** @returns {string | undefined} its file */
16361+ get file() {
16362+ return this.tokens.fileName;
16363+ }
16364+
16365+ /** @returns {boolean} whether a line break comes before it */
16366+ get nlb() {
16367+ return this.tokens.brokeLineAt(this.index);
16368+ }
16369+
16370+ /**
16371+ * @param {boolean} broke whether a line break comes before it
16372+ */
16373+ set nlb(broke) {
16374+ this.tokens.setBrokeLineAt(this.index, broke);
16375+ }
16376+
16377+ /** @returns {EXPECTED_ANY[]} the comments read before it */
16378+ get comments_before() {
16379+ return this.tokens.commentsOf(this.index, false);
16380+ }
16381+
16382+ /**
16383+ * @param {EXPECTED_ANY[]} comments the comments read before it
16384+ */
16385+ set comments_before(comments) {
16386+ this.tokens.bindComments(this.index, false, comments);
16387+ }
16388+
16389+ /** @returns {EXPECTED_ANY[]} the comments read after it */
16390+ get comments_after() {
16391+ return this.tokens.commentsOf(this.index, true);
16392+ }
16393+
16394+ /**
16395+ * @param {EXPECTED_ANY[]} comments the comments read after it
16396+ */
16397+ set comments_after(comments) {
16398+ this.tokens.bindComments(this.index, true, comments);
16399+ }
16400+
16401+ /**
16402+ * @param {number} _depth how deep Node's inspector is
16403+ * @param {EXPECTED_ANY} options its options
16404+ * @returns {string} the token, as Node's console shows it
16405+ */
16406+ [Symbol.for("nodejs.util.inspect.custom")](_depth, options) {
16407+ return `AST_Token { type: ${options.stylize(JSON.stringify(this.type), "string")}, value: ${options.stylize(JSON.stringify(this.value), "string")}, line: ${options.stylize(String(this.line), "number")}, col: ${options.stylize(String(this.col), "number")} }`;
16408+ }
16409+ }
16410+
1631816411/**
1631916412 * Installs webpack's parse: the printer's tree built by webpack's own parser as
1632016413 * it finishes each statement, with that parser's tokens and comments. terser's
@@ -16392,6 +16485,27 @@ const installFusedParse = (modules) => {
1639216485 if (type === tokTypes.eof) return "eof";
1639316486 return PUNCTUATION_LABELS.has(type.label) ? "punc" : "operator";
1639416487 };
16488+ // Every kind a token can have, which one holds as an index into this.
16489+ const KINDS = [
16490+ "",
16491+ "name",
16492+ "privatename",
16493+ "num",
16494+ "string",
16495+ "regexp",
16496+ "arrow",
16497+ "expand",
16498+ "eof",
16499+ "punc",
16500+ "operator",
16501+ "atom",
16502+ "keyword"
16503+ ];
16504+ /** @type {Map<string, number>} */
16505+ const KIND_CODES = new Map(KINDS.map((kind, code) => [kind, code]));
16506+ // What `ends` holds for the token past the source, which no node ends at.
16507+ const NO_END = 0x7fffffff;
16508+
1639516509 // A line opening an HTML comment, which only terser reads as one.
1639616510 const HTML_COMMENT_LINE = /^[\t ]*(?:<!--|-->)/m;
1639716511
@@ -16412,23 +16526,28 @@ const installFusedParse = (modules) => {
1641216526 * deepest, where the frames building it are the ones it has run out of.
1641316527 * @param {string} source the source being parsed
1641416528 * @param {string | null} filename what its tokens name as their file
16415- * @returns {{ onComment: EXPECTED_FUNCTION, onToken: EXPECTED_FUNCTION, shebang: (text: string) => void, at: (pos: number, ending: boolean) => EXPECTED_ANY }} where to report comments and tokens, and the token at an offset
16529+ * @returns {{ onComment: EXPECTED_FUNCTION, onToken: EXPECTED_FUNCTION, shebang: (text: string) => void, finish: () => void, at: (pos: number, ending: boolean) => EXPECTED_ANY }} where to report comments and tokens, the token at an offset, and what narrows the tables once the parse is over
1641616530 */
1641716531 const collectTokens = (source, filename) => {
16418- /** @type {number[]} */
16419- const starts = [];
16420- /** @type {number[]} */
16421- const ends = [];
16422- /** @type {string[]} */
16423- const kinds = [];
16424- /** @type {EXPECTED_ANY[]} */
16425- const values = [];
16426- /** @type {boolean[]} */
16427- const breaks = [];
16532+ // Where each token sits, its kind as an index into `KINDS`, and whether a
16533+ // line break came before it. Grown while the parse runs, then narrowed by
16534+ // `finish` into arrays a token reads for as long as the tree lives.
16535+ /** @type {EXPECTED_ANY} */
16536+ let starts = [];
16537+ /** @type {EXPECTED_ANY} */
16538+ let ends = [];
16539+ /** @type {EXPECTED_ANY} */
16540+ let kinds = [];
16541+ /** @type {EXPECTED_ANY} */
16542+ let breaks = [];
16543+ // The value of a token the source does not spell out: a string holds what
16544+ // its escapes mean, and a private name is read without its `#`.
16545+ /** @type {Map<number, EXPECTED_ANY> | null} */
16546+ let cooked = new Map();
1642816547 /** @type {EXPECTED_ANY[]} */
16429- const built = [];
16430- /** @type {( EXPECTED_ANY[] | undefined)[] } */
16431- const lists = [];
16548+ let built = [];
16549+ /** @type {EXPECTED_ANY} */
16550+ let lists = [];
1643216551 /** @type {number[] | null} */
1643316552 let lineStarts = null;
1643416553 let previousEnd = 0;
@@ -16444,6 +16563,10 @@ const installFusedParse = (modules) => {
1644416563 * @returns {EXPECTED_ANY[]} them, as terser's tokens
1644516564 */
1644616565 const listAt = (index) => {
16566+ if (lists instanceof Map) {
16567+ const kept = lists.get(index);
16568+ return kept === undefined ? NO_COMMENTS : kept;
16569+ }
1644716570 const known = lists[index];
1644816571 if (known !== undefined) return known;
1644916572 // A gap the parser has not read past gains its comments after this, so it
@@ -16496,25 +16619,71 @@ const installFusedParse = (modules) => {
1649616619 const build = (index) => {
1649716620 const known = built[index];
1649816621 if (known !== undefined) return known;
16499- if (lineStarts === null) lineStarts = buildLineStarts(source);
16500- const { line, column } = /** @type {{ line: number, column: number }} */ (
16501- positionAt(lineStarts, starts[index])
16502- );
16503- const token = new AST_Token(
16504- kinds[index],
16505- values[index],
16506- line,
16507- column,
16508- starts[index],
16509- breaks[index],
16510- listAt(index),
16511- listAt(index + 1),
16512- filename === null ? undefined : filename
16513- );
16622+ const token = new SourceToken(reader, index);
1651416623 built[index] = token;
1651516624 return token;
1651616625 };
1651716626
16627+ /**
16628+ * @param {number} index which token
16629+ * @returns {{ line: number, column: number }} where it sits
16630+ */
16631+ const placeOf = (index) => {
16632+ if (lineStarts === null) lineStarts = buildLineStarts(source);
16633+ return /** @type {{ line: number, column: number }} */ (
16634+ positionAt(/** @type {number[]} */ (lineStarts), starts[index])
16635+ );
16636+ };
16637+
16638+ // A list bound onto one token by a parenthesis, which the gap it was read
16639+ // in keeps out of: one token to an index, so the index names it.
16640+ /** @type {Map<number, EXPECTED_ANY[]> | null} */
16641+ let boundBefore = null;
16642+ /** @type {Map<number, EXPECTED_ANY[]> | null} */
16643+ let boundAfter = null;
16644+
16645+ // What a `SourceToken` of this parse reads off it. The arrays it reads are
16646+ // the ones `finish` narrows; the rest go when the parse is over.
16647+ const reader = {
16648+ fileName: filename === null ? undefined : filename,
16649+ positionOf: (/** @type {number} */ index) => starts[index],
16650+ kindOf: (/** @type {number} */ index) => KINDS[kinds[index]],
16651+ valueOf: (/** @type {number} */ index) =>
16652+ cooked !== null && cooked.has(index)
16653+ ? cooked.get(index)
16654+ : source.slice(starts[index], ends[index]),
16655+ lineOf: (/** @type {number} */ index) => placeOf(index).line,
16656+ columnOf: (/** @type {number} */ index) => placeOf(index).column,
16657+ brokeLineAt: (/** @type {number} */ index) => breaks[index] === 1,
16658+ setBrokeLineAt: (
16659+ /** @type {number} */ index,
16660+ /** @type {boolean} */ broke
16661+ ) => {
16662+ breaks[index] = broke ? 1 : 0;
16663+ },
16664+ commentsOf: (
16665+ /** @type {number} */ index,
16666+ /** @type {boolean} */ after
16667+ ) => {
16668+ const bound = after ? boundAfter : boundBefore;
16669+ const own = bound === null ? undefined : bound.get(index);
16670+ return own === undefined ? listAt(after ? index + 1 : index) : own;
16671+ },
16672+ bindComments: (
16673+ /** @type {number} */ index,
16674+ /** @type {boolean} */ after,
16675+ /** @type {EXPECTED_ANY[]} */ comments
16676+ ) => {
16677+ if (after) {
16678+ if (boundAfter === null) boundAfter = new Map();
16679+ boundAfter.set(index, comments);
16680+ } else {
16681+ if (boundBefore === null) boundBefore = new Map();
16682+ boundBefore.set(index, comments);
16683+ }
16684+ }
16685+ };
16686+
1651816687 return {
1651916688 onComment: (
1652016689 /** @type {boolean} */ isBlock,
@@ -16557,18 +16726,53 @@ const installFusedParse = (modules) => {
1655716726 : named;
1655816727 afterDot =
1655916728 token.type === tokTypes.dot || token.type === tokTypes.questionDot;
16729+ if (kind === "string" || kind === "privatename") {
16730+ /** @type {Map<number, EXPECTED_ANY>} */ (cooked).set(
16731+ starts.length,
16732+ value
16733+ );
16734+ }
1656016735 starts.push(from);
1656116736 // A node ends at the last token it holds, which is never the one past
1656216737 // the source: terser leaves the comments after it on the token before.
16563- ends.push(kind === "eof" ? Number.POSITIVE_INFINITY : token.end);
16564- kinds.push(kind);
16565- values.push(value);
16566- breaks.push(nlb);
16738+ ends.push(kind === "eof" ? NO_END : token.end);
16739+ kinds.push(KIND_CODES.get(kind));
16740+ breaks.push(nlb ? 1 : 0);
1656716741 previousEnd = token.end;
1656816742 },
1656916743 shebang: (/** @type {string} */ text) => {
1657016744 read(0, "comment5", text, 0, false);
1657116745 },
16746+ finish: () => {
16747+ // The parse is over: what it grew becomes what a token reads, in a
16748+ // quarter of the room, and what only the parse needed goes.
16749+ const count = starts.length;
16750+ const narrowStarts = new Int32Array(count);
16751+ const narrowEnds = new Int32Array(count);
16752+ const narrowKinds = new Uint8Array(count);
16753+ const narrowBreaks = new Uint8Array(count);
16754+ for (let i = 0; i < count; i++) {
16755+ narrowStarts[i] = starts[i];
16756+ narrowEnds[i] = ends[i];
16757+ narrowKinds[i] = kinds[i];
16758+ narrowBreaks[i] = breaks[i];
16759+ }
16760+ /** @type {Map<number, EXPECTED_ANY[]>} */
16761+ const kept = new Map();
16762+ for (let i = 0; i < lists.length; i++) {
16763+ const list = lists[i];
16764+ if (list !== undefined && list.length !== 0) kept.set(i, list);
16765+ }
16766+ starts = narrowStarts;
16767+ ends = narrowEnds;
16768+ kinds = narrowKinds;
16769+ breaks = narrowBreaks;
16770+ lists = kept;
16771+ built = [];
16772+ if (/** @type {Map<number, EXPECTED_ANY>} */ (cooked).size === 0) {
16773+ cooked = null;
16774+ }
16775+ },
1657216776 at: (/** @type {number} */ pos, /** @type {boolean} */ ending) => {
1657316777 const offsets = ending ? ends : starts;
1657416778 let low = 0;
@@ -16716,6 +16920,7 @@ const installFusedParse = (modules) => {
1671616920 tokens.at
1671716921 );
1671816922 toplevel = AST_Node.from_mozilla_ast(parser.parse(), tokens.at, text);
16923+ tokens.finish();
1671916924 } catch (_error) {
1672016925 // A source only terser's parser reads, which it then reports on.
1672116926 return terserParse(text, givenOptions);
0 commit comments