depvitals 0.1.1 → 0.2.0

package/dist/scanner/moduleSpecifiers.js

@@ -42,14 +42,14 @@ export class ModuleSpecifierError extends Error {
  * @throws {ModuleSpecifierError} when the source reaches an unterminated or malformed lexical state
  *   from which the scanner cannot safely continue.
  */
-export function extractModuleSpecifiers(source) {
-    return interpret(tokenize(source));
+export function extractModuleSpecifiers(source, options = {}) {
+    return interpret(tokenize(source, options.jsx ?? false, options.module ?? false));
 }
 /**
  * Turn source into a stream of significant tokens, skipping whitespace, line/block comments, regex
  * literals and template literals.
  */
-function tokenize(source) {
+function tokenize(source, jsx = false, module = false) {
     const tokens = [];
     const n = source.length;
     let i = 0;
@@ -70,22 +70,57 @@ function tokenize(source) {
     // The value of the previous identifier token, when the previous token was an identifier. Which
     // identifier it was matters for one decision: `return {` opens an object literal, `else {` not.
     let prevIdentifier;
+    // Preserve the position before an `async` modifier for a following `function` keyword.
+    let asyncFunctionIsExpression = false;
+    // A line terminator in trivia may end an expression-bodied arrow through ASI. It is consumed
+    // only when the next significant token cannot continue the preceding expression.
+    let lineTerminatorSinceLastToken = false;
+    let tokenLineBreakBefore = false;
+    let htmlCloseCommentAllowed = true;
+    const emit = (token) => {
+        const significant = tokenLineBreakBefore ? { ...token, lineBreakBefore: true } : token;
+        if (memberAtToken !== undefined) {
+            advanceMember(memberAtToken, significant, tokens[tokens.length - 1]);
+        }
+        tokens.push(significant);
+        if (token.kind !== 'punct' || token.syntheticBoundary !== true) {
+            htmlCloseCommentAllowed = false;
+        }
+        tokenLineBreakBefore = false;
+        lineTerminatorSinceLastToken = false;
+    };
     // Template literal state. `inText` is true while scanning template text that must not be lexed as
     // JavaScript; a backtick toggles it, so nested templates are handled by the toggle. Every open
-    // `${...}` expression pushes its own brace depth onto `braceDepths`, which is what distinguishes
-    // the `}` that closes the interpolation from a `}` belonging to an object literal, a block or a
-    // function body inside it. JavaScript inside `${...}` is lexed like ordinary source.
-    const braceDepths = [];
+    // `${...}` expression pushes a `template-expr` frame carrying its own brace depth, which is what
+    // distinguishes the `}` that closes the interpolation from a `}` belonging to an object literal, a
+    // block or a function body inside it. JavaScript inside `${...}` is lexed like ordinary source.
+    //
+    // The same stack carries the JSX overlay frames (`jsx-tag`, `jsx-text` and the `jsx-expr` of a
+    // `{...}` container), so markup, expression containers, templates and nested elements interleave
+    // in a single pass without any state leaking between them.
+    const frames = [];
     let inText = false;
     // Offset of the opening backtick of the current template, for unterminated-template errors.
     let templateStart = 0;
-    // Brace context. Each `{` pushes whether it opened an expression (an object literal or a
-    // destructuring pattern) or a statement block / function body, and its matching `}` pops that
-    // entry. A `}` only ends an expression when it closed an object literal, which is what separates
-    // `{}` in `{} / require('pkg') / 2`, where both slashes divide, from the `}` of
-    // `if (ok) { ... }`, after which a `/` may legitimately start a regex. Anything unrecognized is
-    // treated as a block.
+    const templateStarts = [];
     const braceContexts = [];
+    let memberAtToken;
+    // Function context of every open function body, tracked independently of expression frame resets
+    // so `${}` boundaries cannot change the nearest await/yield grammar.
+    const functionContextStack = [];
+    // The nearest function body owns the await/yield grammar. An ordinary nested function therefore
+    // suspends an async/generator context from an outer function instead of inheriting it.
+    // A default callback may open and finish while an outer signature is still reading parameters.
+    // Only a signature with closed parameters at its original depth can own the next body brace.
+    const pendingFunctionContexts = [];
+    const pendingClassContexts = [];
+    const conditionalContexts = [];
+    let colonIsExpression = false;
+    const expressionFunctionContexts = [];
+    let typeAnnotation;
+    const parameterContexts = [];
+    let closedParameterSignature;
+    let bracketDepth = 0;
     // Whether the most recent `}` closed an object literal. It is only consulted while that `}` is
     // the previous token, exactly like `prevPunct`.
     let closedObjectBrace = false;
@@ -95,10 +130,19 @@ function tokenize(source) {
     // The control keyword pending a `(` (if/while/for/with), so the matching `)` can be recognised.
     // Only whitespace and comments may appear between the keyword and the `(`.
     let pendingControlKeyword;
-    // How many `(` are currently open, and the depth at which the open control-statement head sits,
-    // so only the `)` that closes the head itself (not a nested one) enables the heuristic.
+    // Parameter/control parentheses carry the signature they opened, rather than recovering one
+    // from an arbitrary `)` when a colon or body brace appears later.
     let parenDepth = 0;
-    let controlParenDepth;
+    const atLexicalDepth = (context) => parenDepth === context.parenDepth &&
+        bracketDepth === context.bracketDepth &&
+        braceContexts.length === context.braceDepth &&
+        frames.length === context.frameDepth;
+    const insideObjectLiteral = () => braceContexts[braceContexts.length - 1]?.role === 'object';
+    const insideClassBody = () => braceContexts[braceContexts.length - 1]?.role === 'class';
+    const currentClass = () => {
+        const brace = braceContexts[braceContexts.length - 1];
+        return brace?.role === 'class' ? brace.state : undefined;
+    };
     // Reset the expression-start state at the beginning of a fresh `${...}` expression.
     const resetExpressionState = () => {
         prevKind = 'start';
@@ -108,13 +152,54 @@ function tokenize(source) {
         afterControlHead = false;
         pendingControlKeyword = undefined;
         closedObjectBrace = false;
+        lineTerminatorSinceLastToken = false;
+        // Pending signatures retain their own depth across template/JSX expressions in parameters.
+    };
+    // A finished JSX element leaves an expression value behind: a following `/` divides, and the
+    // markup itself never opens a statement context.
+    const endJsxElement = () => {
+        prevKind = 'template';
+        prevPunct = undefined;
+        prevIdentifier = undefined;
+        prevIsExpressionKeyword = false;
+        afterControlHead = false;
+        pendingControlKeyword = undefined;
+        closedObjectBrace = false;
+    };
+    // JSX markup and sibling expression containers are separate expressions. Emitting an explicit
+    // boundary keeps the token stream from gluing two of them into an import/require sequence that
+    // does not exist in source (for example `<p>{import}{('pkg')}</p>`).
+    const pushBoundary = (offset) => {
+        emit({
+            kind: 'punct',
+            value: ';',
+            offset,
+            endOffset: offset + 1,
+            syntheticBoundary: true,
+        });
     };
     while (i < n) {
+        memberAtToken = undefined;
         const ch = source[i];
+        let typedArrowContext;
+        let inType = typeAnnotation !== undefined;
+        let closedClassMemberBoundary = false;
+        let closedExpressionBrace = false;
+        let opensClassMemberBoundary = false;
+        let matchingOpen;
         if (ch === undefined) {
             i++;
             continue;
         }
+        let conditional = conditionalContexts[conditionalContexts.length - 1];
+        while (conditional !== undefined &&
+            (conditional.parenDepth > parenDepth ||
+                conditional.bracketDepth > bracketDepth ||
+                conditional.braceDepth > braceContexts.length ||
+                conditional.frameDepth > frames.length)) {
+            conditionalContexts.pop();
+            conditional = conditionalContexts[conditionalContexts.length - 1];
+        }
         // Template literal text: skip everything until `${`, a nested `` ` ``, or the closing `` ` ``.
         // A backtick toggles out of text mode; the matching toggle happens below in code mode.
         if (inText) {
@@ -125,6 +210,9 @@ function tokenize(source) {
             if (ch === '`') {
                 // Closing backtick of the current (or nested) template literal.
                 inText = false;
+                const start = templateStarts.pop() ?? templateStart;
+                emit({ kind: 'template', offset: start, endOffset: i + 1 });
+                templateStart = templateStarts[templateStarts.length - 1] ?? start;
                 prevKind = 'template';
                 i++;
                 continue;
@@ -132,7 +220,14 @@ function tokenize(source) {
             if (ch === '$' && source[i + 1] === '{') {
                 // Start of a `${...}` expression: lex the JavaScript inside like ordinary source. The frame
                 // starts at brace depth 0, so the next unmatched `}` closes the interpolation.
-                braceDepths.push(0);
+                frames.push({
+                    kind: 'template-expr',
+                    depth: 0,
+                    offset: i,
+                    ...(typeAnnotation !== undefined
+                        ? { typeOwner: { annotation: typeAnnotation, depth: { ...typeAnnotation } } }
+                        : {}),
+                });
                 inText = false;
                 resetExpressionState();
                 i += 2;
@@ -141,161 +236,2084 @@ function tokenize(source) {
             i++;
             continue;
         }
-        if (isWhitespace(ch)) {
-            i++;
-            continue;
+        // The innermost frame decides how the next character is read.
+        const frame = frames[frames.length - 1];
+        // JSX children: inert text up to the matching close tag. Quotes, backticks and comment-looking
+        // sequences are text here, so only `<` (markup) and `{` (an expression container) leave it.
+        if (frame?.kind === 'jsx-text') {
+            if (ch === '{') {
+                frames.push({ kind: 'jsx-expr', depth: 0, offset: i });
+                pushBoundary(i);
+                resetExpressionState();
+                i++;
+                continue;
+            }
+            if (ch === '<') {
+                const after = source[i + 1];
+                // Close tag `</name>` or fragment close `</>`: this element ends here.
+                if (after === '/') {
+                    let k = i + 2;
+                    while (k < n && source[k] !== '>') {
+                        k++;
+                    }
+                    if (k >= n) {
+                        throw new ModuleSpecifierError('Unterminated JSX element', 'invalid-source', frame.offset);
+                    }
+                    frames.pop();
+                    pushBoundary(i);
+                    endJsxElement();
+                    i = k + 1;
+                    continue;
+                }
+                // Nested fragment `<>`.
+                if (after === '>') {
+                    frames.push({ kind: 'jsx-text', name: null, offset: i });
+                    i += 2;
+                    continue;
+                }
+                // Nested element `<name ...`.
+                if (isIdentifierStartAt(source, i + 1)) {
+                    const tag = readJsxTagName(source, i + 1, n);
+                    frames.push({ kind: 'jsx-tag', name: tag.name, offset: i, nameEnd: tag.end });
+                    i = tag.end;
+                    continue;
+                }
+                // A `<` that is not markup (`a < b` written inside JSX text) is ordinary text.
+                i++;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        // JSX open tag: attribute names, `=` and namespaces are inert; quoted values are inert text and
+        // `{...}` returns to real JavaScript.
+        if (frame?.kind === 'jsx-tag') {
+            if (ch === '<' && skipTrivia(source, frame.nameEnd, n) === i) {
+                pushBoundary(i);
+                i = readJsxTypeArguments(source, i, n, tokens);
+                pushBoundary(i);
+                continue;
+            }
+            if (ch === '{') {
+                frames.push({ kind: 'jsx-expr', depth: 0, offset: i });
+                pushBoundary(i);
+                resetExpressionState();
+                i++;
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                i = skipJsxAttributeValue(source, i, n);
+                continue;
+            }
+            // Self-closing tag `<name ... />`: the element ends without children.
+            if (ch === '/' && source[i + 1] === '>') {
+                frames.pop();
+                pushBoundary(i);
+                endJsxElement();
+                i += 2;
+                continue;
+            }
+            // End of the open tag: its children follow until the matching close tag.
+            if (ch === '>') {
+                frames.pop();
+                frames.push({ kind: 'jsx-text', name: frame.name, offset: frame.offset });
+                i++;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (!module &&
+            (source.startsWith('<!--', i) || (source.startsWith('-->', i) && htmlCloseCommentAllowed))) {
+            while (i < n && !isLineTerminator(source[i])) {
+                i++;
+            }
+            continue;
+        }
+        if (isWhitespace(ch) || (ch === '/' && (source[i + 1] === '/' || source[i + 1] === '*'))) {
+            const trivia = readTrivia(source, i, n);
+            i = trivia.end;
+            lineTerminatorSinceLastToken ||= trivia.lineBreak;
+            htmlCloseCommentAllowed ||= trivia.lineBreak;
+            continue;
+        }
+        tokenLineBreakBefore = lineTerminatorSinceLastToken;
+        const previousSignature = closedParameterSignature;
+        closedParameterSignature = undefined;
+        memberAtToken = undefined;
+        const classState = currentClass();
+        const identifier = isIdentifierStartAt(source, i) || isUnicodeEscapeStart(source, i)
+            ? readIdentifier(source, i)
+            : undefined;
+        if (typeAnnotation?.role === 'assertion' &&
+            atLexicalDepth(typeAnnotation.owner) &&
+            atTypeRoot(typeAnnotation) &&
+            !(ch === '>' && isArrowHead(tokens[tokens.length - 1], i)) &&
+            !assertionTypeContinues(typeAnnotation, ch, identifier?.value, tokenLineBreakBefore, source[i + 1])) {
+            // Complete the expression before class-field ASI and slash classification consume it.
+            // The token keeps its type delimiter identity; no runtime brace is invented or popped.
+            const previous = tokens[tokens.length - 1];
+            if (previous !== undefined) {
+                tokens[tokens.length - 1] = { ...previous, assertionEnd: true };
+            }
+            prevIsExpressionKeyword = false;
+            afterControlHead = false;
+            typeAnnotation = undefined;
+            inType = false;
+        }
+        // An assertion must release its type context before the same runtime delimiter can retire
+        // an enclosing arrow. Consume the delimiter only after restoring the nearest function grammar.
+        let expressionFunctionContext = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+        while (expressionFunctionContext !== undefined &&
+            typeAnnotation === undefined &&
+            frames[frames.length - 1]?.kind !== 'jsx-text' &&
+            frames[frames.length - 1]?.kind !== 'jsx-tag' &&
+            expressionFunctionBodyEnded(ch, parenDepth, bracketDepth, braceContexts.length, frames.length, functionContextStack.length, conditionalContexts.length, expressionFunctionContext)) {
+            expressionFunctionContexts.pop();
+            expressionFunctionContext = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+        }
+        if (typeAnnotation?.role === 'return' &&
+            tokenLineBreakBefore &&
+            atLexicalDepth(typeAnnotation.signature.owner) &&
+            atTypeRoot(typeAnnotation) &&
+            !typeAnnotation.typeOperandExpected &&
+            identifier !== undefined &&
+            (!TYPE_OPERAND_KEYWORDS.has(identifier.value) || identifier.value === 'const')) {
+            const signature = typeAnnotation.signature;
+            if (pendingFunctionContexts[pendingFunctionContexts.length - 1] === signature.context) {
+                pendingFunctionContexts.pop();
+            }
+            if (classState !== undefined && signature.context.isClassMember === true) {
+                classState.member = undefined;
+            }
+            typeAnnotation = undefined;
+            inType = false;
+        }
+        if (classState !== undefined &&
+            atLexicalDepth(classState) &&
+            (typeAnnotation === undefined ||
+                (typeAnnotation.role === 'field' && atTypeRoot(typeAnnotation)) ||
+                (typeAnnotation.role === 'return' &&
+                    atTypeRoot(typeAnnotation) &&
+                    (ch === ';' || ch === '}')))) {
+            if (tokenLineBreakBefore &&
+                classState.member !== undefined &&
+                typeAnnotation?.typeOperandExpected !== true &&
+                classFieldCanEnd(classState.member, tokens[tokens.length - 1], ch, identifier?.value)) {
+                classState.member = undefined;
+                typeAnnotation = undefined;
+                inType = false;
+            }
+            if (ch === ';' || ch === '}') {
+                classState.member = undefined;
+                if (typeAnnotation?.role === 'field') {
+                    typeAnnotation = undefined;
+                    inType = false;
+                }
+            }
+            else {
+                classState.member ??= {
+                    start: tokens.length,
+                    functionDepth: functionContextStack.length,
+                    phase: 'head',
+                };
+                memberAtToken = classState.member;
+            }
+        }
+        if (lineTerminatorSinceLastToken && typeAnnotation === undefined) {
+            let context = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+            while (context !== undefined &&
+                frames[frames.length - 1]?.kind !== 'jsx-text' &&
+                frames[frames.length - 1]?.kind !== 'jsx-tag' &&
+                lineTerminatorEndsExpressionFunctionBody(ch, prevKind, prevPunct, tokens[tokens.length - 1], identifier?.value, (ch === '+' || ch === '-') && source[i + 1] === ch, parenDepth, bracketDepth, braceContexts.length, frames.length, functionContextStack.length, context)) {
+                expressionFunctionContexts.pop();
+                context = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+            }
+            lineTerminatorSinceLastToken = false;
+        }
+        const equalsOperator = ch === '='
+            ? classifyEquals(source, i, typeAnnotation !== undefined && atTypeRoot(typeAnnotation))
+            : undefined;
+        if (ch === '<' && typeAnnotation === undefined) {
+            const classHeader = pendingClassContexts[pendingClassContexts.length - 1];
+            if (classHeader !== undefined &&
+                atLexicalDepth(classHeader) &&
+                (tokens[tokens.length - 1]?.kind === 'identifier' ||
+                    isPunct(tokens[tokens.length - 1], ')') ||
+                    isPunct(tokens[tokens.length - 1], ']') ||
+                    isPunct(tokens[tokens.length - 1], '>'))) {
+                typeAnnotation = {
+                    role: 'class-header',
+                    owner: classHeader,
+                    parenDepth: 0,
+                    bracketDepth: 0,
+                    braceDepth: 0,
+                    angleDepth: 0,
+                    typeOperandExpected: true,
+                };
+                inType = true;
+            }
+        }
+        // A backtick in code mode opens a (possibly nested) template literal. Inside an annotation
+        // that is a template-literal type: its text stays inert and the annotation keeps running until the
+        // type itself ends.
+        if (ch === '`') {
+            templateStart = i;
+            templateStarts.push(i);
+            inText = true;
+            prevKind = 'template';
+            if (typeAnnotation !== undefined) {
+                typeAnnotation.typeOperandExpected = false;
+            }
+            i++;
+            continue;
+        }
+        // JSX overlay (opt-in via the `jsx` option). A `<` in expression position that is followed by a
+        // tag name (or `>` for a fragment) opens JSX markup: its text, tags and attributes are inert,
+        // while the JavaScript inside `{...}` containers is lexed normally. Expression position is the
+        // same test that decides a regex literal, so a comparison (`a < b`, `f() < x`) is never JSX, and
+        // a TypeScript type-argument list (`<T,>`, `<T extends U>`) is excluded explicitly.
+        if (jsx &&
+            typeAnnotation === undefined &&
+            ch === '<' &&
+            i + 1 < n &&
+            isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword, afterControlHead, closedObjectBrace, tokens[tokens.length - 1])) {
+            const after = source[i + 1];
+            if (after === '>') {
+                frames.push({ kind: 'jsx-text', name: null, offset: i });
+                pushBoundary(i);
+                i += 2;
+                continue;
+            }
+            if (isIdentifierStartAt(source, i + 1) && !jsxTagIsGeneric(source, i + 1, n)) {
+                const tag = readJsxTagName(source, i + 1, n);
+                frames.push({ kind: 'jsx-tag', name: tag.name, offset: i, nameEnd: tag.end });
+                pushBoundary(i);
+                i = tag.end;
+                continue;
+            }
+        }
+        // Type delimiters belong to the field, parameter or return signature, never to runtime code.
+        // Only that owner's boundary or initializer/body can end the annotation.
+        if (typeAnnotation !== undefined) {
+            const annotation = typeAnnotation;
+            const typeFrame = frame?.kind === 'template-expr' && frame.typeOwner?.annotation === annotation
+                ? frame.typeOwner
+                : undefined;
+            const atRoot = typeFrame === undefined && atTypeRoot(annotation);
+            const isTypeArrow = ch === '>' && isArrowHead(tokens[tokens.length - 1], i);
+            if (annotation.role === 'assertion' && atRoot) {
+                if (ch === '?' && annotation.conditionalOperand) {
+                    annotation.conditionalDepth++;
+                    annotation.conditionalOperand = false;
+                }
+                else if (ch === ':' && annotation.conditionalDepth > 0) {
+                    annotation.conditionalDepth--;
+                }
+                if (ch === '(') {
+                    annotation.importCallPending = false;
+                }
+            }
+            // Interpolations own depths relative to the surrounding type, which may itself be an object.
+            if (ch === '}' &&
+                (typeFrame !== undefined
+                    ? sameTypeDepth(annotation, typeFrame.depth)
+                    : annotation.braceDepth === 0) &&
+                (frame?.kind === 'template-expr' || frame?.kind === 'jsx-expr') &&
+                frame.depth === 0) {
+                frames.pop();
+                pushBoundary(i);
+                i++;
+                if (frame.kind === 'template-expr') {
+                    annotation.typeOperandExpected = false;
+                    inText = true;
+                    resetExpressionState();
+                }
+                else {
+                    // Back to the enclosing JSX tag or text frame, which reads the next character itself.
+                    endJsxElement();
+                }
+                continue;
+            }
+            if ((annotation.role === 'field' || annotation.role === 'parameter') &&
+                atRoot &&
+                ch === '=' &&
+                equalsOperator?.operator === 'assignment') {
+                if (annotation.role === 'field') {
+                    annotation.member.phase = 'initializer';
+                }
+                else {
+                    annotation.owner.phase = 'initializer';
+                }
+                typeAnnotation = undefined;
+                inType = false;
+            }
+            else if (annotation.role === 'return' &&
+                ch === '{' &&
+                atRoot &&
+                !annotation.typeOperandExpected) {
+                // A complete type was read, so this brace opens the runtime body.
+                typeAnnotation = undefined;
+                inType = false;
+                lineTerminatorSinceLastToken = false;
+                if (!annotation.signature.isFunctionKeyword) {
+                    pendingFunctionContexts.push({
+                        ...annotation.signature.context,
+                        ...annotation.signature.owner,
+                        parameterDepth: undefined,
+                        phase: 'awaiting-body',
+                    });
+                }
+            }
+            else if (isTypeArrow &&
+                atRoot &&
+                annotation.role === 'return' &&
+                annotation.signature.isArrowSignature &&
+                !functionTypeArrowContinues(source, i, n)) {
+                // The signature's own `=>`: everything after it is the body, not the return type.
+                typedArrowContext = annotation.signature.context;
+                typeAnnotation = undefined;
+                inType = false;
+                lineTerminatorSinceLastToken = false;
+            }
+            else if (atRoot && (ch === ';' || ch === ',' || ch === ')' || ch === ']' || ch === '}')) {
+                // A signature with no body of its own. Neither the annotation nor a pending signature may
+                // outlive it, otherwise later code (a JSX text `<`, another method body, an async arrow) is
+                // misread.
+                typeAnnotation = undefined;
+                inType = false;
+            }
+            else {
+                if (ch === '{') {
+                    annotation.braceDepth++;
+                    annotation.typeOperandExpected = true;
+                }
+                else if (ch === '}') {
+                    annotation.braceDepth = Math.max(0, annotation.braceDepth - 1);
+                    annotation.typeOperandExpected = false;
+                }
+                else if (ch === '(') {
+                    annotation.parenDepth++;
+                    annotation.typeOperandExpected = true;
+                }
+                else if (ch === ')') {
+                    annotation.parenDepth = Math.max(0, annotation.parenDepth - 1);
+                    annotation.typeOperandExpected = false;
+                }
+                else if (ch === '[') {
+                    annotation.bracketDepth++;
+                    annotation.typeOperandExpected = true;
+                }
+                else if (ch === ']') {
+                    annotation.bracketDepth = Math.max(0, annotation.bracketDepth - 1);
+                    annotation.typeOperandExpected = false;
+                }
+                else if (ch === '<') {
+                    annotation.angleDepth++;
+                    annotation.typeOperandExpected = true;
+                }
+                else if (isTypeArrow) {
+                    // A function type's own arrow (`(x: A) => B`) still expects a type on its right.
+                    annotation.typeOperandExpected = true;
+                }
+                else if (ch === '>' && annotation.angleDepth > 0) {
+                    annotation.angleDepth--;
+                    annotation.typeOperandExpected = false;
+                }
+                else if (ch === ':' || ch === '?' || ch === '.' || ch === '|' || ch === '&') {
+                    annotation.typeOperandExpected = true;
+                }
+                if (annotation.role === 'class-header' &&
+                    ch === '>' &&
+                    !isTypeArrow &&
+                    atTypeRoot(annotation)) {
+                    typeAnnotation = undefined;
+                }
+            }
+        }
+        // A `}` in code mode closes the innermost open `${...}` or JSX `{...}` expression only when that
+        // expression has no open braces of its own; otherwise it is an ordinary brace inside it.
+        if (ch === '}' && typeAnnotation === undefined) {
+            if (frame?.kind === 'template-expr' || frame?.kind === 'jsx-expr') {
+                if (frame.depth === 0) {
+                    frames.pop();
+                    pushBoundary(i);
+                    i++;
+                    if (frame.kind === 'template-expr') {
+                        inText = true;
+                        resetExpressionState();
+                    }
+                    else {
+                        // Back to the enclosing JSX tag or text frame, which reads the next character itself.
+                        endJsxElement();
+                    }
+                    continue;
+                }
+                frame.depth -= 1;
+            }
+            // Operand completion for class-field ASI is separate from the regex/division decision.
+            // A function/class body can finish an initializer without closing an object literal.
+            const closed = braceContexts.pop();
+            const closedMethod = closed?.role === 'function' && closed.context.isClassMember === true;
+            closedClassMemberBoundary = closedMethod || closed?.role === 'static-block';
+            closedObjectBrace =
+                closed?.role === 'object' ||
+                    (closed?.role === 'function' && closed.context.isExpression) ||
+                    (closed?.role === 'class' && closed.isExpression);
+            closedExpressionBrace =
+                closedObjectBrace ||
+                    closedMethod ||
+                    closed?.role === 'function' ||
+                    closed?.role === 'class';
+            if (closed?.role === 'function') {
+                functionContextStack.pop();
+            }
+            if ((closed?.role === 'function' || closed?.role === 'static-block') &&
+                closed.owner !== undefined) {
+                closed.owner.member = undefined;
+            }
+        }
+        // `/` is a regex when it can start an expression, otherwise it is division.
+        if (ch === '/') {
+            if (isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword ||
+                (tokenLineBreakBefore &&
+                    (isIdentifier(tokens[tokens.length - 1], 'break') ||
+                        isIdentifier(tokens[tokens.length - 1], 'continue'))), afterControlHead, closedObjectBrace, tokens[tokens.length - 1])) {
+                const start = i;
+                i = skipRegex(source, i);
+                emit({ kind: 'regex', offset: start, endOffset: i });
+                prevKind = 'regex';
+                afterControlHead = false;
+                pendingControlKeyword = undefined;
+                continue;
+            }
+            emit({ kind: 'punct', value: '/', offset: i, endOffset: i + 1 });
+            prevKind = 'punct';
+            prevPunct = '/';
+            afterControlHead = false;
+            pendingControlKeyword = undefined;
+            i++;
+            continue;
+        }
+        // String literals (single or double quoted).
+        if (ch === "'" || ch === '"') {
+            const { value, next } = readString(source, i);
+            emit({ kind: 'string', value, offset: i, endOffset: next });
+            if (typeAnnotation !== undefined) {
+                typeAnnotation.typeOperandExpected = false;
+            }
+            prevKind = 'string';
+            afterControlHead = false;
+            pendingControlKeyword = undefined;
+            i = next;
+            continue;
+        }
+        // Identifiers.
+        if (identifier !== undefined) {
+            const start = i;
+            i = identifier.end;
+            const value = identifier.value;
+            if (typeAnnotation !== undefined) {
+                if (typeAnnotation.role === 'assertion') {
+                    if (atLexicalDepth(typeAnnotation.owner) &&
+                        atTypeRoot(typeAnnotation) &&
+                        value === 'extends' &&
+                        !typeAnnotation.typeOperandExpected) {
+                        typeAnnotation.conditionalOperand = true;
+                    }
+                    typeAnnotation.importCallPending = value === 'import';
+                }
+                // `as const` completes an assertion, while prefix keywords still expect an operand.
+                typeAnnotation.typeOperandExpected =
+                    TYPE_OPERAND_KEYWORDS.has(value) &&
+                        !(typeAnnotation.role === 'assertion' && value === 'const');
+            }
+            const previousIdentifier = prevIdentifier;
+            const startsAssertion = (value === 'as' || value === 'satisfies') &&
+                !inType &&
+                // TypeScript permits trivia after these operators, but a preceding newline ends them.
+                !tokenLineBreakBefore &&
+                !(prevKind === 'punct' && prevPunct === '.') &&
+                !(prevKind === 'punct' &&
+                    prevPunct === '}' &&
+                    !closedObjectBrace &&
+                    tokens[tokens.length - 1]?.assertionEnd !== true) &&
+                !afterControlHead &&
+                !prevIsExpressionKeyword &&
+                canStartTypeAssertion(tokens[tokens.length - 1]);
+            if (value === 'async') {
+                asyncFunctionIsExpression = functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression);
+                if (isIdentifier(tokens[tokens.length - 1], 'default') &&
+                    isIdentifier(tokens[tokens.length - 2], 'export')) {
+                    asyncFunctionIsExpression = false;
+                }
+            }
+            prevIdentifier = value;
+            const isMemberName = prevKind === 'punct' && prevPunct === '.';
+            const classMemberName = value === 'class' &&
+                (insideObjectLiteral() || insideClassBody()) &&
+                memberDeclarationHead(tokens, tokens.length, insideClassBody(), currentClass()?.member?.start) !== undefined;
+            const nextSignificant = skipTrivia(source, i, n);
+            const classPropertyName = value === 'class' &&
+                (insideObjectLiteral() || insideClassBody()) &&
+                [':', '=', '(', ',', '}'].includes(source[nextSignificant] ?? '');
+            if (value === 'class' &&
+                !isMemberName &&
+                !classMemberName &&
+                !classPropertyName &&
+                typeAnnotation === undefined) {
+                const isExportDefault = isIdentifier(tokens[tokens.length - 1], 'default') &&
+                    isIdentifier(tokens[tokens.length - 2], 'export');
+                pendingClassContexts.push({
+                    parenDepth,
+                    bracketDepth,
+                    braceDepth: braceContexts.length,
+                    frameDepth: frames.length,
+                    isExpression: !isExportDefault &&
+                        (previousIdentifier === 'extends' ||
+                            functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression) ||
+                            (isPunct(tokens[tokens.length - 1], '>') && isArrowHead(tokens[tokens.length - 2]))),
+                });
+            }
+            // A keyword after `.` is a property name (e.g. `x.return`), not an expression start.
+            const forIterationSeparator = (value === 'of' || value === 'in') &&
+                !isMemberName &&
+                consumeForIterationSeparator(tokens, parameterContexts, {
+                    parenDepth,
+                    bracketDepth,
+                    braceDepth: braceContexts.length,
+                    frameDepth: frames.length,
+                });
+            let isExpressionKeyword = (REGEX_PRECEDING_KEYWORDS.has(value) || forIterationSeparator) && !isMemberName;
+            // `await`/`yield` are keywords only inside an async / generator function body. A member name
+            // (`obj.await`) is always a property access, never a keyword, so a following `/` divides.
+            if (!isMemberName) {
+                const expressionContext = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+                const bodyContext = functionContextStack[functionContextStack.length - 1];
+                const parameterOwner = nearestFunctionParameter(parameterContexts);
+                const classMemberOwner = nearestClassField(braceContexts);
+                const parameterGrammarSuspended = parameterOwner !== undefined &&
+                    functionContextStack.length <= parameterOwner.functionDepth &&
+                    expressionContext?.parameterOwner !== parameterOwner;
+                const fieldGrammarSuspended = classMemberOwner !== undefined &&
+                    functionContextStack.length <= classMemberOwner.functionDepth &&
+                    expressionContext?.classMemberOwner !== classMemberOwner;
+                const expressionContextIsCurrent = expressionContext !== undefined &&
+                    functionContextStack.length <= expressionContext.functionDepth
+                    ? expressionContext
+                    : undefined;
+                const functionContext = parameterGrammarSuspended || fieldGrammarSuspended
+                    ? undefined
+                    : (expressionContextIsCurrent ?? bodyContext);
+                if (value === 'await' &&
+                    (functionContext?.async === true ||
+                        (functionContext === undefined &&
+                            module &&
+                            !parameterGrammarSuspended &&
+                            !fieldGrammarSuspended))) {
+                    isExpressionKeyword = true;
+                }
+                else if (value === 'yield' && functionContext?.generator === true) {
+                    isExpressionKeyword = true;
+                }
+            }
+            prevIsExpressionKeyword = isExpressionKeyword;
+            // Remember a control-statement keyword until its `(` is seen so only that head's `)` may be
+            // followed by a regex literal.
+            pendingControlKeyword = pendingControlKeywordAfter(value, isMemberName || insideObjectLiteral() || insideClassBody(), pendingControlKeyword);
+            // A `function` keyword (not a property name) starts a function signature. Track whether it is
+            // an expression (`const f = function(){}`) or a declaration (`function f(){}`), and whether it
+            // is async (`async function`, i.e. preceded by `async`) or a generator (`function*`, resolved
+            // when a following `*` is seen). The context is consumed at the body `{`.
+            const methodName = value === 'function' &&
+                (insideObjectLiteral() || insideClassBody()) &&
+                memberDeclarationHead(tokens, tokens.length, insideClassBody(), currentClass()?.member?.start) !== undefined;
+            if (value === 'function' && !isMemberName && !methodName && typeAnnotation === undefined) {
+                // `async function` is only async without a line terminator between the two words: a line
+                // break ends the `async` statement, so the declaration that follows is an ordinary one.
+                const isAsync = previousIdentifier === 'async' && prevKind === 'identifier' && !tokenLineBreakBefore;
+                pendingFunctionContexts.push({
+                    async: isAsync,
+                    generator: false,
+                    isExpression: isAsync
+                        ? asyncFunctionIsExpression
+                        : !(isIdentifier(tokens[tokens.length - 1], 'default') &&
+                            isIdentifier(tokens[tokens.length - 2], 'export')) &&
+                            functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression),
+                    parenDepth,
+                    bracketDepth,
+                    braceDepth: braceContexts.length,
+                    frameDepth: frames.length,
+                    parameterDepth: undefined,
+                    phase: 'awaiting-parameters',
+                });
+            }
+            emit({
+                kind: 'identifier',
+                value,
+                offset: start,
+                endOffset: i,
+                ...(isMemberName ? { propertyName: true } : {}),
+            });
+            if (startsAssertion) {
+                typeAnnotation = {
+                    role: 'assertion',
+                    conditionalDepth: 0,
+                    conditionalOperand: false,
+                    importCallPending: false,
+                    owner: {
+                        parenDepth,
+                        bracketDepth,
+                        braceDepth: braceContexts.length,
+                        frameDepth: frames.length,
+                    },
+                    parenDepth: 0,
+                    bracketDepth: 0,
+                    braceDepth: 0,
+                    angleDepth: 0,
+                    typeOperandExpected: true,
+                };
+            }
+            prevKind = 'identifier';
+            afterControlHead = false;
+            continue;
+        }
+        // Numbers end an expression, so they affect the regex/division decision.
+        if (isNumberStart(ch)) {
+            const start = i;
+            i++;
+            while (i < n) {
+                const part = source[i];
+                if (part === undefined || !(isIdentifierPartAt(source, i) || part === '.')) {
+                    break;
+                }
+                i++;
+            }
+            emit({ kind: 'number', offset: start, endOffset: i });
+            if (typeAnnotation !== undefined) {
+                typeAnnotation.typeOperandExpected = false;
+            }
+            prevKind = 'number';
+            afterControlHead = false;
+            pendingControlKeyword = undefined;
+            continue;
+        }
+        if (ch === ':' && typeAnnotation === undefined) {
+            const parameter = parameterContexts[parameterContexts.length - 1];
+            if (previousSignature !== undefined && atLexicalDepth(previousSignature.owner)) {
+                typeAnnotation = {
+                    role: 'return',
+                    signature: previousSignature,
+                    parenDepth: 0,
+                    bracketDepth: 0,
+                    braceDepth: 0,
+                    angleDepth: 0,
+                    typeOperandExpected: true,
+                };
+                inType = true;
+            }
+            else if (classState !== undefined &&
+                memberAtToken !== undefined &&
+                (memberAtToken.phase === 'field' || memberAtToken.phase === 'head')) {
+                typeAnnotation = {
+                    role: 'field',
+                    owner: classState,
+                    member: memberAtToken,
+                    parenDepth: 0,
+                    bracketDepth: 0,
+                    braceDepth: 0,
+                    angleDepth: 0,
+                    typeOperandExpected: true,
+                };
+                memberAtToken.phase = 'type';
+                inType = true;
+            }
+            else if (parameter?.signature !== undefined &&
+                parameter.phase === 'binding' &&
+                atLexicalDepth(parameter.depth)) {
+                typeAnnotation = {
+                    role: 'parameter',
+                    owner: parameter,
+                    parenDepth: 0,
+                    bracketDepth: 0,
+                    braceDepth: 0,
+                    angleDepth: 0,
+                    typeOperandExpected: true,
+                };
+                parameter.phase = 'type';
+                inType = true;
+            }
+        }
+        // Any other single character is punctuation. This (and the `:`/`;`/`}` handlers below) is the
+        // only place that pushes a conditionalContext, and it is reached solely while scanning real
+        // JavaScript: template text, JSX markup and `${...}`/`{...}` expression bodies are consumed by
+        // the text-mode gates above, so inert punctuation inside them never contributes a conditional.
+        // A `?` in template text is a plain character, not a ternary, so it must not leak here.
+        if (!inType &&
+            ch === '?' &&
+            (memberAtToken === undefined || memberAtToken.phase === 'initializer') &&
+            source[i + 1] !== '?' &&
+            source[i - 1] !== '?' &&
+            source[i + 1] !== '.') {
+            conditionalContexts.push({
+                parenDepth,
+                bracketDepth,
+                braceDepth: braceContexts.length,
+                frameDepth: frames.length,
+            });
+        }
+        else if (!inType && ch === ':') {
+            const isConditional = conditional !== undefined && atLexicalDepth(conditional);
+            if (isConditional) {
+                conditionalContexts.pop();
+            }
+            colonIsExpression = isConditional || insideObjectLiteral();
+        }
+        else if (!inType && ch === ';' && conditional !== undefined && atLexicalDepth(conditional)) {
+            conditionalContexts.pop();
+        }
+        if (!inType && ch === '{') {
+            // Record what this brace opens, so its `}` knows whether an expression or a statement ended.
+            let isObject = opensObjectLiteral(prevKind, prevPunct, prevIdentifier, prevIsExpressionKeyword, frame?.kind === 'template-expr' || frame?.kind === 'jsx-expr', colonIsExpression, tokenLineBreakBefore);
+            const pending = pendingFunctionContexts[pendingFunctionContexts.length - 1];
+            let context;
+            if (pending?.phase === 'awaiting-body' && atLexicalDepth(pending)) {
+                context = pendingFunctionContexts.pop();
+            }
+            if (context !== undefined) {
+                isObject = false;
+            }
+            const classExpression = !isObject && context === undefined
+                ? takeClassBodyContext(pendingClassContexts, {
+                    parenDepth,
+                    bracketDepth,
+                    braceDepth: braceContexts.length,
+                    frameDepth: frames.length,
+                })
+                : undefined;
+            const isClassBody = classExpression !== undefined;
+            opensClassMemberBoundary = isClassBody;
+            const isStaticBlock = !isObject &&
+                !isClassBody &&
+                insideClassBody() &&
+                isIdentifier(tokens[tokens.length - 1], 'static');
+            // A statement-block brace that consumes a pending function signature is a function body. A
+            // function expression used as a value ends an expression (so a following `/` divides), while a
+            // declaration in statement position starts a block (so a following `/` may be a regex).
+            //
+            // Methods consume the signature captured at their parameter opener. Arrows use their
+            // contiguous operator; neither a control head nor an unrelated call can claim this brace.
+            if (context === undefined && !isObject && !isClassBody) {
+                const last = tokens[tokens.length - 1];
+                context =
+                    isPunct(last, '>') && isArrowHead(tokens[tokens.length - 2])
+                        ? inferArrowContext(tokens, tokens.length - 2)
+                        : previousSignature !== undefined &&
+                            !previousSignature.isArrowSignature &&
+                            atLexicalDepth(previousSignature.owner)
+                            ? previousSignature.context
+                            : undefined;
+            }
+            if (!isObject && context !== undefined) {
+                functionContextStack.push(context);
+            }
+            const owner = currentClass();
+            if (context !== undefined) {
+                braceContexts.push({
+                    role: 'function',
+                    context,
+                    ...(context.isClassMember === true && owner !== undefined ? { owner } : {}),
+                });
+            }
+            else if (isClassBody) {
+                braceContexts.push({
+                    role: 'class',
+                    isExpression: classExpression.isExpression,
+                    state: {
+                        parenDepth,
+                        bracketDepth,
+                        braceDepth: braceContexts.length + 1,
+                        frameDepth: frames.length,
+                        member: undefined,
+                    },
+                });
+            }
+            else if (isStaticBlock && owner !== undefined) {
+                braceContexts.push({ role: 'static-block', owner });
+            }
+            else {
+                braceContexts.push({ role: isObject ? 'object' : 'block' });
+            }
+            // Count the brace inside the innermost open `${...}` or JSX `{...}` expression so its closing
+            // `}` is found.
+            if (frame?.kind === 'template-expr' || frame?.kind === 'jsx-expr') {
+                frame.depth += 1;
+            }
+        }
+        else if (!inType && ch === '(') {
+            // A `(` after a control keyword opens a control head; only its matching `)` may then be
+            // followed by a regex literal, so the nesting depth of every `(` has to be tracked.
+            const pending = pendingFunctionContexts[pendingFunctionContexts.length - 1];
+            const previousToken = tokens[tokens.length - 1];
+            const arrowBodyParenthesis = previousToken?.kind === 'punct' &&
+                previousToken.value === '>' &&
+                isArrowHead(tokens[tokens.length - 2], previousToken.offset);
+            const signatureCandidate = arrowBodyParenthesis
+                ? undefined
+                : parameterSignatureContext(tokens, pending !== undefined && atLexicalDepth(pending) ? pending : undefined, insideObjectLiteral() || insideClassBody(), insideClassBody(), tokenLineBreakBefore, currentClass()?.member?.start);
+            const signature = signatureCandidate?.isArrowSignature === true && !arrowFollowsParametersSafely(source, i, n)
+                ? undefined
+                : signatureCandidate;
+            parameterContexts.push({
+                openIndex: tokens.length,
+                signature: signature === undefined
+                    ? undefined
+                    : {
+                        ...signature,
+                        owner: {
+                            parenDepth,
+                            bracketDepth,
+                            braceDepth: braceContexts.length,
+                            frameDepth: frames.length,
+                        },
+                    },
+                control: pendingControlKeyword !== undefined,
+                controlKeyword: pendingControlKeyword,
+                functionDepth: functionContextStack.length,
+                depth: {
+                    parenDepth: parenDepth + 1,
+                    bracketDepth,
+                    braceDepth: braceContexts.length,
+                    frameDepth: frames.length,
+                },
+                phase: 'binding',
+                ...(pendingControlKeyword === 'for' ? { forPhase: 'binding' } : {}),
+            });
+            if (pending?.phase === 'awaiting-parameters' &&
+                atLexicalDepth(pending) &&
+                signature?.isFunctionKeyword === true) {
+                pending.parameterDepth = parenDepth + 1;
+                pending.phase = 'parameters';
+            }
+            parenDepth++;
+            pendingControlKeyword = undefined;
+            afterControlHead = false;
+        }
+        else if (!inType && ch === '[') {
+            bracketDepth++;
+        }
+        else if (!inType && ch === ')') {
+            const pending = pendingFunctionContexts[pendingFunctionContexts.length - 1];
+            if (pending?.parameterDepth === parenDepth &&
+                bracketDepth === pending.bracketDepth &&
+                braceContexts.length === pending.braceDepth &&
+                frames.length === pending.frameDepth) {
+                pending.phase = 'awaiting-body';
+            }
+            const parameters = parameterContexts.pop();
+            matchingOpen = parameters?.openIndex;
+            closedParameterSignature = parameters?.signature;
+            afterControlHead = parameters?.control === true;
+            if (parenDepth > 0) {
+                parenDepth--;
+            }
+        }
+        else if (!inType && ch === ']') {
+            if (bracketDepth > 0) {
+                bracketDepth--;
+            }
+        }
+        if (!inType && (ch === '+' || ch === '-') && source[i + 1] === ch) {
+            const previous = tokens[tokens.length - 1];
+            const postfix = !tokenLineBreakBefore &&
+                previous !== undefined &&
+                isMemberExpressionEnd(previous) &&
+                !prevIsExpressionKeyword;
+            emit({
+                kind: 'punct',
+                value: ch + ch,
+                offset: i,
+                endOffset: i + 2,
+                expressionEnd: postfix,
+            });
+            prevKind = 'punct';
+            prevPunct = ch + ch;
+            i += 2;
+            continue;
+        }
+        // An arrow's expression body has no brace where its function context can be consumed. Record
+        // its bounded context after `=>`; a following delimiter removes it again.
+        if (!inType && ch === '>' && isArrowHead(tokens[tokens.length - 1], i)) {
+            const context = typedArrowContext ?? inferArrowContext(tokens, tokens.length - 1);
+            const next = skipTrivia(source, i + 1, n);
+            if (context !== undefined) {
+                if (source[next] === '{') {
+                    if (typedArrowContext !== undefined) {
+                        pendingFunctionContexts.push({
+                            ...typedArrowContext,
+                            parenDepth,
+                            bracketDepth,
+                            braceDepth: braceContexts.length,
+                            frameDepth: frames.length,
+                            parameterDepth: undefined,
+                            phase: 'awaiting-body',
+                        });
+                    }
+                }
+                else {
+                    const parameterOwner = nearestFunctionParameter(parameterContexts);
+                    const classMemberOwner = nearestClassField(braceContexts);
+                    expressionFunctionContexts.push({
+                        ...context,
+                        isExpression: true,
+                        parenDepth,
+                        bracketDepth,
+                        braceDepth: braceContexts.length,
+                        frameDepth: frames.length,
+                        functionDepth: functionContextStack.length,
+                        conditionalDepth: conditionalContexts.length,
+                        ...(parameterOwner === undefined ? {} : { parameterOwner }),
+                        ...(classMemberOwner === undefined ? {} : { classMemberOwner }),
+                    });
+                }
+            }
+        }
+        // A `*` right after `function` (whitespace/comments aside) marks a generator: `function*` and
+        // `function *`. It is recorded on the pending signature, consumed at the body `{`.
+        const pending = pendingFunctionContexts[pendingFunctionContexts.length - 1];
+        const parameter = parameterContexts[parameterContexts.length - 1];
+        if (ch === ';' && parameter?.forPhase !== undefined && atLexicalDepth(parameter.depth)) {
+            parameter.forPhase = 'regular';
+        }
+        if (!inType && parameter !== undefined && atLexicalDepth(parameter.depth)) {
+            if (ch === ',') {
+                parameter.phase = 'binding';
+            }
+            else if (equalsOperator?.operator === 'assignment') {
+                parameter.phase = 'initializer';
+            }
+        }
+        if (!inType &&
+            ch === '*' &&
+            prevKind === 'identifier' &&
+            prevIdentifier === 'function' &&
+            pending !== undefined) {
+            pendingFunctionContexts[pendingFunctionContexts.length - 1] = {
+                ...pending,
+                generator: true,
+            };
+        }
+        // A callback's statements cannot invalidate a signature outside its body or parameter list.
+        if (!inType && ch === ';' && pending !== undefined && atLexicalDepth(pending)) {
+            pendingFunctionContexts.pop();
+        }
+        const previousToken = tokens[tokens.length - 1];
+        emit({
+            kind: 'punct',
+            value: ch,
+            offset: i,
+            endOffset: i + 1,
+            ...(ch === '!' &&
+                source[i + 1] !== '=' &&
+                previousToken !== undefined &&
+                isMemberExpressionEnd(previousToken) &&
+                !prevIsExpressionKeyword
+                ? { expressionEnd: true }
+                : {}),
+            ...equalsOperator,
+            ...(matchingOpen !== undefined ? { matchingOpen } : {}),
+            ...(closedClassMemberBoundary || opensClassMemberBoundary || (ch === ';' && insideClassBody())
+                ? { memberSeparator: true }
+                : {}),
+            ...(closedExpressionBrace ? { expressionEnd: true } : {}),
+        });
+        prevKind = 'punct';
+        prevPunct = ch;
+        i++;
+    }
+    // Reaching the end of the source with an open frame means the template literal, the JSX element or
+    // the JSX expression container was never closed. The innermost open frame is the one that failed.
+    const openFrame = frames[frames.length - 1];
+    if (inText || openFrame?.kind === 'template-expr') {
+        throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', inText ? templateStart : (openFrame?.offset ?? templateStart));
+    }
+    if (openFrame?.kind === 'jsx-expr') {
+        throw new ModuleSpecifierError('Unterminated JSX expression', 'invalid-source', openFrame.offset);
+    }
+    if (openFrame !== undefined) {
+        throw new ModuleSpecifierError('Unterminated JSX element', 'invalid-source', openFrame.offset);
+    }
+    return tokens;
+}
+// A `<` followed by an identifier that begins a generic type-argument list (e.g. `<T,>`, `<T = X>`,
+// `<T extends U>`, `<const T,>`) or a generic function signature (`<T>(x: T) => T`) is not a JSX
+// element. `<T>` alone in expression position remains ambiguous and is treated as JSX.
+function jsxTagIsGeneric(source, i, n) {
+    try {
+        if (!isIdentifierStartAt(source, i)) {
+            return false;
+        }
+        const identifier = readIdentifier(source, i);
+        let k = identifier.end;
+        const name = identifier.value;
+        k = skipTrivia(source, k, n);
+        const next = source[k];
+        if (next === ',' || next === '=') {
+            return true;
+        }
+        if (next === '>') {
+            const j = skipTrivia(source, k + 1, n);
+            if (source[j] === '(') {
+                return arrowFollowsParameters(source, j, n);
+            }
+        }
+        let end = k;
+        while (end < n && isIdentifierPartAt(source, end)) {
+            end++;
+        }
+        if (source.slice(k, end) === 'extends') {
+            // `extends` is a generic constraint only when it introduces a constraint type that closes
+            // the type-parameter list. `implements` is not a TypeScript type-parameter constraint and
+            // remains a JSX boolean attribute.
+            const j = skipTrivia(source, end, n);
+            const after = source[j];
+            if (after !== '=' &&
+                after !== '"' &&
+                after !== "'" &&
+                after !== '`' &&
+                after !== '>' &&
+                after !== '/') {
+                return true;
+            }
+        }
+        // `const T, ...`: a TypeScript const type parameter, whose real name follows the modifier.
+        if (name === 'const' && k < n && isIdentifierStartAt(source, k)) {
+            return jsxTagIsGeneric(source, k, n);
+        }
+        return false;
+    }
+    catch (error) {
+        if (error instanceof ModuleSpecifierError) {
+            // This is speculative: an apostrophe or `/*` may be inert JSX children, not broken JS.
+            // Let the normal JSX path scan it; genuinely incomplete markup will still fail there.
+            return false;
+        }
+        throw error;
+    }
+}
+// Scan a generic function signature's parameter list starting at its opening `(` (offset `open`).
+// Returns true only when the list is closed and `=>` follows, so callers can treat `<T>(...) =>` as
+// a generic signature rather than a JSX element.
+//
+// Brackets inside strings, template literals and regex literals are inert: a `)` inside any of them
+// must not be counted as the parameter-list close. Template interpolations are skipped opaquely
+// because a template literal is a single argument value, so its internal parentheses never shape
+// the parameter list. Regex-vs-division tracking mirrors the main tokenizer so a regex default
+// (for example `= /a/)`) is skipped instead of read as division.
+function arrowFollowsParameters(source, open, n) {
+    let depth = 0;
+    let prevKind = 'start';
+    let prevPunct;
+    let k = open;
+    while (k < n) {
+        k = skipTrivia(source, k, n);
+        const ch = source[k];
+        if (ch === undefined) {
+            break;
+        }
+        // String literals: their brackets and slashes are inert text, so skip the whole value.
+        if (ch === "'" || ch === '"') {
+            k = readString(source, k).next;
+            prevKind = 'string';
+            continue;
+        }
+        // Template literals: skip their text and interpolation so a `)` inside a template is not
+        // counted as the parameter-list close.
+        if (ch === '`') {
+            k = skipTemplateLiteral(source, k);
+            prevKind = 'template';
+            continue;
+        }
+        // Regex literals: a `/` that begins a regex must be skipped so its `)` stays inside the pattern
+        // rather than closing the parameter list.
+        if (ch === '/' && isRegexStart(prevKind, prevPunct, false, false, false)) {
+            k = skipRegex(source, k);
+            prevKind = 'regex';
+            continue;
+        }
+        if (ch === '(') {
+            depth++;
+            prevKind = 'punct';
+            prevPunct = '(';
+        }
+        else if (ch === ')') {
+            depth--;
+            prevKind = 'punct';
+            prevPunct = ')';
+            if (depth === 0) {
+                const j = skipTrivia(source, k + 1, n);
+                return ((source[j] === '=' && source[j + 1] === '>') ||
+                    (source[j] === ':' && arrowFollowsReturnType(source, j + 1, n)));
+            }
+        }
+        else if (isIdentifierStartAt(source, k)) {
+            const identifier = readIdentifier(source, k);
+            k = identifier.end - 1;
+            prevKind = 'identifier';
+            prevPunct = undefined;
+        }
+        else {
+            prevKind = 'punct';
+            prevPunct = ch;
+        }
+        k++;
+    }
+    return false;
+}
+function arrowFollowsReturnType(source, start, n) {
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let angleDepth = 0;
+    let index = start;
+    while (index < n) {
+        index = skipTrivia(source, index, n);
+        const ch = source[index];
+        if (ch === undefined) {
+            return false;
+        }
+        if (ch === "'" || ch === '"') {
+            index = readString(source, index).next;
+            continue;
+        }
+        if (ch === '`') {
+            index = skipTemplateLiteral(source, index);
+            continue;
+        }
+        if (ch === '=' && source[index + 1] === '>') {
+            if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && angleDepth === 0) {
+                return true;
+            }
+            index += 2;
+            continue;
+        }
+        if (ch === '(') {
+            parenDepth++;
+        }
+        else if (ch === ')') {
+            if (parenDepth === 0) {
+                return false;
+            }
+            parenDepth--;
+        }
+        else if (ch === '[') {
+            bracketDepth++;
+        }
+        else if (ch === ']') {
+            if (bracketDepth === 0) {
+                return false;
+            }
+            bracketDepth--;
+        }
+        else if (ch === '{') {
+            braceDepth++;
+        }
+        else if (ch === '}') {
+            if (braceDepth === 0) {
+                return false;
+            }
+            braceDepth--;
+        }
+        else if (ch === '<') {
+            angleDepth++;
+        }
+        else if (ch === '>') {
+            if (angleDepth === 0) {
+                return false;
+            }
+            angleDepth--;
+        }
+        else if (parenDepth === 0 &&
+            bracketDepth === 0 &&
+            braceDepth === 0 &&
+            angleDepth === 0 &&
+            (ch === ';' || ch === ',')) {
+            return false;
+        }
+        index++;
+    }
+    return false;
+}
+function arrowFollowsParametersSafely(source, open, n) {
+    try {
+        return arrowFollowsParameters(source, open, n);
+    }
+    catch (error) {
+        if (error instanceof ModuleSpecifierError) {
+            return false;
+        }
+        throw error;
+    }
+}
+// Skip a template literal starting at its opening backtick (offset `start`). Returns the index just
+// past the closing backtick.
+//
+// `${...}` interpolations are skipped opaquely by brace depth: the caller only needs this region to
+// be invisible so its brackets never reach the parameter-list accounting, which is why the body is
+// not re-lexed here.
+//
+// @throws {ModuleSpecifierError} on an unterminated template literal.
+function skipTemplateLiteral(source, start) {
+    const n = source.length;
+    let i = start + 1; // past the opening backtick
+    while (i < n) {
+        const ch = source[i];
+        // A backslash escapes the next character (including a nested backtick or `${`).
+        if (ch === '\\') {
+            i += 2;
+            continue;
+        }
+        if (ch === '`') {
+            return i + 1;
+        }
+        if (ch === '$' && source[i + 1] === '{') {
+            // Skip the interpolation until its braces balance. Nested templates/braces are handled by the
+            // depth counter; a raw line terminator is invalid inside a template and stops the scan.
+            let depth = 1;
+            i += 2;
+            while (i < n && depth > 0) {
+                const inner = source[i];
+                if (inner === '\n' || inner === '\r') {
+                    throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', start);
+                }
+                if (inner === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (inner === '{') {
+                    depth++;
+                }
+                else if (inner === '}') {
+                    depth--;
+                }
+                i++;
+            }
+            continue;
+        }
+        i++;
+    }
+    throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', start);
+}
+/**
+ * Lex only the boundaries of a component's type arguments. These tokens preserve literal imports
+ * without changing the surrounding JavaScript function/brace state or treating type braces as JSX.
+ */
+function readJsxTypeArguments(source, open, n, tokens) {
+    const closers = ['>'];
+    let i = open + 1;
+    while (i < n) {
+        const trivia = readTrivia(source, i, n);
+        i = trivia.end;
+        const ch = source[i];
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === "'" || ch === '"') {
+            const { value, next } = readString(source, i);
+            tokens.push({
+                kind: 'string',
+                value,
+                offset: i,
+                endOffset: next,
+                lineBreakBefore: trivia.lineBreak,
+            });
+            i = next;
+            continue;
+        }
+        if (ch === '`') {
+            throw new ModuleSpecifierError('Template literal types in JSX type arguments are not supported', 'invalid-source', i);
+        }
+        if (isIdentifierStartAt(source, i)) {
+            const start = i;
+            const identifier = readIdentifier(source, i);
+            i = identifier.end;
+            tokens.push({
+                kind: 'identifier',
+                value: identifier.value,
+                offset: start,
+                endOffset: i,
+                lineBreakBefore: trivia.lineBreak,
+            });
+            continue;
+        }
+        if (ch === '<' || ch === '(' || ch === '{' || ch === '[') {
+            closers.push(ch === '<' ? '>' : ch === '(' ? ')' : ch === '{' ? '}' : ']');
+        }
+        else if (ch === closers[closers.length - 1] && !(ch === '>' && source[i - 1] === '=')) {
+            closers.pop();
+            if (closers.length === 0) {
+                return i + 1;
+            }
+        }
+        tokens.push({
+            kind: 'punct',
+            value: ch,
+            offset: i,
+            endOffset: i + 1,
+            lineBreakBefore: trivia.lineBreak,
+            ...(ch === '=' ? classifyEquals(source, i, true) : {}),
+        });
+        i++;
+    }
+    throw new ModuleSpecifierError('Unterminated JSX type arguments', 'invalid-source', open);
+}
+/**
+ * Whether the source between two offsets contains a line terminator.
+ */
+function hasLineTerminator(source, from, to) {
+    for (let k = from; k < to; k++) {
+        if (isLineTerminator(source[k])) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Skip whitespace and comments without interpreting any target-project code. */
+function skipTrivia(source, start, n) {
+    return readTrivia(source, start, n).end;
+}
+function readTrivia(source, start, n) {
+    let i = start;
+    let lineBreak = false;
+    while (i < n) {
+        if (isWhitespace(source[i])) {
+            lineBreak ||= isLineTerminator(source[i]);
+            i++;
+            continue;
+        }
+        if (source[i] === '/' && source[i + 1] === '/') {
+            i += 2;
+            while (i < n && !isLineTerminator(source[i])) {
+                i++;
+            }
+            continue;
+        }
+        if (source[i] === '/' && source[i + 1] === '*') {
+            const start = i;
+            i = skipBlockComment(source, i);
+            lineBreak ||= hasLineTerminator(source, start, i);
+            continue;
+        }
+        break;
+    }
+    return { end: i, lineBreak };
+}
+/**
+ * Type keywords that still expect a type after them, so a `{` following one opens an object type and
+ * not a function body (`T extends { ok: boolean } ? A : B`).
+ */
+const TYPE_OPERAND_KEYWORDS = new Set([
+    'abstract',
+    'as',
+    'asserts',
+    'await',
+    'const',
+    'extends',
+    'in',
+    'infer',
+    'is',
+    'keyof',
+    'new',
+    'readonly',
+    'satisfies',
+    'typeof',
+]);
+/**
+ * Whether a root-level `=>` inside a return annotation is an arrow of the return type itself rather
+ * than the signature's runtime arrow. A function type keeps a second arrow at the same nesting level
+ * (`(): (x: number) => void => {}`); once the return type is over, the next significant token is the
+ * body (`{`), a statement terminator or a delimiter that closes the surrounding code.
+ */
+function functionTypeArrowContinues(source, arrowEnd, n) {
+    let depth = 0;
+    for (let i = arrowEnd + 1; i < n; i++) {
+        const ch = source[i];
+        if (ch === '(' || ch === '[' || ch === '<') {
+            depth++;
+        }
+        else if (ch === '>' && depth > 0) {
+            depth--;
+        }
+        else if (ch === ')' || ch === ']') {
+            if (depth === 0) {
+                return false;
+            }
+            depth--;
+        }
+        else if (depth === 0) {
+            if (ch === '{' || ch === ';' || ch === ',') {
+                return false;
+            }
+            if (ch === '=' && source[i + 1] === '>') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Index of the token that names a `(` parameter list. A generic signature keeps its type-parameter
+ * list between the name and the `(` (`async function f<T>(): T {}`, `async <T,>(value: T) => {}`,
+ * `async check<T>(): T {}`), so a balanced `<...>` directly before the `(` is skipped. The index of
+ * the token directly before the `(` is returned unchanged when no such list precedes it.
+ */
+function signatureNameIndex(tokens, openIndex) {
+    let index = openIndex - 1;
+    const angle = tokens[index];
+    if (angle?.kind !== 'punct' || angle.value !== '>') {
+        return index;
+    }
+    const closers = [];
+    while (index >= 0) {
+        const token = tokens[index];
+        if (token === undefined) {
+            break;
+        }
+        if (token.kind !== 'punct') {
+            index--;
+            continue;
+        }
+        if (token.value === '>' && isArrowHead(tokens[index - 1], token.offset)) {
+            index -= 2;
+            continue;
+        }
+        if (['>', ')', ']', '}'].includes(token.value)) {
+            closers.push(token.value);
+        }
+        else if (['<', '(', '[', '{'].includes(token.value)) {
+            const expected = token.value === '<' ? '>' : token.value === '(' ? ')' : token.value === '[' ? ']' : '}';
+            if (closers.pop() !== expected) {
+                break;
+            }
+            if (closers.length === 0) {
+                return index - 1;
+            }
+        }
+        else if (token.value === ';' &&
+            token.syntheticBoundary !== true &&
+            closers[closers.length - 1] === '>') {
+            break;
+        }
+        index--;
+    }
+    // The `>` does not close a balanced type-parameter list, so the token before `(` names the list.
+    return openIndex - 1;
+}
+/**
+ * Modifiers that may sit between a member separator and a method name.
+ *
+ * `new`, `typeof`, `void` and `await` are absent on purpose: they are operators, so an identifier
+ * after them belongs to an expression and never starts a member declaration.
+ */
+const MEMBER_MODIFIERS = new Set([
+    'abstract',
+    'async',
+    'get',
+    'override',
+    'private',
+    'protected',
+    'public',
+    'set',
+    'static',
+]);
+/** Punctuation that can start a member declaration inside an object literal, class body or interface. */
+const MEMBER_SEPARATORS = new Set(['{', ',', ';']);
+/**
+ * Index of the `@` that starts the decorator ending at `index`, or -1 when the tokens ending there
+ * are not a decorator. Only the tail of a decorator is known from the member side, so the
+ * LeftHandSideExpression of `@dec`, `@dec(1)`, `@a.b` and `@(dec)` is scanned backwards.
+ */
+function decoratorStartIndex(tokens, index) {
+    let depth = 0;
+    for (let k = index; k >= 0; k--) {
+        const token = tokens[k];
+        if (token === undefined) {
+            return -1;
+        }
+        if (token.kind !== 'punct') {
+            continue;
+        }
+        if (token.value === ')' || token.value === ']' || token.value === '}') {
+            depth++;
+        }
+        else if (token.value === '(' || token.value === '[' || token.value === '{') {
+            // An unmatched opener means the scan left the decorator expression.
+            if (depth === 0) {
+                return -1;
+            }
+            depth--;
+        }
+        else if (depth === 0) {
+            if (token.value === '@') {
+                return k;
+            }
+            // Only property access (`@a.b`, `@a?.b`) continues a decorator name.
+            if (token.value !== '.' && token.value !== '?') {
+                return -1;
+            }
+        }
+    }
+    return -1;
+}
+/**
+ * The async/generator flags of the member declaration whose name is the token at `nameIndex`, or
+ * `undefined` when no member declaration starts there.
+ *
+ * Class headers are bounded by the current member's forward-tracked start. Objects use explicit
+ * separators, never class-field ASI. Only modifiers and decorators may precede the name.
+ */
+function memberDeclarationHead(tokens, nameIndex, insideClassBody, memberStart) {
+    // A computed member (`[key]() {}`) is named by the `]` that closes its key.
+    let index = nameIndex - 1;
+    if (isPunct(tokens[nameIndex], ']')) {
+        const open = matchingOpenBracket(tokens, nameIndex);
+        if (open < 0) {
+            return undefined;
+        }
+        index = open - 1;
+    }
+    let async = false;
+    let generator = false;
+    for (;;) {
+        while (index >= (memberStart ?? 0)) {
+            const token = tokens[index];
+            if (isPunct(token, '*') || isPunct(token, '#')) {
+                generator ||= isPunct(token, '*');
+                index--;
+                continue;
+            }
+            if (token?.kind === 'identifier') {
+                const nextToken = tokens[index + 1];
+                const startsMethodModifier = nextToken !== undefined && nextToken.lineBreakBefore !== true;
+                if (token.value === 'async' && startsMethodModifier) {
+                    async = true;
+                    index--;
+                    continue;
+                }
+                if (MEMBER_MODIFIERS.has(token.value) && startsMethodModifier) {
+                    index--;
+                    continue;
+                }
+            }
+            break;
+        }
+        if (insideClassBody && memberStart !== undefined && index < memberStart) {
+            return { async, generator };
+        }
+        const start = tokens[index];
+        if (start?.kind === 'punct' &&
+            (MEMBER_SEPARATORS.has(start.value) ||
+                (start.value === '}' && start.memberSeparator === true))) {
+            return { async, generator };
+        }
+        // Decorators precede the modifiers they apply to, and each one ends just before them.
+        const decorator = decoratorStartIndex(tokens, index);
+        if (decorator < 0) {
+            return undefined;
+        }
+        index = decorator - 1;
+    }
+}
+function isPunct(token, value) {
+    return token?.kind === 'punct' && token.value === value;
+}
+function classifyEquals(source, offset, atTypeBoundary = false) {
+    const next = source[offset + 1];
+    const previous = source[offset - 1];
+    if (next === '>') {
+        return { operator: 'arrow', operatorEndOffset: offset + 2 };
+    }
+    if (next === '=' ||
+        (previous !== undefined &&
+            '=!<>+-*/%&|^?'.includes(previous) &&
+            !(atTypeBoundary && previous === '>'))) {
+        let end = offset + 1;
+        while (source[end] === '=') {
+            end++;
+        }
+        return { operator: 'other', operatorEndOffset: end };
+    }
+    return { operator: 'assignment', operatorEndOffset: offset + 1 };
+}
+function readIdentifier(source, start) {
+    let end = start;
+    let value = '';
+    let first = true;
+    while (end < source.length) {
+        const escaped = isUnicodeEscapeStart(source, end);
+        const segment = escaped ? readUnicodeEscape(source, end) : readCodePoint(source, end);
+        if (segment === undefined) {
+            break;
+        }
+        const allowed = first
+            ? isIdentifierStartCharacter(segment.character)
+            : isIdentifierPartCharacter(segment.character);
+        if (!allowed) {
+            if (escaped) {
+                throw new ModuleSpecifierError('Invalid Unicode escape in identifier', 'invalid-source', end);
+            }
+            break;
+        }
+        value += segment.character;
+        end = segment.end;
+        first = false;
+    }
+    if (first) {
+        throw new ModuleSpecifierError('Invalid identifier', 'invalid-source', start);
+    }
+    return { value, end };
+}
+function isArrowHead(token, greaterOffset) {
+    return (token?.kind === 'punct' &&
+        token.operator === 'arrow' &&
+        (greaterOffset === undefined || token.operatorEndOffset === greaterOffset + 1));
+}
+function lineBreakBetween(tokens, start, end) {
+    for (let index = start + 1; index <= end; index++) {
+        if (tokens[index]?.lineBreakBefore === true) {
+            return true;
+        }
+    }
+    return false;
+}
+function isMemberExpressionEnd(token) {
+    if (token.assertionEnd === true) {
+        return true;
+    }
+    if (token.kind === 'identifier') {
+        return (token.propertyName === true ||
+            (!REGEX_PRECEDING_KEYWORDS.has(token.value) && !['await', 'yield'].includes(token.value)));
+    }
+    return (EXPRESSION_ENDING.has(token.kind) ||
+        isPunct(token, ')') ||
+        isPunct(token, ']') ||
+        (token.kind === 'punct' && token.expressionEnd === true));
+}
+function advanceMember(member, token, previous) {
+    if (member.phase === 'initializer' || member.phase === 'parameters') {
+        return;
+    }
+    if (isPunct(token, '@')) {
+        member.phase = 'decorator';
+        return;
+    }
+    if (member.phase === 'decorator') {
+        if (token.lineBreakBefore !== true &&
+            !isPunct(previous, ')') &&
+            !(previous?.kind === 'identifier' && token.kind === 'identifier')) {
+            return;
         }
-        // Line comment: it ends at any ECMAScript line terminator (LF, CR, LS or PS), not only `\n`.
-        if (ch === '/' && source[i + 1] === '/') {
-            i += 2;
-            while (i < n && !isLineTerminator(source[i])) {
-                i++;
-            }
-            continue;
+        member.phase = 'head';
+    }
+    if (token.kind === 'punct' && token.operator === 'assignment') {
+        member.phase = 'initializer';
+    }
+    else if (isPunct(token, ':')) {
+        member.phase = 'type';
+    }
+    else if (isPunct(token, '(') && member.phase !== 'type') {
+        member.phase = 'parameters';
+    }
+    else if (member.phase === 'head' &&
+        ((token.kind === 'identifier' &&
+            !MEMBER_MODIFIERS.has(token.value) &&
+            !['declare', 'readonly'].includes(token.value)) ||
+            token.kind === 'string' ||
+            token.kind === 'number' ||
+            isPunct(token, '['))) {
+        member.phase = 'field';
+    }
+}
+function classFieldCanEnd(member, previous, next, nextIdentifier) {
+    if (previous === undefined || member.phase === 'parameters' || member.phase === 'decorator') {
+        return false;
+    }
+    const canEnd = isMemberExpressionEnd(previous) ||
+        ((member.phase === 'field' || member.phase === 'head') &&
+            (previous.kind === 'identifier' || isPunct(previous, '?') || isPunct(previous, '!'))) ||
+        (member.phase === 'type' &&
+            ((previous.kind === 'identifier' && !TYPE_OPERAND_KEYWORDS.has(previous.value)) ||
+                isPunct(previous, '>') ||
+                isPunct(previous, '}')));
+    if (!canEnd) {
+        return false;
+    }
+    if (member.phase === 'initializer') {
+        return !expressionContinues(next, nextIdentifier);
+    }
+    // An uninitialized field cannot continue by multiplication. Type operators and suffixes can.
+    return !UNINITIALIZED_FIELD_CONTINUATIONS.has(next);
+}
+const UNINITIALIZED_FIELD_CONTINUATIONS = new Set([
+    '(',
+    '[',
+    '.',
+    '?',
+    '!',
+    '=',
+    ':',
+    '<',
+    '>',
+    '|',
+    '&',
+    ',',
+]);
+function atTypeRoot(type) {
+    return (type.parenDepth === 0 &&
+        type.bracketDepth === 0 &&
+        type.braceDepth === 0 &&
+        type.angleDepth === 0);
+}
+function sameTypeDepth(left, right) {
+    return (left.parenDepth === right.parenDepth &&
+        left.bracketDepth === right.bracketDepth &&
+        left.braceDepth === right.braceDepth &&
+        left.angleDepth === right.angleDepth);
+}
+/**
+ * Infer an arrow signature using the index of `=` in `=>`, regardless of whether `>` is emitted.
+ */
+function inferArrowContext(tokens, arrowIndex) {
+    const arrow = tokens[arrowIndex];
+    if (!isArrowHead(arrow)) {
+        return undefined;
+    }
+    const beforeArrow = arrowIndex - 1;
+    const parameters = tokens[beforeArrow];
+    let parametersIndex;
+    if (parameters?.kind === 'punct' && parameters.value === ')') {
+        parametersIndex = matchingOpenParen(tokens, beforeArrow);
+    }
+    else if (parameters?.kind === 'identifier') {
+        parametersIndex = beforeArrow;
+    }
+    else {
+        return undefined;
+    }
+    const parametersStart = parametersIndex >= 0 ? tokens[parametersIndex] : undefined;
+    if (parametersStart?.kind !== 'identifier' && parametersStart?.kind !== 'punct') {
+        return undefined;
+    }
+    // Only trivia before the parameters can break the async modifier; newlines inside `(...)` cannot.
+    // A generic arrow keeps its type-parameter list between `async` and the parameter list.
+    const markerIndex = parametersStart.kind === 'punct' && parametersStart.value === '('
+        ? signatureNameIndex(tokens, parametersIndex)
+        : parametersIndex - 1;
+    const markerToken = tokens[markerIndex];
+    const async = markerToken?.kind === 'identifier' &&
+        markerToken.value === 'async' &&
+        asyncModifierIsContinuous(tokens, markerIndex, parametersIndex);
+    return {
+        async,
+        generator: false,
+        isExpression: false,
+    };
+}
+function parameterSignatureContext(tokens, pending, insideMethodContainer, insideClassBody, lineBreakBefore, memberStart) {
+    const openIndex = tokens.length;
+    const nameIndex = signatureNameIndex(tokens, openIndex);
+    const name = tokens[nameIndex];
+    const head = insideMethodContainer && isMethodName(name)
+        ? memberDeclarationHead(tokens, nameIndex, insideClassBody, memberStart)
+        : undefined;
+    if (head !== undefined) {
+        return {
+            context: {
+                ...head,
+                isExpression: false,
+                isClassMember: insideClassBody,
+            },
+            isFunctionKeyword: false,
+            isArrowSignature: false,
+        };
+    }
+    if (pending?.phase === 'awaiting-parameters' &&
+        (name?.kind === 'identifier' || isPunct(name, '*'))) {
+        return { context: pending, isFunctionKeyword: true, isArrowSignature: false };
+    }
+    const marker = tokens[nameIndex - 1];
+    // A generic signature has no name of its own before `(` when it is anonymous (`async <T,>(v: T) => {}`).
+    const startsArrowParameters = openIndex === 0 ||
+        (isIdentifier(name, 'async') &&
+            (openIndex === 1 ||
+                (marker?.kind === 'punct' && ['=', '(', '[', ',', ':'].includes(marker.value)) ||
+                isIdentifier(marker, 'return'))) ||
+        (name?.kind === 'punct' && ['=', '(', '[', ',', ':'].includes(name.value));
+    if (startsArrowParameters) {
+        const asyncToken = name?.kind === 'identifier' && name.value === 'async' ? name : undefined;
+        const async = asyncToken !== undefined &&
+            !lineBreakBefore &&
+            asyncModifierIsContinuous(tokens, nameIndex, openIndex - 1);
+        return {
+            context: { async, generator: false, isExpression: false },
+            isFunctionKeyword: false,
+            isArrowSignature: true,
+        };
+    }
+    // Without a `function` keyword the parameter list must start a real member declaration, so the
+    // `:` of a conditional expression or of an unrelated expression never claims a return annotation.
+    return undefined;
+}
+function asyncModifierIsContinuous(tokens, modifierIndex, parameterIndex) {
+    const genericOpen = isPunct(tokens[modifierIndex + 1], '<') ? modifierIndex + 1 : undefined;
+    return !lineBreakBetween(tokens, modifierIndex, genericOpen ?? parameterIndex);
+}
+function nearestFunctionParameter(parameters) {
+    for (let index = parameters.length - 1; index >= 0; index--) {
+        const parameter = parameters[index];
+        if (parameter?.signature !== undefined) {
+            return parameter;
         }
-        // Block comment. Comments are transparent to the regex/division heuristic, so a comment between
-        // a control keyword and its `(` behaves exactly like whitespace.
-        if (ch === '/' && source[i + 1] === '*') {
-            i = skipBlockComment(source, i);
-            continue;
+    }
+    return undefined;
+}
+function nearestClassField(braces) {
+    for (let index = braces.length - 1; index >= 0; index--) {
+        const brace = braces[index];
+        if (brace?.role === 'class' && brace.state.member?.phase === 'initializer') {
+            return brace.state.member;
         }
-        // A backtick in code mode opens a (possibly nested) template literal.
-        if (ch === '`') {
-            templateStart = i;
-            inText = true;
-            prevKind = 'template';
-            i++;
+    }
+    return undefined;
+}
+function consumeForIterationSeparator(tokens, parameters, depth) {
+    const control = parameters[parameters.length - 1];
+    if (control?.forPhase !== 'binding' ||
+        control.depth.parenDepth !== depth.parenDepth ||
+        control.depth.bracketDepth !== depth.bracketDepth ||
+        control.depth.braceDepth !== depth.braceDepth ||
+        control.depth.frameDepth !== depth.frameDepth ||
+        tokens.length <= control.openIndex) {
+        return false;
+    }
+    const previous = tokens[tokens.length - 1];
+    const isSeparator = previous !== undefined &&
+        isMemberExpressionEnd(previous) &&
+        !isIdentifier(previous, 'const') &&
+        !isIdentifier(previous, 'let') &&
+        !isIdentifier(previous, 'var');
+    if (isSeparator) {
+        control.forPhase = 'iteration';
+    }
+    return isSeparator;
+}
+// At the owner's root, a finished operand can still have a suffix or compose with another
+// type. Only a runtime boundary retires the assertion; internal closers never do so themselves.
+function assertionTypeContinues(annotation, next, identifier, lineBreak, after) {
+    if (next === '-' && annotation.typeOperandExpected && after !== '-') {
+        return true;
+    }
+    if (identifier !== undefined) {
+        return annotation.typeOperandExpected || (identifier === 'extends' && !lineBreak);
+    }
+    if (next === '?') {
+        return annotation.conditionalOperand;
+    }
+    if (next === ':') {
+        return annotation.conditionalDepth > 0;
+    }
+    if (next === '(') {
+        return annotation.typeOperandExpected || annotation.importCallPending;
+    }
+    if (next === '{' || next === '`' || next === "'" || next === '"') {
+        return annotation.typeOperandExpected;
+    }
+    if (next === '<' || next === '[') {
+        return after !== next && after !== '=' && (annotation.typeOperandExpected || !lineBreak);
+    }
+    if (next === '|' || next === '&') {
+        return after !== next && after !== '=';
+    }
+    if (next === '.') {
+        return true;
+    }
+    if (next === '=' && after === '>') {
+        return true;
+    }
+    return (annotation.typeOperandExpected &&
+        !['/', '+', '-', '*', '%', '!', ';', ',', ')', ']', '}', '=', '>'].includes(next));
+}
+function canStartTypeAssertion(previous) {
+    if (previous?.assertionEnd === true) {
+        return true;
+    }
+    return (previous !== undefined &&
+        isMemberExpressionEnd(previous) &&
+        !(previous.kind === 'identifier' &&
+            previous.propertyName !== true &&
+            [
+                'const',
+                'let',
+                'var',
+                'function',
+                'class',
+                'type',
+                'interface',
+                'namespace',
+                'import',
+                'export',
+                'extends',
+                'implements',
+            ].includes(previous.value)));
+}
+function isMethodName(token) {
+    return (token?.kind === 'identifier' ||
+        token?.kind === 'string' ||
+        token?.kind === 'number' ||
+        isPunct(token, ']'));
+}
+function expressionFunctionBodyEnded(ch, parenDepth, bracketDepth, braceDepth, frameDepth, functionDepth, conditionalDepth, context) {
+    if (functionDepth > context.functionDepth ||
+        braceDepth > context.braceDepth ||
+        frameDepth !== context.frameDepth) {
+        return false;
+    }
+    if (ch === ':' &&
+        context.conditionalDepth > 0 &&
+        conditionalDepth === context.conditionalDepth &&
+        parenDepth === context.parenDepth &&
+        bracketDepth === context.bracketDepth &&
+        braceDepth === context.braceDepth) {
+        return true;
+    }
+    if (ch === ';' || ch === ',') {
+        return (parenDepth === context.parenDepth &&
+            bracketDepth === context.bracketDepth &&
+            braceDepth === context.braceDepth);
+    }
+    if (ch === ')' || ch === ']' || ch === '}') {
+        return (parenDepth === context.parenDepth &&
+            bracketDepth === context.bracketDepth &&
+            braceDepth === context.braceDepth);
+    }
+    return false;
+}
+function lineTerminatorEndsExpressionFunctionBody(next, prevKind, prevPunct, previous, nextIdentifier, nextIsUpdate, parenDepth, bracketDepth, braceDepth, frameDepth, functionDepth, context) {
+    if (functionDepth > context.functionDepth ||
+        parenDepth !== context.parenDepth ||
+        bracketDepth !== context.bracketDepth ||
+        braceDepth !== context.braceDepth ||
+        frameDepth !== context.frameDepth) {
+        return false;
+    }
+    const previousEndsExpression = previous?.assertionEnd === true ||
+        EXPRESSION_ENDING.has(prevKind) ||
+        (prevKind === 'punct' &&
+            ([')', ']', '}'].includes(prevPunct ?? '') ||
+                (previous?.kind === 'punct' && previous.expressionEnd === true)));
+    return previousEndsExpression && (nextIsUpdate || !expressionContinues(next, nextIdentifier));
+}
+function expressionContinues(next, identifier) {
+    return (EXPRESSION_CONTINUATION_CHARACTERS.has(next) ||
+        identifier === 'in' ||
+        identifier === 'instanceof');
+}
+/** Whether a token is the given identifier. */
+function isIdentifier(token, value) {
+    return token?.kind === 'identifier' && token.value === value;
+}
+/**
+ * The index of the `[` matching the `]` at `closeIndex`, or `-1` when the source has no match.
+ */
+function matchingOpenBracket(tokens, closeIndex) {
+    let depth = 0;
+    for (let k = closeIndex; k >= 0; k--) {
+        const token = tokens[k];
+        if (token?.kind !== 'punct') {
             continue;
         }
-        // A `}` in code mode closes the innermost open `${...}` expression only when that expression has
-        // no open braces of its own; otherwise it is an ordinary brace inside the expression.
-        if (ch === '}') {
-            const depth = braceDepths[braceDepths.length - 1];
-            if (depth !== undefined) {
-                if (depth === 0) {
-                    braceDepths.pop();
-                    i++;
-                    inText = true;
-                    resetExpressionState();
-                    continue;
-                }
-                braceDepths[braceDepths.length - 1] = depth - 1;
-            }
-            // Otherwise `}` is an ordinary brace: it ends an expression only when it closed an object
-            // literal. An unmatched `}` (an empty context) keeps the statement-block behaviour.
-            closedObjectBrace = braceContexts.pop() === true;
+        if (token.value === ']') {
+            depth++;
         }
-        // `/` is a regex when it can start an expression, otherwise it is division.
-        if (ch === '/') {
-            if (isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword, afterControlHead, closedObjectBrace)) {
-                i = skipRegex(source, i);
-                prevKind = 'regex';
-                afterControlHead = false;
-                pendingControlKeyword = undefined;
-                continue;
+        else if (token.value === '[') {
+            depth--;
+            if (depth === 0) {
+                return k;
             }
-            tokens.push({ kind: 'punct', value: '/', offset: i });
-            prevKind = 'punct';
-            prevPunct = '/';
-            afterControlHead = false;
-            pendingControlKeyword = undefined;
-            i++;
-            continue;
-        }
-        // String literals (single or double quoted).
-        if (ch === "'" || ch === '"') {
-            const { value, next } = readString(source, i);
-            tokens.push({ kind: 'string', value, offset: i });
-            prevKind = 'string';
-            afterControlHead = false;
-            pendingControlKeyword = undefined;
-            i = next;
-            continue;
         }
-        // Identifiers.
-        if (isIdentifierStart(ch)) {
-            const start = i;
-            i++;
-            while (i < n) {
-                const part = source[i];
-                if (part === undefined || !isIdentifierPart(part)) {
-                    break;
-                }
-                i++;
-            }
-            const value = source.slice(start, i);
-            prevIdentifier = value;
-            // A keyword after `.` is a property name (e.g. `x.return`), not an expression start.
-            prevIsExpressionKeyword =
-                REGEX_PRECEDING_KEYWORDS.has(value) && !(prevKind === 'punct' && prevPunct === '.');
-            // Remember a control-statement keyword until its `(` is seen so only that head's `)` may be
-            // followed by a regex literal.
-            pendingControlKeyword = pendingControlKeywordAfter(value, 
-            // After `.` the identifier is a property name (e.g. `obj.if(...)`), never a control head.
-            prevKind === 'punct' && prevPunct === '.', pendingControlKeyword);
-            tokens.push({ kind: 'identifier', value, offset: start });
-            prevKind = 'identifier';
-            afterControlHead = false;
+    }
+    return -1;
+}
+/**
+ * The index of the `(` matching the `)` at `closeIndex`, or `-1` when the source has no match.
+ */
+function matchingOpenParen(tokens, closeIndex) {
+    const close = tokens[closeIndex];
+    if (close?.kind === 'punct' && close.matchingOpen !== undefined) {
+        return close.matchingOpen;
+    }
+    let depth = 0;
+    for (let k = closeIndex; k >= 0; k--) {
+        const token = tokens[k];
+        if (token?.kind !== 'punct') {
             continue;
         }
-        // Numbers end an expression, so they affect the regex/division decision.
-        if (isNumberStart(ch)) {
-            const start = i;
-            i++;
-            while (i < n) {
-                const part = source[i];
-                if (part === undefined || !(isIdentifierPart(part) || part === '.')) {
-                    break;
-                }
-                i++;
-            }
-            tokens.push({ kind: 'number', offset: start });
-            prevKind = 'number';
-            afterControlHead = false;
-            pendingControlKeyword = undefined;
-            continue;
+        if (token.value === ')') {
+            depth++;
         }
-        // Any other single character is punctuation.
-        if (ch === '{') {
-            // Record what this brace opens, so its `}` knows whether an expression or a statement ended.
-            // The enclosing entry is inspected before pushing, so a `:` knows if it separates a property.
-            braceContexts.push(opensObjectLiteral(prevKind, prevPunct, prevIdentifier, prevIsExpressionKeyword, braceDepths.length > 0, braceContexts[braceContexts.length - 1] === true));
-            // Count the brace inside the innermost open `${...}` expression so its closing `}` is found.
-            const depth = braceDepths[braceDepths.length - 1];
-            if (depth !== undefined) {
-                braceDepths[braceDepths.length - 1] = depth + 1;
+        else if (token.value === '(') {
+            depth--;
+            if (depth === 0) {
+                return k;
             }
         }
-        else if (ch === '(') {
-            // A `(` after a control keyword opens a control head; only its matching `)` may then be
-            // followed by a regex literal, so the nesting depth of every `(` has to be tracked.
-            parenDepth++;
-            if (pendingControlKeyword !== undefined) {
-                controlParenDepth = parenDepth;
-                pendingControlKeyword = undefined;
-            }
-            afterControlHead = false;
+    }
+    return -1;
+}
+/** Claim the most recent class header at this exact depth; nested heritage classes claim first. */
+function takeClassBodyContext(contexts, depth) {
+    for (let index = contexts.length - 1; index >= 0; index--) {
+        const context = contexts[index];
+        if (context?.parenDepth === depth.parenDepth &&
+            context.bracketDepth === depth.bracketDepth &&
+            context.braceDepth === depth.braceDepth &&
+            context.frameDepth === depth.frameDepth) {
+            contexts.splice(index, 1);
+            return context;
         }
-        else if (ch === ')') {
-            afterControlHead = controlParenDepth !== undefined && parenDepth === controlParenDepth;
-            if (afterControlHead) {
-                controlParenDepth = undefined;
-            }
-            if (parenDepth > 0) {
-                parenDepth--;
-            }
+    }
+    return undefined;
+}
+/**
+ * Read a JSX tag name starting at `i` (the first character after `<`). Member expressions
+ * (`<UI.Panel>`), namespaced names (`<svg:rect>`) and dashed names (`<my-tag>`) are part of the name.
+ */
+function readJsxTagName(source, i, n) {
+    const start = i;
+    while (i < n) {
+        const ch = source[i];
+        if (ch === undefined ||
+            !(isIdentifierPartAt(source, i) || ch === '.' || ch === '-' || ch === ':')) {
+            break;
         }
-        tokens.push({ kind: 'punct', value: ch, offset: i });
-        prevKind = 'punct';
-        prevPunct = ch;
-        i++;
+        i += codePointLength(source, i);
     }
-    // Reaching the end of the source while inside a template text or an open `${...}` expression means
-    // the template literal was never closed.
-    if (inText || braceDepths.length > 0) {
-        throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', templateStart);
+    return { name: source.slice(start, i), end: i };
+}
+/**
+ * Skip a quoted JSX attribute value starting at its opening quote. The value is inert text: it ends
+ * at the matching quote and backslashes are not escapes, so it can never contribute a specifier.
+ */
+function skipJsxAttributeValue(source, i, n) {
+    const quote = source[i];
+    let k = i + 1;
+    while (k < n && source[k] !== quote) {
+        k++;
     }
-    return tokens;
+    if (k >= n) {
+        throw new ModuleSpecifierError('Unterminated JSX attribute value', 'invalid-source', i);
+    }
+    return k + 1;
 }
 /**
  * Significant token kinds that clearly terminate an expression. After one of these, `/` is
@@ -308,6 +2326,29 @@ const EXPRESSION_ENDING = new Set([
     'template',
     'regex',
 ]);
+// A token beginning with one of these characters may continue an expression across a line
+// terminator, so ASI must not retire an expression-bodied arrow before it.
+const EXPRESSION_CONTINUATION_CHARACTERS = new Set([
+    '.',
+    '(',
+    '[',
+    '?',
+    ':',
+    ',',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '>',
+    '=',
+    '!',
+    '&',
+    '|',
+    '^',
+    '`',
+]);
 /**
  * Expression-starting keywords. After one of these, a `/` begins a regex literal even though the
  * keyword itself is tokenized as an identifier. `of`, `yield` and `await` are intentionally
@@ -355,9 +2396,8 @@ function pendingControlKeywordAfter(value, isMemberName, pending) {
  * expression on its right: assignment (`= {`), an argument or element list (`f({`, `[{`) and the
  * separators and binary/logical operators. `>` is absent because it usually ends an arrow function
  * (`() => {}`), whose `{` opens a function body, and `)`/`}` are absent because they close
- * statement heads and blocks. `:` is decided separately, in {@link opensObjectLiteral}, because it
- * is a property separator inside an object literal but a label or `case`/`default` separator
- * otherwise.
+ * statement heads and blocks. `:` is classified separately using property/conditional depth,
+ * because labels and `case`/`default` clauses instead introduce statements.
  */
 const EXPRESSION_BEFORE_BRACE = new Set([
     '=',
@@ -377,26 +2417,41 @@ const EXPRESSION_BEFORE_BRACE = new Set([
 ]);
 // Keywords that start an expression but are still followed by a statement block.
 const BLOCK_AFTER_KEYWORD = new Set(['else', 'do']);
+// Whether a `function` keyword sits in expression position (a function expression used as a value,
+// so a slash after its body `{}` divides) rather than statement position (a declaration, so a slash
+// after its body may start a regex). The previous significant token must expect an expression on
+// its right: an expression-starting punctuation, an expression keyword, or a regex.
+function functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression) {
+    if (prevKind === 'punct') {
+        return prevPunct === ':' ? colonIsExpression : EXPRESSION_BEFORE_BRACE.has(prevPunct ?? '');
+    }
+    if (prevKind === 'identifier') {
+        return REGEX_PRECEDING_KEYWORDS.has(previousIdentifier ?? '');
+    }
+    return prevKind === 'regex';
+}
 /**
  * Whether a `{` opens an expression (an object literal or a destructuring pattern) instead of a
- * statement block or function body. `enclosingIsObjectLiteral` reports what the enclosing `{`, if
- * any, opened. Statement position is the default, so an unknown context keeps the existing
+ * statement block or function body. `colonIsExpression` distinguishes property/conditional colons
+ * from statement separators. Statement position is the default, so an unknown context keeps the existing
  * behaviour of allowing a regex literal after the matching `}`.
  */
-function opensObjectLiteral(prevKind, prevPunct, prevIdentifier, prevIsExpressionKeyword, inTemplateExpression, enclosingIsObjectLiteral) {
+function opensObjectLiteral(prevKind, prevPunct, prevIdentifier, prevIsExpressionKeyword, inTemplateExpression, colonIsExpression, lineBreakBefore) {
     if (prevKind === 'punct') {
         // Inside an object literal a `:` separates a property from its value (`{ scale: {} }`, where a
         // following `/` divides), while at statement level the same `:` follows a label
         // (`label: {}`) or a `case`/`default` clause, whose `{` opens a block.
         if (prevPunct === ':') {
-            return enclosingIsObjectLiteral;
+            return colonIsExpression;
         }
         return EXPRESSION_BEFORE_BRACE.has(prevPunct ?? '');
     }
     if (prevKind === 'identifier') {
         // `return {` is an expression, `else {`/`do {` are blocks and every other identifier
         // (`function f`, `class C`) sits in statement position.
-        return prevIsExpressionKeyword && !BLOCK_AFTER_KEYWORD.has(prevIdentifier ?? '');
+        return (prevIsExpressionKeyword &&
+            !BLOCK_AFTER_KEYWORD.has(prevIdentifier ?? '') &&
+            !(prevIdentifier === 'return' && lineBreakBefore));
     }
     // Right after `${` an expression is expected, so a `{` opens an object literal.
     return inTemplateExpression && prevKind === 'start';
@@ -409,7 +2464,16 @@ function opensObjectLiteral(prevKind, prevPunct, prevIdentifier, prevIsExpressio
  * what it closed: an object literal ends an expression, so the `/` divides, while a statement block
  * leaves the expression-start position, where a regex literal may begin.
  */
-function isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword, afterControlHead, closedObjectBrace) {
+function isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword, afterControlHead, closedObjectBrace, previous) {
+    if (previous?.assertionEnd === true) {
+        return false;
+    }
+    if (previous?.kind === 'punct' && previous.value !== '}' && previous.expressionEnd === true) {
+        return false;
+    }
+    if (previous?.kind === 'punct' && (previous.value === '++' || previous.value === '--')) {
+        return previous.expressionEnd !== true;
+    }
     if (prevKind === 'identifier' && prevIsExpressionKeyword) {
         return true;
     }
@@ -467,11 +2531,30 @@ function interpret(tokens) {
  * - `import 'pkg'` and `import ... from 'pkg'` are `import`.
  * - `import('pkg')` is `dynamic-import` only when the sole argument is a static string.
  */
-function handleImport(tokens, i, occurrences) {
+/**
+ * Whether the identifier at `i` is a property name (`obj.require`), which is never the global
+ * `require`/`import`. A `.` that belongs to a spread (`...require('pkg')`) is not member access.
+ */
+function isMemberName(tokens, i) {
     const prev = tokens[i - 1];
+    if (prev?.kind === 'punct' && prev.value === '#') {
+        return true;
+    }
+    if (prev?.kind !== 'punct' || prev.value !== '.') {
+        return false;
+    }
+    const second = tokens[i - 2];
+    const third = tokens[i - 3];
+    const isSpread = second?.kind === 'punct' &&
+        second.value === '.' &&
+        third?.kind === 'punct' &&
+        third.value === '.';
+    return !isSpread;
+}
+function handleImport(tokens, i, occurrences) {
     const next = tokens[i + 1];
     // `obj.import(...)`: a member call, not the import keyword.
-    if (prev?.kind === 'punct' && prev.value === '.') {
+    if (isMemberName(tokens, i)) {
         return i + 1;
     }
     // `import.meta` / `import .foo`: not a module import.
@@ -509,6 +2592,18 @@ function handleExport(tokens, i, occurrences) {
  */
 function scanImportSource(tokens, i, occurrences, kind) {
     const n = tokens.length;
+    if (kind === 'export-from') {
+        const sourceIndex = exportSourceIndex(tokens, i);
+        if (sourceIndex === undefined) {
+            return i + 1;
+        }
+        const source = tokens[sourceIndex];
+        if (source?.kind === 'string') {
+            occurrences.push({ specifier: source.value, kind });
+            return sourceIndex + 1;
+        }
+        return i + 1;
+    }
     let j = i + 1;
     // How many `{ ... }` named clauses of the current statement are open. `import`/`export` are legal
     // binding names inside such a clause (e.g. `import { export as v } from 'pkg'`), so they may only
@@ -545,14 +2640,47 @@ function scanImportSource(tokens, i, occurrences, kind) {
     // No source found; keep scanning from the next token.
     return i + 1;
 }
+function exportSourceIndex(tokens, exportIndex) {
+    let index = exportIndex + 1;
+    if (isIdentifier(tokens[index], 'type')) {
+        index++;
+    }
+    if (isPunct(tokens[index], '*')) {
+        index++;
+        if (isIdentifier(tokens[index], 'as')) {
+            index += 2;
+        }
+    }
+    else if (isPunct(tokens[index], '{')) {
+        let depth = 1;
+        index++;
+        while (index < tokens.length && depth > 0) {
+            if (isPunct(tokens[index], '{')) {
+                depth++;
+            }
+            else if (isPunct(tokens[index], '}')) {
+                depth--;
+            }
+            index++;
+        }
+        if (depth !== 0) {
+            return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+    return isIdentifier(tokens[index], 'from') && tokens[index + 1]?.kind === 'string'
+        ? index + 1
+        : undefined;
+}
 /**
  * Handle a `require` identifier. `obj.require(...)` is ignored (preceded by `.`).
  * `require('pkg')` is `require` only when the sole argument is a static string.
  */
 function handleRequire(tokens, i, occurrences) {
-    const prev = tokens[i - 1];
     // `obj.require(...)`: not the global CommonJS require.
-    if (prev?.kind === 'punct' && prev.value === '.') {
+    if (isMemberName(tokens, i)) {
         return i + 1;
     }
     const next = tokens[i + 1];
@@ -803,7 +2931,7 @@ function isWhitespace(ch) {
         ch === '\f' ||
         ch === '\uFEFF' ||
         isLineTerminator(ch) ||
-        SPACE_SEPARATOR.test(ch));
+        (ch !== undefined && SPACE_SEPARATOR.test(ch)));
 }
 /**
  * The ECMAScript `LineTerminator` characters. Line comments and the hashbang end at any of them,
@@ -812,11 +2940,62 @@ function isWhitespace(ch) {
 function isLineTerminator(ch) {
     return ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029';
 }
-function isIdentifierStart(ch) {
-    return /[A-Za-z_$]/.test(ch);
+const IDENTIFIER_START = /^[$_\p{ID_Start}]$/u;
+const IDENTIFIER_PART = /^[$_\u200C\u200D\p{ID_Continue}]$/u;
+function isIdentifierStartAt(source, index) {
+    const codePoint = readCodePoint(source, index);
+    return codePoint !== undefined && isIdentifierStartCharacter(codePoint.character);
+}
+function isIdentifierPartAt(source, index) {
+    const codePoint = readCodePoint(source, index);
+    return codePoint !== undefined && isIdentifierPartCharacter(codePoint.character);
+}
+function isIdentifierStartCharacter(character) {
+    return IDENTIFIER_START.test(character);
+}
+function isIdentifierPartCharacter(character) {
+    return IDENTIFIER_PART.test(character);
+}
+function codePointLength(source, index) {
+    return (source.codePointAt(index) ?? 0) > 0xffff ? 2 : 1;
+}
+function readCodePoint(source, index) {
+    const point = source.codePointAt(index);
+    if (point === undefined) {
+        return undefined;
+    }
+    const end = index + (point > 0xffff ? 2 : 1);
+    return { character: String.fromCodePoint(point), end };
+}
+function isUnicodeEscapeStart(source, index) {
+    return source[index] === '\\' && source[index + 1] === 'u';
 }
-function isIdentifierPart(ch) {
-    return /[A-Za-z0-9_$]/.test(ch);
+function readUnicodeEscape(source, start) {
+    let end = start + 2;
+    let digits;
+    if (source[end] === '{') {
+        const digitsStart = ++end;
+        while (end < source.length && /[0-9A-Fa-f]/.test(source[end] ?? '')) {
+            end++;
+        }
+        if (end === digitsStart || source[end] !== '}' || end - digitsStart > 6) {
+            throw new ModuleSpecifierError('Invalid Unicode escape in identifier', 'invalid-source', start);
+        }
+        digits = source.slice(digitsStart, end);
+        end++;
+    }
+    else {
+        digits = source.slice(end, end + 4);
+        if (digits.length !== 4 || !/^[0-9A-Fa-f]{4}$/.test(digits)) {
+            throw new ModuleSpecifierError('Invalid Unicode escape in identifier', 'invalid-source', start);
+        }
+        end += 4;
+    }
+    const value = Number.parseInt(digits, 16);
+    if (value > 0x10ffff) {
+        throw new ModuleSpecifierError('Invalid Unicode escape in identifier', 'invalid-source', start);
+    }
+    return { character: String.fromCodePoint(value), end };
 }
 function isNumberStart(ch) {
     return /[0-9]/.test(ch);