depvitals 0.2.0 → 0.4.0

package/dist/scanner/moduleSpecifiers.js

@@ -43,14 +43,55 @@ export class ModuleSpecifierError extends Error {
  *   from which the scanner cannot safely continue.
  */
 export function extractModuleSpecifiers(source, options = {}) {
-    return interpret(tokenize(source, options.jsx ?? false, options.module ?? false));
+    return collectModuleSpecifiers(source, options).map(({ specifier, kind }) => ({
+        specifier,
+        kind,
+    }));
+}
+/**
+ * Authoritative occurrence collector. The lexer must finish successfully before locations escape.
+ * Recognition is shared with the legacy projection above; no additional extraction is performed.
+ */
+export function collectModuleSpecifiers(source, options = {}) {
+    const jsx = options.jsx ?? false;
+    // Ambiguous input gets one non-interpreting lexical probe and one definitive extraction. No
+    // source reread, parser retry after an exception, or repeated per-statement suffix scans.
+    const module = options.module === 'detect'
+        ? tokenize(source, jsx, false, true).some((token) => token.moduleSignal === true)
+        : (options.module ?? false);
+    const occurrences = interpret(tokenize(source, jsx, module));
+    let cursor = 0;
+    let line = 1;
+    let column = 1;
+    // Interpreter output is in literal encounter order. Each original UTF-16 unit is visited at
+    // most once, except a bounded CRLF lookahead; no per-occurrence prefix/suffix scan is needed.
+    return occurrences.map(({ specifier, kind, offset }) => {
+        while (cursor < offset) {
+            const character = source[cursor++];
+            if (character === '\r') {
+                if (source[cursor] === '\n')
+                    cursor++;
+                line++;
+                column = 1;
+            }
+            else if (character === '\n' || character === '\u2028' || character === '\u2029') {
+                line++;
+                column = 1;
+            }
+            else {
+                column++;
+            }
+        }
+        return { specifier, kind, position: { offset, line, column } };
+    });
 }
 /**
  * Turn source into a stream of significant tokens, skipping whitespace, line/block comments, regex
  * literals and template literals.
  */
-function tokenize(source, jsx = false, module = false) {
+function tokenize(source, jsx = false, module = false, detectModule = false) {
     const tokens = [];
+    const typeArgumentBounds = new Map();
     const n = source.length;
     let i = 0;
     // Whether the previous identifier token is an expression-starting keyword (return, typeof, ...).
@@ -82,7 +123,14 @@ function tokenize(source, jsx = false, module = false) {
         if (memberAtToken !== undefined) {
             advanceMember(memberAtToken, significant, tokens[tokens.length - 1]);
         }
-        tokens.push(significant);
+        const scope = requireScopes[requireScopes.length - 1];
+        tokens.push(scope?.inParameters === true
+            ? {
+                ...significant,
+                parameterFrame: frames.length,
+                ...(typeAnnotation === undefined ? {} : { parameterType: true }),
+            }
+            : significant);
         if (token.kind !== 'punct' || token.syntheticBoundary !== true) {
             htmlCloseCommentAllowed = false;
         }
@@ -108,6 +156,19 @@ function tokenize(source, jsx = false, module = false) {
     // Function context of every open function body, tracked independently of expression frame resets
     // so `${}` boundaries cannot change the nearest await/yield grammar.
     const functionContextStack = [];
+    const requireScopes = [];
+    const closeRequireScope = (scope) => {
+        if (scope !== undefined && requireScopes[requireScopes.length - 1] === scope) {
+            requireScopes.pop();
+        }
+    };
+    const recordRequireBinding = (parameters, end) => {
+        const scope = parameters.signature?.context.requireScope;
+        const bindingEnd = parameters.bindingEnd ?? end;
+        if (scope !== undefined && parameters.bindingStart < bindingEnd) {
+            scope.bindings.push({ start: parameters.bindingStart, end: bindingEnd });
+        }
+    };
     // 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.
@@ -139,6 +200,12 @@ function tokenize(source, jsx = false, module = false) {
         frames.length === context.frameDepth;
     const insideObjectLiteral = () => braceContexts[braceContexts.length - 1]?.role === 'object';
     const insideClassBody = () => braceContexts[braceContexts.length - 1]?.role === 'class';
+    const atMethodContainer = () => {
+        const brace = braceContexts[braceContexts.length - 1];
+        return brace?.role === 'object'
+            ? atLexicalDepth(brace.depth)
+            : brace?.role === 'class' && atLexicalDepth(brace.state);
+    };
     const currentClass = () => {
         const brace = braceContexts[braceContexts.length - 1];
         return brace?.role === 'class' ? brace.state : undefined;
@@ -166,8 +233,8 @@ function tokenize(source, jsx = false, module = 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
+    // Template interpolations, JSX markup and sibling containers are separate expressions. An
+    // explicit boundary keeps the token stream from gluing them into an import/require sequence that
     // does not exist in source (for example `<p>{import}{('pkg')}</p>`).
     const pushBoundary = (offset) => {
         emit({
@@ -228,6 +295,8 @@ function tokenize(source, jsx = false, module = false) {
                         ? { typeOwner: { annotation: typeAnnotation, depth: { ...typeAnnotation } } }
                         : {}),
                 });
+                // The preceding tag is not the callee of tokens inside this interpolation.
+                pushBoundary(i);
                 inText = false;
                 resetExpressionState();
                 i += 2;
@@ -361,6 +430,35 @@ function tokenize(source, jsx = false, module = false) {
             typeAnnotation = undefined;
             inType = false;
         }
+        const expressionOwner = expressionFunctionContexts[expressionFunctionContexts.length - 1];
+        if (typeAnnotation === undefined &&
+            ch === '<' &&
+            prevKind === 'identifier' &&
+            expressionOwner !== undefined &&
+            atLexicalDepth(expressionOwner)) {
+            const end = expressionTypeArgumentEnd(source, i, n, typeArgumentBounds);
+            if (end !== undefined) {
+                // Use the ordinary type overlay: it preserves template imports and lexical scopes.
+                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,
+                };
+                inType = true;
+            }
+        }
         // 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];
@@ -369,7 +467,7 @@ function tokenize(source, jsx = false, module = false) {
             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();
+            closeRequireScope(expressionFunctionContexts.pop()?.requireScope);
             expressionFunctionContext = expressionFunctionContexts[expressionFunctionContexts.length - 1];
         }
         if (typeAnnotation?.role === 'return' &&
@@ -377,11 +475,15 @@ function tokenize(source, jsx = false, module = false) {
             atLexicalDepth(typeAnnotation.signature.owner) &&
             atTypeRoot(typeAnnotation) &&
             !typeAnnotation.typeOperandExpected &&
-            identifier !== undefined &&
-            (!TYPE_OPERAND_KEYWORDS.has(identifier.value) || identifier.value === 'const')) {
+            ((identifier !== undefined &&
+                (!TYPE_OPERAND_KEYWORDS.has(identifier.value) || identifier.value === 'const')) ||
+                (ch === '[' &&
+                    typeAnnotation.signature.context.isClassMember === true &&
+                    computedMethodFollows(source, i, n)))) {
             const signature = typeAnnotation.signature;
-            if (pendingFunctionContexts[pendingFunctionContexts.length - 1] === signature.context) {
-                pendingFunctionContexts.pop();
+            if (pendingFunctionContexts[pendingFunctionContexts.length - 1]?.requireScope ===
+                signature.context.requireScope) {
+                closeRequireScope(pendingFunctionContexts.pop()?.requireScope);
             }
             if (classState !== undefined && signature.context.isClassMember === true) {
                 classState.member = undefined;
@@ -389,6 +491,18 @@ function tokenize(source, jsx = false, module = false) {
             typeAnnotation = undefined;
             inType = false;
         }
+        const pendingBodylessSignature = pendingFunctionContexts[pendingFunctionContexts.length - 1];
+        if (pendingBodylessSignature?.phase === 'awaiting-body' &&
+            atLexicalDepth(pendingBodylessSignature) &&
+            ((typeAnnotation === undefined && tokenLineBreakBefore && ch !== '{' && ch !== ':') ||
+                (ch === '}' &&
+                    (typeAnnotation === undefined ||
+                        (typeAnnotation.role === 'return' && atTypeRoot(typeAnnotation)))))) {
+            closeRequireScope(pendingFunctionContexts.pop()?.requireScope);
+            typeAnnotation = undefined;
+            inType = false;
+            resetExpressionState();
+        }
         if (classState !== undefined &&
             atLexicalDepth(classState) &&
             (typeAnnotation === undefined ||
@@ -426,7 +540,7 @@ function tokenize(source, jsx = false, module = false) {
                 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();
+                closeRequireScope(expressionFunctionContexts.pop()?.requireScope);
                 context = expressionFunctionContexts[expressionFunctionContexts.length - 1];
             }
             lineTerminatorSinceLastToken = false;
@@ -556,7 +670,9 @@ function tokenize(source, jsx = false, module = false) {
                 typeAnnotation = undefined;
                 inType = false;
                 lineTerminatorSinceLastToken = false;
-                if (!annotation.signature.isFunctionKeyword) {
+                if (!annotation.signature.isFunctionKeyword &&
+                    pendingFunctionContexts[pendingFunctionContexts.length - 1]?.requireScope !==
+                        annotation.signature.context.requireScope) {
                     pendingFunctionContexts.push({
                         ...annotation.signature.context,
                         ...annotation.signature.owner,
@@ -569,7 +685,7 @@ function tokenize(source, jsx = false, module = false) {
                 atRoot &&
                 annotation.role === 'return' &&
                 annotation.signature.isArrowSignature &&
-                !functionTypeArrowContinues(source, i, n)) {
+                !functionTypeArrowContinues(source, i, n, conditional !== undefined && atLexicalDepth(conditional))) {
                 // The signature's own `=>`: everything after it is the body, not the return type.
                 typedArrowContext = annotation.signature.context;
                 typeAnnotation = undefined;
@@ -666,6 +782,7 @@ function tokenize(source, jsx = false, module = false) {
                     closed?.role === 'function' ||
                     closed?.role === 'class';
             if (closed?.role === 'function') {
+                closeRequireScope(closed.context.requireScope);
                 functionContextStack.pop();
             }
             if ((closed?.role === 'function' || closed?.role === 'static-block') &&
@@ -741,8 +858,17 @@ function tokenize(source, jsx = false, module = false) {
                 !afterControlHead &&
                 !prevIsExpressionKeyword &&
                 canStartTypeAssertion(tokens[tokens.length - 1]);
+            // Capture the enclosing operand grammar before this identifier replaces it. Contextual
+            // await/yield, an arrow head and a fresh embedded expression all expect an expression.
+            const expressionPosition = functionIsExpressionPosition(prevKind, prevPunct, colonIsExpression, (prevKind === 'identifier' &&
+                prevIsExpressionKeyword &&
+                !BLOCK_AFTER_KEYWORD.has(previousIdentifier ?? '') &&
+                !((previousIdentifier === 'return' || previousIdentifier === 'yield') &&
+                    tokenLineBreakBefore)) ||
+                (isPunct(tokens[tokens.length - 1], '>') && isArrowHead(tokens[tokens.length - 2])) ||
+                (prevKind === 'start' && (frame?.kind === 'template-expr' || frame?.kind === 'jsx-expr')));
             if (value === 'async') {
-                asyncFunctionIsExpression = functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression);
+                asyncFunctionIsExpression = expressionPosition;
                 if (isIdentifier(tokens[tokens.length - 1], 'default') &&
                     isIdentifier(tokens[tokens.length - 2], 'export')) {
                     asyncFunctionIsExpression = false;
@@ -750,8 +876,13 @@ function tokenize(source, jsx = false, module = false) {
             }
             prevIdentifier = value;
             const isMemberName = prevKind === 'punct' && prevPunct === '.';
+            const atRoot = braceContexts.length === 0 && parenDepth === 0 && bracketDepth === 0 && frames.length === 0;
+            let moduleSignal = detectModule &&
+                !isMemberName &&
+                ((value === 'import' && importSignalsModule(source, i, atRoot)) ||
+                    (value === 'export' && atRoot && exportSignalsModule(source, i)));
             const classMemberName = value === 'class' &&
-                (insideObjectLiteral() || insideClassBody()) &&
+                atMethodContainer() &&
                 memberDeclarationHead(tokens, tokens.length, insideClassBody(), currentClass()?.member?.start) !== undefined;
             const nextSignificant = skipTrivia(source, i, n);
             const classPropertyName = value === 'class' &&
@@ -769,10 +900,7 @@ function tokenize(source, jsx = false, module = false) {
                     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]))),
+                    isExpression: !isExportDefault && (previousIdentifier === 'extends' || expressionPosition),
                 });
             }
             // A keyword after `.` is a property name (e.g. `x.return`), not an expression start.
@@ -805,8 +933,19 @@ function tokenize(source, jsx = false, module = false) {
                 const functionContext = parameterGrammarSuspended || fieldGrammarSuspended
                     ? undefined
                     : (expressionContextIsCurrent ?? bodyContext);
+                const probe = detectModule &&
+                    value === 'await' &&
+                    !(prevKind === 'identifier' &&
+                        ['class', 'function', 'var', 'let', 'const', 'extends'].includes(previousIdentifier ?? '')) &&
+                    functionContext === undefined &&
+                    !parameterGrammarSuspended &&
+                    !fieldGrammarSuspended
+                    ? probeAwaitOperand(source, i, parameterContexts[parameterContexts.length - 1]?.forPhase !== undefined)
+                    : undefined;
+                moduleSignal ||= probe?.module === true;
                 if (value === 'await' &&
                     (functionContext?.async === true ||
+                        probe?.keyword === true ||
                         (functionContext === undefined &&
                             module &&
                             !parameterGrammarSuspended &&
@@ -826,20 +965,24 @@ function tokenize(source, jsx = false, module = false) {
             // 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()) &&
+                atMethodContainer() &&
                 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({
+                    requireScope: {
+                        parent: requireScopes[requireScopes.length - 1],
+                        bindings: [],
+                        inParameters: true,
+                    },
                     async: isAsync,
                     generator: false,
                     isExpression: isAsync
                         ? asyncFunctionIsExpression
                         : !(isIdentifier(tokens[tokens.length - 1], 'default') &&
-                            isIdentifier(tokens[tokens.length - 2], 'export')) &&
-                            functionIsExpressionPosition(prevKind, prevPunct, previousIdentifier, colonIsExpression),
+                            isIdentifier(tokens[tokens.length - 2], 'export')) && expressionPosition,
                     parenDepth,
                     bracketDepth,
                     braceDepth: braceContexts.length,
@@ -848,13 +991,42 @@ function tokenize(source, jsx = false, module = false) {
                     phase: 'awaiting-parameters',
                 });
             }
+            // A bare arrow parameter has no opening parenthesis to own its binding range.
+            const next = !inType && !isMemberName ? skipTrivia(source, i, n) : n;
+            const singleArrowContext = source[next] === '=' && source[next + 1] === '>'
+                ? {
+                    async: prevKind === 'identifier' &&
+                        previousIdentifier === 'async' &&
+                        !tokenLineBreakBefore,
+                    generator: false,
+                    isExpression: false,
+                    requireScope: {
+                        parent: requireScopes[requireScopes.length - 1],
+                        bindings: [{ start: tokens.length, end: tokens.length + 1 }],
+                        inParameters: false,
+                    },
+                }
+                : undefined;
+            if (singleArrowContext?.requireScope !== undefined) {
+                requireScopes.push(singleArrowContext.requireScope);
+            }
             emit({
                 kind: 'identifier',
                 value,
                 offset: start,
+                ...(singleArrowContext === undefined ? {} : { signatureContext: singleArrowContext }),
                 endOffset: i,
+                ...(value === 'require' && requireScopes.length > 0
+                    ? { requireScope: requireScopes[requireScopes.length - 1] }
+                    : {}),
                 ...(isMemberName ? { propertyName: true } : {}),
+                ...(moduleSignal ? { moduleSignal: true } : {}),
             });
+            // Once the mode is known, only the definitive module pass should validate the remainder.
+            // Continuing this probe with script grammar could reject valid newline await operands.
+            if (detectModule && moduleSignal) {
+                return tokens;
+            }
             if (startsAssertion) {
                 typeAnnotation = {
                     role: 'assertion',
@@ -940,6 +1112,7 @@ function tokenize(source, jsx = false, module = false) {
                     angleDepth: 0,
                     typeOperandExpected: true,
                 };
+                parameter.bindingEnd ??= tokens.length;
                 parameter.phase = 'type';
                 inType = true;
             }
@@ -1042,7 +1215,17 @@ function tokenize(source, jsx = false, module = false) {
                 braceContexts.push({ role: 'static-block', owner });
             }
             else {
-                braceContexts.push({ role: isObject ? 'object' : 'block' });
+                braceContexts.push(isObject
+                    ? {
+                        role: 'object',
+                        depth: {
+                            parenDepth,
+                            bracketDepth,
+                            braceDepth: braceContexts.length + 1,
+                            frameDepth: frames.length,
+                        },
+                    }
+                    : { role: 'block' });
             }
             // Count the brace inside the innermost open `${...}` or JSX `{...}` expression so its closing
             // `}` is found.
@@ -1054,18 +1237,38 @@ function tokenize(source, jsx = false, module = false) {
             // 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)
+            const signatureCandidate = parameterSignatureContext(tokens, pending !== undefined && atLexicalDepth(pending) ? pending : undefined, atMethodContainer(), insideClassBody(), tokenLineBreakBefore, currentClass()?.member?.start);
+            // A ternary's alternate may itself be an arrow. Its => is not proof that
+            // the consequent's parentheses were parameters: a typed arrow must still
+            // leave the enclosing conditional's colon after its own body.
+            const needsConditionalEnd = conditional !== undefined && atLexicalDepth(conditional);
+            const selectedSignature = signatureCandidate?.isArrowSignature === true &&
+                !arrowFollowsParametersSafely(source, i, n, jsx, needsConditionalEnd)
                 ? undefined
                 : signatureCandidate;
+            const signature = selectedSignature === undefined
+                ? undefined
+                : {
+                    ...selectedSignature,
+                    context: selectedSignature.context.requireScope !== undefined
+                        ? selectedSignature.context
+                        : {
+                            ...selectedSignature.context,
+                            requireScope: {
+                                parent: requireScopes[requireScopes.length - 1],
+                                bindings: [],
+                                inParameters: true,
+                            },
+                        },
+                };
+            if (signature?.context.requireScope !== undefined) {
+                requireScopes.push(signature.context.requireScope);
+            }
             parameterContexts.push({
                 openIndex: tokens.length,
+                bindingStart: tokens.length + 1,
+                bindingEnd: undefined,
+                bindingCommas: [],
                 signature: signature === undefined
                     ? undefined
                     : {
@@ -1111,8 +1314,25 @@ function tokenize(source, jsx = false, module = false) {
                 pending.phase = 'awaiting-body';
             }
             const parameters = parameterContexts.pop();
+            if (parameters?.signature !== undefined) {
+                recordRequireBinding(parameters, tokens.length);
+                const scope = parameters.signature.context.requireScope;
+                if (scope !== undefined) {
+                    scope.inParameters = false;
+                }
+            }
             matchingOpen = parameters?.openIndex;
             closedParameterSignature = parameters?.signature;
+            if (closedParameterSignature !== undefined &&
+                !closedParameterSignature.isFunctionKeyword &&
+                !closedParameterSignature.isArrowSignature) {
+                pendingFunctionContexts.push({
+                    ...closedParameterSignature.context,
+                    ...closedParameterSignature.owner,
+                    parameterDepth: undefined,
+                    phase: 'awaiting-body',
+                });
+            }
             afterControlHead = parameters?.control === true;
             if (parenDepth > 0) {
                 parenDepth--;
@@ -1148,17 +1368,15 @@ function tokenize(source, jsx = false, module = false) {
             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',
-                        });
-                    }
+                    pendingFunctionContexts.push({
+                        ...context,
+                        parenDepth,
+                        bracketDepth,
+                        braceDepth: braceContexts.length,
+                        frameDepth: frames.length,
+                        parameterDepth: undefined,
+                        phase: 'awaiting-body',
+                    });
                 }
                 else {
                     const parameterOwner = nearestFunctionParameter(parameterContexts);
@@ -1187,9 +1405,23 @@ function tokenize(source, jsx = false, module = false) {
         }
         if (!inType && parameter !== undefined && atLexicalDepth(parameter.depth)) {
             if (ch === ',') {
+                const scope = parameter.signature?.context.requireScope;
+                if (scope !== undefined) {
+                    parameter.bindingCommas.push({
+                        index: tokens.length,
+                        bindingStart: parameter.bindingStart,
+                        bindingEnd: parameter.bindingEnd,
+                        phase: parameter.phase,
+                        bindingCount: scope.bindings.length,
+                    });
+                }
+                recordRequireBinding(parameter, tokens.length);
+                parameter.bindingStart = tokens.length + 1;
+                parameter.bindingEnd = undefined;
                 parameter.phase = 'binding';
             }
             else if (equalsOperator?.operator === 'assignment') {
+                parameter.bindingEnd ??= tokens.length;
                 parameter.phase = 'initializer';
             }
         }
@@ -1205,9 +1437,10 @@ function tokenize(source, jsx = false, module = false) {
         }
         // A callback's statements cannot invalidate a signature outside its body or parameter list.
         if (!inType && ch === ';' && pending !== undefined && atLexicalDepth(pending)) {
-            pendingFunctionContexts.pop();
+            closeRequireScope(pendingFunctionContexts.pop()?.requireScope);
         }
         const previousToken = tokens[tokens.length - 1];
+        const openingSignature = ch === '(' ? parameterContexts[parameterContexts.length - 1]?.signature?.context : undefined;
         emit({
             kind: 'punct',
             value: ch,
@@ -1221,12 +1454,37 @@ function tokenize(source, jsx = false, module = false) {
                 ? { expressionEnd: true }
                 : {}),
             ...equalsOperator,
+            ...(openingSignature === undefined ? {} : { signatureContext: openingSignature }),
             ...(matchingOpen !== undefined ? { matchingOpen } : {}),
             ...(closedClassMemberBoundary || opensClassMemberBoundary || (ch === ';' && insideClassBody())
                 ? { memberSeparator: true }
                 : {}),
             ...(closedExpressionBrace ? { expressionEnd: true } : {}),
         });
+        if (!inType &&
+            ch === '>' &&
+            requireScopes[requireScopes.length - 1]?.inParameters === true &&
+            !isArrowHead(tokens[tokens.length - 2], i)) {
+            const start = markParameterTypeArguments(tokens, tokens.length);
+            const owner = parameterContexts[parameterContexts.length - 1];
+            const scope = owner?.signature?.context.requireScope;
+            if (start !== undefined && owner !== undefined && scope !== undefined) {
+                // Commas were provisional until the closing > established a type-argument list.
+                // Restore the initializer state as well as its binding ranges; do not re-lex source.
+                let first = owner.bindingCommas.length;
+                while (first > 0 && (owner.bindingCommas[first - 1]?.index ?? -1) >= start) {
+                    first--;
+                }
+                const checkpoint = owner.bindingCommas[first];
+                if (checkpoint !== undefined) {
+                    owner.bindingStart = checkpoint.bindingStart;
+                    owner.bindingEnd = checkpoint.bindingEnd;
+                    owner.phase = checkpoint.phase;
+                    scope.bindings.length = checkpoint.bindingCount;
+                    owner.bindingCommas.length = first;
+                }
+            }
+        }
         prevKind = 'punct';
         prevPunct = ch;
         i++;
@@ -1310,17 +1568,166 @@ function jsxTagIsGeneric(source, i, n) {
 // 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) {
+function arrowFollowsParameters(source, open, n, jsx = false, needsConditionalEnd = false, mode = 'parameters') {
     let depth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let conditionalDepth = 0;
+    let assertionOwner;
     let prevKind = 'start';
     let prevPunct;
     let k = open;
+    const jsxFrames = [];
+    const typeArgumentBounds = new Map();
     while (k < n) {
-        k = skipTrivia(source, k, n);
-        const ch = source[k];
+        let ch = source[k];
+        const frame = jsxFrames[jsxFrames.length - 1];
+        if (frame?.kind === 'jsx-text') {
+            if (ch === '{') {
+                jsxFrames.push({ kind: 'jsx-expr', depth: 0, offset: k });
+                prevKind = 'start';
+                prevPunct = undefined;
+                k++;
+                continue;
+            }
+            if (ch === '<' && source[k + 1] === '/') {
+                const end = source.indexOf('>', k + 2);
+                if (end < 0) {
+                    return false;
+                }
+                jsxFrames.pop();
+                prevKind = 'template';
+                prevPunct = undefined;
+                k = end + 1;
+                continue;
+            }
+            // Quotes, parentheses, backticks and comment markers in children are inert.
+            if (ch !== '<') {
+                k++;
+                continue;
+            }
+        }
+        else if (frame?.kind === 'jsx-tag') {
+            if (ch === '<' && skipTrivia(source, frame.nameEnd, n) === k) {
+                k = readJsxTypeArguments(source, k, n, []);
+            }
+            else if (ch === '{') {
+                jsxFrames.push({ kind: 'jsx-expr', depth: 0, offset: k });
+                prevKind = 'start';
+                prevPunct = undefined;
+                k++;
+            }
+            else if (ch === '"' || ch === "'") {
+                k = skipJsxAttributeValue(source, k, n);
+            }
+            else if (ch === '/' && source[k + 1] === '>') {
+                jsxFrames.pop();
+                prevKind = 'template';
+                prevPunct = undefined;
+                k += 2;
+            }
+            else if (ch === '>') {
+                jsxFrames.pop();
+                jsxFrames.push({ kind: 'jsx-text', name: frame.name, offset: frame.offset });
+                k++;
+            }
+            else {
+                k++;
+            }
+            continue;
+        }
+        else {
+            k = skipTrivia(source, k, n);
+            ch = source[k];
+        }
         if (ch === undefined) {
             break;
         }
+        if (jsx &&
+            ch === '<' &&
+            (frame?.kind === 'jsx-text' || isRegexStart(prevKind, prevPunct, false, false, false))) {
+            if (source[k + 1] === '>') {
+                jsxFrames.push({ kind: 'jsx-text', name: null, offset: k });
+                k += 2;
+                continue;
+            }
+            if (isIdentifierStartAt(source, k + 1) &&
+                (frame?.kind === 'jsx-text' || !jsxTagIsGeneric(source, k + 1, n))) {
+                const tag = readJsxTagName(source, k + 1, n);
+                jsxFrames.push({ kind: 'jsx-tag', name: tag.name, offset: k, nameEnd: tag.end });
+                k = tag.end;
+                continue;
+            }
+        }
+        if (frame?.kind === 'jsx-text') {
+            k++;
+            continue;
+        }
+        if (frame?.kind === 'jsx-expr') {
+            if (ch === '}') {
+                if (frame.depth === 0) {
+                    jsxFrames.pop();
+                    prevKind = 'template';
+                    prevPunct = undefined;
+                    k++;
+                    continue;
+                }
+                frame.depth--;
+            }
+            else if (ch === '{') {
+                frame.depth++;
+            }
+        }
+        if (mode === 'conditional-body' && ch === '<' && prevKind === 'identifier') {
+            const inAssertion = assertionOwner?.paren === depth &&
+                assertionOwner.bracket === bracketDepth &&
+                assertionOwner.brace === braceDepth &&
+                assertionOwner.frame === jsxFrames.length;
+            const end = expressionTypeArgumentEnd(source, k, n, typeArgumentBounds, inAssertion);
+            if (end !== undefined) {
+                k = end;
+                prevKind = 'identifier';
+                prevPunct = undefined;
+                continue;
+            }
+        }
+        if (assertionOwner?.paren === depth &&
+            assertionOwner.bracket === bracketDepth &&
+            assertionOwner.brace === braceDepth &&
+            assertionOwner.frame === jsxFrames.length &&
+            ['+', '-', '*', '/', '%', '=', '?', '!'].includes(ch)) {
+            assertionOwner = undefined;
+        }
+        // Reuse the same opaque regions to confirm a typed nested arrow in a ternary.
+        // Colons in JSX, object literals, nested delimiters or inner conditionals do not
+        // close the enclosing conditional. Stop at this expression's own boundary.
+        if (mode === 'conditional-body') {
+            if (jsxFrames.length === 0 && depth === 0 && bracketDepth === 0 && braceDepth === 0) {
+                if (ch === ':') {
+                    if (conditionalDepth === 0) {
+                        return true;
+                    }
+                    conditionalDepth--;
+                }
+                else if (ch === '?' &&
+                    source[k + 1] !== '?' &&
+                    source[k - 1] !== '?' &&
+                    source[k + 1] !== '.') {
+                    conditionalDepth++;
+                }
+                else if ([';', ',', ')', ']', '}'].includes(ch)) {
+                    return false;
+                }
+            }
+            if (ch === '[')
+                bracketDepth++;
+            else if (ch === ']')
+                bracketDepth--;
+            else if (ch === '{')
+                braceDepth++;
+            else if (ch === '}')
+                braceDepth--;
+        }
         // String literals: their brackets and slashes are inert text, so skip the whole value.
         if (ch === "'" || ch === '"') {
             k = readString(source, k).next;
@@ -1350,14 +1757,30 @@ function arrowFollowsParameters(source, open, n) {
             depth--;
             prevKind = 'punct';
             prevPunct = ')';
-            if (depth === 0) {
+            if (depth === 0 && mode === 'parameters') {
                 const j = skipTrivia(source, k + 1, n);
-                return ((source[j] === '=' && source[j + 1] === '>') ||
-                    (source[j] === ':' && arrowFollowsReturnType(source, j + 1, n)));
+                if (source[j] === '=' && source[j + 1] === '>') {
+                    return true;
+                }
+                const arrow = source[j] === ':' ? arrowAfterReturnType(source, j + 1, n) : undefined;
+                return (arrow !== undefined &&
+                    (!needsConditionalEnd ||
+                        arrowFollowsParameters(source, arrow + 2, n, jsx, false, 'conditional-body')));
             }
         }
         else if (isIdentifierStartAt(source, k)) {
             const identifier = readIdentifier(source, k);
+            if (mode === 'conditional-body' &&
+                ['as', 'satisfies'].includes(identifier.value) &&
+                prevKind !== 'start' &&
+                !(prevKind === 'punct' && prevPunct === '.')) {
+                assertionOwner = {
+                    paren: depth,
+                    bracket: bracketDepth,
+                    brace: braceDepth,
+                    frame: jsxFrames.length,
+                };
+            }
             k = identifier.end - 1;
             prevKind = 'identifier';
             prevPunct = undefined;
@@ -1370,7 +1793,83 @@ function arrowFollowsParameters(source, open, n) {
     }
     return false;
 }
-function arrowFollowsReturnType(source, start, n) {
+/** Skip a balanced type-argument list only when its suffix can continue an expression. */
+function expressionTypeArgumentEnd(source, open, n, bounds, typeAssertion = false) {
+    let end = bounds.get(open);
+    if (end === undefined) {
+        try {
+            end = readJsxTypeArguments(source, open, n, [], true, bounds);
+        }
+        catch (error) {
+            if (error instanceof ModuleSpecifierError) {
+                bounds.set(open, null);
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    if (end === null)
+        return undefined;
+    const next = skipTrivia(source, end, n);
+    const ch = source[next];
+    if (!typeAssertion)
+        return ch === '(' ? end : undefined;
+    if (isIdentifierStartAt(source, next) || isUnicodeEscapeStart(source, next)) {
+        return ['as', 'satisfies', 'in', 'instanceof'].includes(readIdentifier(source, next).value)
+            ? end
+            : undefined;
+    }
+    return ch !== undefined && (isNumberStart(ch) || ch === '"' || ch === "'") ? undefined : end;
+}
+/** A newline computed method head ends a complete bodyless member return annotation. */
+function computedMethodFollows(source, start, n) {
+    let depth = 0;
+    let index = start;
+    let previous = 'start';
+    let punct;
+    while (index < n) {
+        index = skipTrivia(source, index, n);
+        const ch = source[index];
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === "'" || ch === '"') {
+            index = readString(source, index).next;
+            previous = 'string';
+            continue;
+        }
+        if (ch === '`') {
+            index = skipTemplateLiteral(source, index);
+            previous = 'template';
+            continue;
+        }
+        if (ch === '/' && isRegexStart(previous, punct, false, false, false)) {
+            index = skipRegex(source, index);
+            previous = 'regex';
+            continue;
+        }
+        if (ch === '[') {
+            depth++;
+        }
+        else if (ch === ']') {
+            depth--;
+            if (depth === 0) {
+                return source[skipTrivia(source, index + 1, n)] === '(';
+            }
+        }
+        if (isIdentifierStartAt(source, index) || isUnicodeEscapeStart(source, index)) {
+            index = readIdentifier(source, index).end;
+            previous = 'identifier';
+        }
+        else {
+            previous = isNumberStart(ch) ? 'number' : 'punct';
+            punct = ch;
+            index++;
+        }
+    }
+    return false;
+}
+function arrowAfterReturnType(source, start, n) {
     let parenDepth = 0;
     let bracketDepth = 0;
     let braceDepth = 0;
@@ -1380,7 +1879,7 @@ function arrowFollowsReturnType(source, start, n) {
         index = skipTrivia(source, index, n);
         const ch = source[index];
         if (ch === undefined) {
-            return false;
+            return undefined;
         }
         if (ch === "'" || ch === '"') {
             index = readString(source, index).next;
@@ -1392,17 +1891,34 @@ function arrowFollowsReturnType(source, start, n) {
         }
         if (ch === '=' && source[index + 1] === '>') {
             if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && angleDepth === 0) {
-                return true;
+                return index;
             }
             index += 2;
             continue;
         }
+        if (parenDepth === 0 &&
+            bracketDepth === 0 &&
+            braceDepth === 0 &&
+            angleDepth === 0 &&
+            (isIdentifierStartAt(source, index) || isUnicodeEscapeStart(source, index))) {
+            const identifier = readIdentifier(source, index);
+            const next = skipTrivia(source, identifier.end, n);
+            // An operand followed by a call is runtime code (not a return type). In particular,
+            // a conditional's `: async () =>` must not claim the preceding sequence expression.
+            if (source[next] === '(' &&
+                identifier.value !== 'import' &&
+                !TYPE_OPERAND_KEYWORDS.has(identifier.value)) {
+                return undefined;
+            }
+            index = identifier.end;
+            continue;
+        }
         if (ch === '(') {
             parenDepth++;
         }
         else if (ch === ')') {
             if (parenDepth === 0) {
-                return false;
+                return undefined;
             }
             parenDepth--;
         }
@@ -1411,7 +1927,7 @@ function arrowFollowsReturnType(source, start, n) {
         }
         else if (ch === ']') {
             if (bracketDepth === 0) {
-                return false;
+                return undefined;
             }
             bracketDepth--;
         }
@@ -1420,7 +1936,7 @@ function arrowFollowsReturnType(source, start, n) {
         }
         else if (ch === '}') {
             if (braceDepth === 0) {
-                return false;
+                return undefined;
             }
             braceDepth--;
         }
@@ -1429,7 +1945,7 @@ function arrowFollowsReturnType(source, start, n) {
         }
         else if (ch === '>') {
             if (angleDepth === 0) {
-                return false;
+                return undefined;
             }
             angleDepth--;
         }
@@ -1438,15 +1954,15 @@ function arrowFollowsReturnType(source, start, n) {
             braceDepth === 0 &&
             angleDepth === 0 &&
             (ch === ';' || ch === ',')) {
-            return false;
+            return undefined;
         }
         index++;
     }
-    return false;
+    return undefined;
 }
-function arrowFollowsParametersSafely(source, open, n) {
+function arrowFollowsParametersSafely(source, open, n, jsx = false, needsConditionalEnd = false) {
     try {
-        return arrowFollowsParameters(source, open, n);
+        return arrowFollowsParameters(source, open, n, jsx, needsConditionalEnd);
     }
     catch (error) {
         if (error instanceof ModuleSpecifierError) {
@@ -1504,68 +2020,184 @@ function skipTemplateLiteral(source, start) {
     }
     throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', start);
 }
+/** Probe template types with the same type boundaries as their interpolated operands. */
+function skipTemplateType(source, start, n, bounds) {
+    let i = start + 1;
+    while (i < n) {
+        if (source[i] === '\\')
+            i += 2;
+        else if (source[i] === '`')
+            return i + 1;
+        else if (source[i] === '$' && source[i + 1] === '{') {
+            i = readJsxTypeArguments(source, i + 1, n, [], true, bounds, '}');
+        }
+        else
+            i++;
+    }
+    throw new ModuleSpecifierError('Unterminated template literal', 'invalid-source', start);
+}
+/** Only a complete type followed by a line break can begin another bodyless type member. */
+function typeMemberFollowsLineBreak(tokens, lineBreak) {
+    const complete = (token) => {
+        if (token === undefined)
+            return false;
+        if (token.kind === 'identifier')
+            return !TYPE_OPERAND_KEYWORDS.has(token.value);
+        return (token.kind === 'string' ||
+            token.kind === 'number' ||
+            token.kind === 'template' ||
+            (token.kind === 'punct' &&
+                ([')', ']', '}', '>'].includes(token.value) || /^[0-9]$/.test(token.value))));
+    };
+    let index = tokens.length - 1;
+    if (lineBreak && complete(tokens[index]))
+        return true;
+    // The line break may precede a modifier rather than the method name (e.g. get b()).
+    while (index >= 0) {
+        const token = tokens[index];
+        if (token?.kind !== 'identifier' || !MEMBER_MODIFIERS.has(token.value))
+            break;
+        if (token.lineBreakBefore === true && complete(tokens[index - 1]))
+            return true;
+        index--;
+    }
+    return false;
+}
 /**
  * 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 = ['>'];
+function readJsxTypeArguments(source, open, n, tokens, expressionProbe = false, bounds, rootClose = '>') {
+    const closers = [rootClose];
+    const opens = [open];
+    const conditions = [0];
     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);
+    try {
+        while (i < n) {
+            const trivia = readTrivia(source, i, n);
+            i = trivia.end;
+            const ch = source[i];
+            if (ch === undefined) {
+                break;
+            }
+            // A speculative expression probe must not borrow a > from a later statement
+            // or conditional branch. Colons in conditional types still belong to the list.
+            if (expressionProbe &&
+                (closers[closers.length - 1] === '>' || (rootClose === '}' && closers.length === 1))) {
+                const level = conditions.length - 1;
+                if (ch === '?')
+                    conditions[level] = (conditions[level] ?? 0) + 1;
+                else if (ch === ':' && (conditions[level] ?? 0) > 0)
+                    conditions[level] = (conditions[level] ?? 0) - 1;
+                else if (ch === ';' ||
+                    ch === ':' ||
+                    (ch === '=' && source[i + 1] !== '>') ||
+                    ([')', ']', '}'].includes(ch) && ch !== closers[closers.length - 1])) {
+                    throw new ModuleSpecifierError('Invalid type argument boundary', 'invalid-source', i);
+                }
+            }
+            if (expressionProbe && ch === '/') {
+                throw new ModuleSpecifierError('Runtime slash in type argument probe', 'invalid-source', i);
+            }
+            if (ch === "'" || ch === '"') {
+                const callee = tokens[tokens.length - 2];
+                if (expressionProbe &&
+                    isPunct(tokens[tokens.length - 1], '(') &&
+                    callee?.kind === 'identifier' &&
+                    callee.value !== 'import' &&
+                    !TYPE_OPERAND_KEYWORDS.has(callee.value)) {
+                    throw new ModuleSpecifierError('Literal method parameter in type argument probe', 'invalid-source', i);
+                }
+                const { value, next } = readString(source, i);
+                tokens.push({
+                    kind: 'string',
+                    value,
+                    offset: i,
+                    endOffset: next,
+                    lineBreakBefore: trivia.lineBreak,
+                });
+                i = next;
+                continue;
+            }
+            if (ch === '`') {
+                if (expressionProbe) {
+                    const end = skipTemplateType(source, i, n, bounds);
+                    tokens.push({
+                        kind: 'template',
+                        offset: i,
+                        endOffset: end,
+                        lineBreakBefore: trivia.lineBreak,
+                    });
+                    i = end;
+                    continue;
+                }
+                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);
+                const next = skipTrivia(source, identifier.end, n);
+                if (expressionProbe &&
+                    source[next] === '(' &&
+                    identifier.value !== 'import' &&
+                    !TYPE_OPERAND_KEYWORDS.has(identifier.value) &&
+                    !(closers[closers.length - 1] === '}' &&
+                        closers.length > 1 &&
+                        (memberDeclarationHead(tokens, tokens.length, false) !== undefined ||
+                            typeMemberFollowsLineBreak(tokens, trivia.lineBreak)))) {
+                    throw new ModuleSpecifierError('Runtime call in type argument probe', 'invalid-source', i);
+                }
+                i = identifier.end;
+                tokens.push({
+                    kind: 'identifier',
+                    value: identifier.value,
+                    offset: start,
+                    endOffset: i,
+                    lineBreakBefore: trivia.lineBreak,
+                });
+                continue;
+            }
+            if (expressionProbe && ch === '{' && isPunct(tokens[tokens.length - 1], ')')) {
+                throw new ModuleSpecifierError('Runtime body in type argument probe', 'invalid-source', i);
+            }
+            if (ch === '<' || ch === '(' || ch === '{' || ch === '[') {
+                closers.push(ch === '<' ? '>' : ch === '(' ? ')' : ch === '{' ? '}' : ']');
+                opens.push(i);
+                conditions.push(0);
+            }
+            else if (ch === closers[closers.length - 1] && !(ch === '>' && source[i - 1] === '=')) {
+                closers.pop();
+                const opened = opens.pop();
+                conditions.pop();
+                if (expressionProbe && ch === '>' && opened !== undefined)
+                    bounds?.set(opened, i + 1);
+                if (closers.length === 0) {
+                    return i + 1;
+                }
+            }
             tokens.push({
-                kind: 'string',
-                value,
+                kind: 'punct',
+                value: ch,
                 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,
+                endOffset: i + 1,
                 lineBreakBefore: trivia.lineBreak,
+                ...(ch === '=' ? classifyEquals(source, i, true) : {}),
             });
-            continue;
-        }
-        if (ch === '<' || ch === '(' || ch === '{' || ch === '[') {
-            closers.push(ch === '<' ? '>' : ch === '(' ? ')' : ch === '{' ? '}' : ']');
+            i++;
         }
-        else if (ch === closers[closers.length - 1] && !(ch === '>' && source[i - 1] === '=')) {
-            closers.pop();
-            if (closers.length === 0) {
-                return i + 1;
+        throw new ModuleSpecifierError('Unterminated JSX type arguments', 'invalid-source', open);
+    }
+    catch (error) {
+        if (expressionProbe && bounds !== undefined) {
+            // One failed walk classifies every still-open angle encountered along the way.
+            for (let level = 0; level < closers.length; level++) {
+                const opened = opens[level];
+                if (closers[level] === '>' && opened !== undefined)
+                    bounds.set(opened, null);
             }
         }
-        tokens.push({
-            kind: 'punct',
-            value: ch,
-            offset: i,
-            endOffset: i + 1,
-            lineBreakBefore: trivia.lineBreak,
-            ...(ch === '=' ? classifyEquals(source, i, true) : {}),
-        });
-        i++;
+        throw error;
     }
-    throw new ModuleSpecifierError('Unterminated JSX type arguments', 'invalid-source', open);
 }
 /**
  * Whether the source between two offsets contains a line terminator.
@@ -1634,7 +2266,7 @@ const TYPE_OPERAND_KEYWORDS = new Set([
  * (`(): (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) {
+function functionTypeArrowContinues(source, arrowEnd, n, conditionalEnd = false) {
     let depth = 0;
     for (let i = arrowEnd + 1; i < n; i++) {
         const ch = source[i];
@@ -1651,7 +2283,7 @@ function functionTypeArrowContinues(source, arrowEnd, n) {
             depth--;
         }
         else if (depth === 0) {
-            if (ch === '{' || ch === ';' || ch === ',') {
+            if (ch === '{' || ch === ';' || ch === ',' || (conditionalEnd && ch === ':')) {
                 return false;
             }
             if (ch === '=' && source[i + 1] === '>') {
@@ -1661,6 +2293,43 @@ function functionTypeArrowContinues(source, arrowEnd, n) {
     }
     return false;
 }
+/** Preserve type-argument identity while inspecting a parameter binding pattern. */
+function markParameterTypeArguments(tokens, openIndex) {
+    if (!isPunct(tokens[openIndex - 1], '>')) {
+        return;
+    }
+    const start = signatureNameIndex(tokens, openIndex) + 1;
+    if (!isPunct(tokens[start], '<')) {
+        return;
+    }
+    // A real JS destructuring entry between comparison operators needs a default or property
+    // separator. Do not mistake that binding for a generic argument. Nested type members may
+    // contain their own separators inside balanced (), [] and {}.
+    let depth = 0;
+    for (let index = start + 1; index < openIndex - 1; index++) {
+        const token = tokens[index];
+        if (token?.kind !== 'punct') {
+            continue;
+        }
+        if (['(', '[', '{'].includes(token.value)) {
+            depth++;
+        }
+        else if ([')', ']', '}'].includes(token.value)) {
+            depth--;
+        }
+        else if (depth === 0 &&
+            (token.operator === 'assignment' || token.value === ':' || token.value === ';')) {
+            return;
+        }
+    }
+    for (let index = start; index < openIndex; index++) {
+        const token = tokens[index];
+        if (token !== undefined) {
+            tokens[index] = { ...token, parameterType: true };
+        }
+    }
+    return start;
+}
 /**
  * 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) => {}`,
@@ -2013,11 +2682,22 @@ function inferArrowContext(tokens, arrowIndex) {
     const async = markerToken?.kind === 'identifier' &&
         markerToken.value === 'async' &&
         asyncModifierIsContinuous(tokens, markerIndex, parametersIndex);
-    return {
+    return (parametersStart.signatureContext ?? {
         async,
         generator: false,
         isExpression: false,
-    };
+    });
+}
+/** Parameter lists can start at expression/statement boundaries, never after a call's name. */
+function arrowParameterPrefix(token) {
+    if (token === undefined) {
+        return true;
+    }
+    if (token.kind === 'punct') {
+        return (EXPRESSION_BEFORE_BRACE.has(token.value) || [':', '>', ';', '{', '/'].includes(token.value));
+    }
+    return (token.kind === 'identifier' &&
+        ['return', 'throw', 'yield', 'await', 'void', 'typeof', 'delete', 'default'].includes(token.value));
 }
 function parameterSignatureContext(tokens, pending, insideMethodContainer, insideClassBody, lineBreakBefore, memberStart) {
     const openIndex = tokens.length;
@@ -2043,12 +2723,7 @@ function parameterSignatureContext(tokens, pending, insideMethodContainer, insid
     }
     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));
+    const startsArrowParameters = arrowParameterPrefix(name) || (isIdentifier(name, 'async') && arrowParameterPrefix(marker));
     if (startsArrowParameters) {
         const asyncToken = name?.kind === 'identifier' && name.value === 'async' ? name : undefined;
         const async = asyncToken !== undefined &&
@@ -2421,13 +3096,13 @@ const BLOCK_AFTER_KEYWORD = new Set(['else', 'do']);
 // 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) {
+function functionIsExpressionPosition(prevKind, prevPunct, colonIsExpression, expressionExpected) {
+    if (expressionExpected) {
+        return true;
+    }
     if (prevKind === 'punct') {
         return prevPunct === ':' ? colonIsExpression : EXPRESSION_BEFORE_BRACE.has(prevPunct ?? '');
     }
-    if (prevKind === 'identifier') {
-        return REGEX_PRECEDING_KEYWORDS.has(previousIdentifier ?? '');
-    }
     return prevKind === 'regex';
 }
 /**
@@ -2500,6 +3175,29 @@ function isRegexStart(prevKind, prevPunct, prevIsExpressionKeyword, afterControl
 function interpret(tokens) {
     const occurrences = [];
     const n = tokens.length;
+    let closingDelimiters;
+    const closingDelimiter = (openIndex) => {
+        closingDelimiters ??= indexClosingDelimiters(tokens);
+        return closingDelimiters.get(openIndex);
+    };
+    const resolvedRequireScopes = new Map();
+    const requireIsShadowed = (scope) => {
+        const path = [];
+        let current = scope;
+        while (current !== undefined && !resolvedRequireScopes.has(current)) {
+            path.push(current);
+            current = current.parent;
+        }
+        let shadowed = current === undefined ? false : (resolvedRequireScopes.get(current) ?? false);
+        for (let index = path.length - 1; index >= 0; index--) {
+            const owner = path[index];
+            if (owner !== undefined) {
+                shadowed ||= owner.bindings.some((range) => bindingHasRequire(tokens, range.start, range.end, closingDelimiter));
+                resolvedRequireScopes.set(owner, shadowed);
+            }
+        }
+        return shadowed;
+    };
     let i = 0;
     while (i < n) {
         const token = tokens[i];
@@ -2508,7 +3206,7 @@ function interpret(tokens) {
             continue;
         }
         if (token.value === 'import') {
-            i = handleImport(tokens, i, occurrences);
+            i = handleImport(tokens, i, occurrences, closingDelimiter);
             continue;
         }
         if (token.value === 'export') {
@@ -2516,6 +3214,10 @@ function interpret(tokens) {
             continue;
         }
         if (token.value === 'require') {
+            if (token.requireScope !== undefined && requireIsShadowed(token.requireScope)) {
+                i++;
+                continue;
+            }
             i = handleRequire(tokens, i, occurrences);
             continue;
         }
@@ -2529,7 +3231,7 @@ function interpret(tokens) {
  * - `obj.import(...)` is ignored (a member call, preceded by `.`).
  * - `import.meta` is ignored (treated as `import` followed by `.`).
  * - `import 'pkg'` and `import ... from 'pkg'` are `import`.
- * - `import('pkg')` is `dynamic-import` only when the sole argument is a static string.
+ * - Dynamic import accepts a literal source with optional bounded object-literal options.
  */
 /**
  * Whether the identifier at `i` is a property name (`obj.require`), which is never the global
@@ -2551,7 +3253,7 @@ function isMemberName(tokens, i) {
         third.value === '.';
     return !isSpread;
 }
-function handleImport(tokens, i, occurrences) {
+function handleImport(tokens, i, occurrences, closingDelimiter) {
     const next = tokens[i + 1];
     // `obj.import(...)`: a member call, not the import keyword.
     if (isMemberName(tokens, i)) {
@@ -2563,82 +3265,125 @@ function handleImport(tokens, i, occurrences) {
     }
     // `import 'pkg'`
     if (next?.kind === 'string') {
-        occurrences.push({ specifier: next.value, kind: 'import' });
+        occurrences.push({ specifier: next.value, kind: 'import', offset: next.offset });
         return i + 2;
     }
-    // `import('pkg')` / `import ('pkg')`: only a sole string argument closed by `)` is static.
+    // Keep literal specifiers with sole-argument or bounded object-literal options forms.
     if (next?.kind === 'punct' && next.value === '(') {
-        const specifier = soleStringSpecifier(tokens, i + 2);
+        const specifier = dynamicImportSpecifier(tokens, i + 2, closingDelimiter);
         if (specifier !== undefined) {
-            occurrences.push({ specifier, kind: 'dynamic-import' });
+            occurrences.push({
+                specifier: specifier.value,
+                kind: 'dynamic-import',
+                offset: specifier.offset,
+            });
             return i + 3;
         }
         return i + 1;
     }
-    // Static `import ... from 'pkg'`: scan forward for `from` followed by a string.
+    // Static `import ... from 'pkg'`: consume only the supported clause.
     return scanImportSource(tokens, i, occurrences, 'import');
 }
 /**
  * Handle an `export` identifier. `export ... from 'pkg'` is `export-from`.
  */
 function handleExport(tokens, i, occurrences) {
+    // Member names share the same boundary rule as import and require.
+    if (isMemberName(tokens, i)) {
+        return i + 1;
+    }
     return scanImportSource(tokens, i, occurrences, 'export-from');
 }
+/** Read only the supported clause; unrelated statements cannot supply its source. */
+function scanImportSource(tokens, i, occurrences, kind) {
+    const sourceIndex = kind === 'export-from' ? exportSourceIndex(tokens, i) : importSourceIndex(tokens, i);
+    const source = sourceIndex === undefined ? undefined : tokens[sourceIndex];
+    if (source?.kind === 'string' && sourceIndex !== undefined) {
+        occurrences.push({ specifier: source.value, kind, offset: source.offset });
+        return sourceIndex + 1;
+    }
+    return i + 1;
+}
 /**
- * Scan forward from `i` looking for the `from` keyword followed by a string, recording it with
- * `kind`. Stops early at a nested `import`/`export`/`require` so a following construct is handled on
- * its own, except for `import`/`export` used as binding names inside the `{ ... }` clause of the
- * current statement (e.g. `import { export as v } from 'pkg'`).
+ * Consume a default binding and/or a namespace/named clause, then require `from` + literal.
+ * Each property lookalike fails locally. Named clauses accept only specifiers, never arbitrary
+ * brace contents, so failed candidates cannot repeatedly search an unrelated suffix.
  */
-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;
+function importSourceIndex(tokens, importIndex) {
+    let index = importIndex + 1;
+    if (isIdentifier(tokens[index], 'type') &&
+        (isPunct(tokens[index + 1], '{') ||
+            isPunct(tokens[index + 1], '*') ||
+            (tokens[index + 1]?.kind === 'identifier' &&
+                (!isIdentifier(tokens[index + 1], 'from') || tokens[index + 2]?.kind !== 'string') &&
+                (!isIdentifier(tokens[index + 1], 'as') || isIdentifier(tokens[index + 2], 'from'))))) {
+        index++;
+    }
+    if (tokens[index]?.kind === 'identifier') {
+        index++;
+        // Preserve the historical synthetic default-alias form supported by this scanner.
+        if (isIdentifier(tokens[index], 'as') && tokens[index + 1]?.kind === 'identifier') {
+            index += 2;
         }
-        const source = tokens[sourceIndex];
-        if (source?.kind === 'string') {
-            occurrences.push({ specifier: source.value, kind });
-            return sourceIndex + 1;
+        if (isPunct(tokens[index], ',')) {
+            index++;
+        }
+        else {
+            return importFromSourceIndex(tokens, index);
         }
-        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
-    // start a new construct at depth 0, otherwise the search stops before the real `from` source.
-    let braceDepth = 0;
-    while (j < n) {
-        const token = tokens[j];
-        if (token?.kind === 'punct') {
-            if (token.value === '{') {
-                braceDepth++;
+    if (isPunct(tokens[index], '*')) {
+        if (!isIdentifier(tokens[index + 1], 'as') || tokens[index + 2]?.kind !== 'identifier') {
+            return undefined;
+        }
+        index += 3;
+    }
+    else if (isPunct(tokens[index], '{')) {
+        index++;
+        while (!isPunct(tokens[index], '}')) {
+            // `type as T` imports the value `type`, but `type as` imports the type `as`.
+            // A second `as` plus an alias distinguishes `type as as Alias` from `type as as`.
+            if (isIdentifier(tokens[index], 'type') &&
+                tokens[index + 1]?.kind === 'identifier' &&
+                (!isIdentifier(tokens[index + 1], 'as') ||
+                    isPunct(tokens[index + 2], ',') ||
+                    isPunct(tokens[index + 2], '}') ||
+                    (isIdentifier(tokens[index + 2], 'as') && tokens[index + 3]?.kind === 'identifier'))) {
+                index++;
+            }
+            const imported = tokens[index];
+            if (imported?.kind !== 'identifier' && imported?.kind !== 'string') {
+                return undefined;
             }
-            else if (token.value === '}') {
-                // Clamped so an unmatched `}` cannot leave a negative depth that hides later boundaries.
-                braceDepth = braceDepth > 0 ? braceDepth - 1 : 0;
+            index++;
+            if (isIdentifier(tokens[index], 'as')) {
+                if (tokens[index + 1]?.kind !== 'identifier') {
+                    return undefined;
+                }
+                index += 2;
             }
-        }
-        if (token?.kind === 'identifier') {
-            const next = tokens[j + 1];
-            // `import`/`export` only start a new construct outside the named clause. A `require`
-            // identifier only starts one when it begins a direct call: a binding named `require` (e.g.
-            // `import { require } from 'pkg'`) must not stop the search for the source that follows
-            // `from`.
-            if ((braceDepth === 0 && (token.value === 'import' || token.value === 'export')) ||
-                (token.value === 'require' && next?.kind === 'punct' && next.value === '(')) {
-                break;
+            else if (imported.kind === 'string') {
+                return undefined;
             }
-            if (token.value === 'from' && next?.kind === 'string') {
-                occurrences.push({ specifier: next.value, kind });
-                return j + 2;
+            if (!isPunct(tokens[index], ',')) {
+                break;
             }
+            index++;
         }
-        j++;
+        if (!isPunct(tokens[index], '}')) {
+            return undefined;
+        }
+        index++;
     }
-    // No source found; keep scanning from the next token.
-    return i + 1;
+    else {
+        return undefined;
+    }
+    return importFromSourceIndex(tokens, index);
+}
+function importFromSourceIndex(tokens, index) {
+    return isIdentifier(tokens[index], 'from') && tokens[index + 1]?.kind === 'string'
+        ? index + 1
+        : undefined;
 }
 function exportSourceIndex(tokens, exportIndex) {
     let index = exportIndex + 1;
@@ -2684,32 +3429,177 @@ function handleRequire(tokens, i, occurrences) {
         return i + 1;
     }
     const next = tokens[i + 1];
-    // `require('pkg')`: only a sole string argument closed by `)` is static.
+    // A sole string argument, with an optional trailing comma, is static; options are not supported.
     if (next?.kind === 'punct' && next.value === '(') {
         const specifier = soleStringSpecifier(tokens, i + 2);
         if (specifier !== undefined) {
-            occurrences.push({ specifier, kind: 'require' });
+            occurrences.push({ specifier: specifier.value, kind: 'require', offset: specifier.offset });
             return i + 3;
         }
     }
     return i + 1;
 }
+/** Inspect binding targets only, skipping property keys, types and initializer expressions. */
+function bindingHasRequire(tokens, start, end, closingDelimiter) {
+    const targets = [{ start, end }];
+    while (targets.length > 0) {
+        const target = targets.pop();
+        if (target === undefined) {
+            break;
+        }
+        let index = bindingAfterRest(tokens, target.start);
+        // Constructor parameter properties prefix the binding, rather than naming it.
+        let modifier = tokens[index];
+        while (index + 1 < target.end &&
+            modifier?.kind === 'identifier' &&
+            ['public', 'private', 'protected', 'readonly', 'override'].includes(modifier.value)) {
+            index++;
+            modifier = tokens[index];
+        }
+        const token = tokens[index];
+        if (token?.kind === 'identifier') {
+            const next = tokens[index + 1];
+            if (token.value === 'require' &&
+                (index + 1 >= target.end ||
+                    isPunct(next, ',') ||
+                    isPunct(next, '?') ||
+                    (next?.kind === 'punct' && next.operator === 'assignment'))) {
+                return true;
+            }
+            continue;
+        }
+        const object = isPunct(token, '{');
+        if (!object && !isPunct(token, '[')) {
+            continue;
+        }
+        const close = closingDelimiter(index);
+        if (close === undefined || close >= target.end) {
+            continue;
+        }
+        const frame = token?.parameterFrame;
+        index++;
+        while (index < close) {
+            if (isPunct(tokens[index], ',')) {
+                index++;
+                continue;
+            }
+            index = bindingAfterRest(tokens, index);
+            let binding = index;
+            if (object) {
+                const keyClose = isPunct(tokens[index], '[') ? closingDelimiter(index) : index;
+                if (keyClose === undefined) {
+                    break;
+                }
+                if (isPunct(tokens[keyClose + 1], ':')) {
+                    binding = keyClose + 2;
+                }
+            }
+            targets.push({ start: binding, end: close });
+            index = bindingElementEnd(tokens, binding, close, frame, closingDelimiter);
+        }
+    }
+    return false;
+}
+function bindingAfterRest(tokens, index) {
+    return isPunct(tokens[index], '.') &&
+        isPunct(tokens[index + 1], '.') &&
+        isPunct(tokens[index + 2], '.')
+        ? index + 3
+        : index;
+}
+function bindingElementEnd(tokens, start, end, frame, closingDelimiter) {
+    let index = start;
+    while (index < end) {
+        const token = tokens[index];
+        if (isPunct(token, ',') && token?.parameterFrame === frame && token?.parameterType !== true) {
+            return index + 1;
+        }
+        if (isPunct(token, '(') || isPunct(token, '[') || isPunct(token, '{')) {
+            const close = closingDelimiter(index);
+            if (close !== undefined && close < end) {
+                index = close + 1;
+                continue;
+            }
+        }
+        index++;
+    }
+    return end;
+}
+/** Index balanced delimiters once, lazily, so nested option calls do not rescan suffixes. */
+function indexClosingDelimiters(tokens) {
+    const closing = new Map();
+    const stack = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token?.kind !== 'punct') {
+            continue;
+        }
+        if (token.value === '(' || token.value === '[' || token.value === '{') {
+            stack.push(index);
+            continue;
+        }
+        const opener = closerFor(token.value);
+        if (opener === undefined) {
+            continue;
+        }
+        const open = stack.pop();
+        if (open === undefined || !isPunct(tokens[open], opener)) {
+            // Do not pair an enclosing option object across a malformed nested delimiter.
+            stack.length = 0;
+        }
+        else {
+            closing.set(open, index);
+        }
+    }
+    return closing;
+}
+/** The opener a closer matches, or undefined when the token is not a closer. */
+function closerFor(value) {
+    if (value === ')') {
+        return '(';
+    }
+    return value === ']' ? '[' : value === '}' ? '{' : undefined;
+}
+/**
+ * Recognize the supported dynamic import arguments: a literal source plus either no further
+ * argument or one balanced object-literal options expression. Option contents are never evaluated
+ * and never contribute evidence. `require` keeps the stricter sole-literal rule.
+ */
+function dynamicImportSpecifier(tokens, argIndex, closingDelimiter) {
+    const sole = soleStringSpecifier(tokens, argIndex);
+    if (sole !== undefined) {
+        return sole;
+    }
+    const specifier = tokens[argIndex];
+    if (specifier?.kind !== 'string' ||
+        !isPunct(tokens[argIndex + 1], ',') ||
+        !isPunct(tokens[argIndex + 2], '{')) {
+        return undefined;
+    }
+    const optionsClose = closingDelimiter(argIndex + 2);
+    if (optionsClose === undefined) {
+        return undefined;
+    }
+    const next = isPunct(tokens[optionsClose + 1], ',') ? optionsClose + 2 : optionsClose + 1;
+    return isPunct(tokens[next], ')') ? specifier : undefined;
+}
 /**
- * The decoded string at `argIndex` when it is the only argument of the surrounding call, that is
- * when it is a string and the very next token closes the call with `)`. Returns undefined otherwise,
+ * The string token at `argIndex` when it is the only argument of the surrounding call, that is
+ * when it is a string followed by an optional trailing comma and `)`. Returns undefined otherwise,
  * so a dynamic argument (e.g. `'pkg-' + name`) or a call with extra arguments (e.g.
  * `require('pkg', ctx)`) never yields a static specifier.
  */
 function soleStringSpecifier(tokens, argIndex) {
     const arg = tokens[argIndex];
-    const closing = tokens[argIndex + 1];
+    const closingIndex = isPunct(tokens[argIndex + 1], ',') ? argIndex + 2 : argIndex + 1;
+    const closing = tokens[closingIndex];
     if (arg?.kind !== 'string') {
         return undefined;
     }
     if (closing?.kind !== 'punct' || closing.value !== ')') {
         return undefined;
     }
-    return arg.value;
+    return arg;
 }
 /* -------------------------------------------------------------------------- */
 /* Lexical constructs                                                         */
@@ -2725,7 +3615,88 @@ function skipBlockComment(source, start) {
     }
     throw new ModuleSpecifierError('Unterminated block comment', 'invalid-source', start);
 }
+/** A dynamic import remains valid script syntax; only static forms and meta signal a module. */
+function importSignalsModule(source, end, atRoot) {
+    const next = skipTrivia(source, end, source.length);
+    if (source[next] === '.') {
+        const meta = skipTrivia(source, next + 1, source.length);
+        return ((isIdentifierStartAt(source, meta) || isUnicodeEscapeStart(source, meta)) &&
+            readIdentifier(source, meta).value === 'meta');
+    }
+    return (atRoot &&
+        (source[next] === "'" ||
+            source[next] === '"' ||
+            source[next] === '{' ||
+            source[next] === '*' ||
+            isIdentifierStartAt(source, next) ||
+            isUnicodeEscapeStart(source, next)));
+}
+function exportSignalsModule(source, end) {
+    const next = skipTrivia(source, end, source.length);
+    return (source[next] === '{' ||
+        source[next] === '*' ||
+        (isIdentifierStartAt(source, next) &&
+            ['default', 'const', 'let', 'var', 'function', 'async', 'class'].includes(readIdentifier(source, next).value)));
+}
+/**
+ * Probe top-level await without treating every identifier named await as a keyword. A complete
+ * regex may be read opaquely during this pass even when its following operand makes it script
+ * division. That protects apostrophes until a later static declaration settles the whole file.
+ * Calls, indexing, tags, unary +/- and flag-like identifier divisors remain ambiguous script
+ * expressions absent another signal.
+ */
+function probeAwaitOperand(source, end, inForHead) {
+    const trivia = readTrivia(source, end, source.length);
+    const next = trivia.end;
+    const ch = source[next];
+    if (ch === '/') {
+        const finish = regexEnd(source, next);
+        if (finish === undefined) {
+            return { keyword: false, module: false };
+        }
+        const following = skipTrivia(source, finish, source.length);
+        const tail = source[following];
+        // Characters consumed as flags can instead be a complete identifier divisor (including a
+        // valid flag such as g). Its following operator/terminator cannot establish module grammar.
+        const hasIdentifierDivisor = source[finish - 1] !== '/';
+        const comparisonKeyword = (isIdentifierStartAt(source, following) || isUnicodeEscapeStart(source, following)) &&
+            ['in', 'instanceof'].includes(readIdentifier(source, following).value);
+        const unambiguous = !hasIdentifierDivisor &&
+            (tail === undefined ||
+                [';', ',', ')', ']', '}', '?'].includes(tail) ||
+                (tail === '.' && !isNumberStart(source[following + 1] ?? '')) ||
+                // These binary operators cannot start the missing right-hand divisor. Unary +/-,
+                // calls, indexing, templates and decimal starts still admit script expressions.
+                ['<', '>', '*', '%', '&', '|', '^'].includes(tail) ||
+                source.startsWith('==', following) ||
+                source.startsWith('!=', following) ||
+                comparisonKeyword);
+        return { keyword: true, module: unambiguous };
+    }
+    // A newline also permits a bare await identifier statement followed by another statement.
+    if (trivia.lineBreak) {
+        return { keyword: false, module: false };
+    }
+    if (isIdentifierStartAt(source, next) || isUnicodeEscapeStart(source, next)) {
+        const name = readIdentifier(source, next).value;
+        const operand = !['in', 'instanceof'].includes(name) && !(name === 'of' && inForHead);
+        return { keyword: operand, module: operand };
+    }
+    const operand = ch !== undefined &&
+        (isNumberStart(ch) ||
+            (ch === '.' && isNumberStart(source[next + 1] ?? '')) ||
+            ["'", '"', '{', '~'].includes(ch) ||
+            (ch === '!' && source[next + 1] !== '='));
+    return { keyword: operand, module: operand };
+}
 function skipRegex(source, start) {
+    const end = regexEnd(source, start);
+    if (end === undefined) {
+        throw new ModuleSpecifierError('Unterminated regex literal', 'invalid-source', start);
+    }
+    return end;
+}
+function regexEnd(source, start) {
     const n = source.length;
     let i = start + 1;
     let inClass = false;
@@ -2734,7 +3705,7 @@ function skipRegex(source, start) {
         // A regex literal cannot contain a raw line terminator. Rejecting it here stops a wrong regex
         // start from swallowing the following lines.
         if (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029') {
-            throw new ModuleSpecifierError('Unterminated regex literal', 'invalid-source', start);
+            return undefined;
         }
         if (ch === '\\') {
             i += 2;
@@ -2757,7 +3728,7 @@ function skipRegex(source, start) {
         }
         i++;
     }
-    throw new ModuleSpecifierError('Unterminated regex literal', 'invalid-source', start);
+    return undefined;
 }
 function skipRegexFlags(source, i) {
     const n = source.length;