veryfront 0.1.1237 → 0.1.1239

package/esm/src/transforms/mdx/esm-module-loader/utils/source-spans.js

@@ -1,4 +1,55 @@
 import { INVALID_ARGUMENT } from "../../../../errors/index.js";
+const MAX_TEMPLATE_LITERAL_DEPTH = 512;
+const MAX_RAW_JSX_TEXT_CLOSING_LOOKAHEAD = 64 * 1024;
+const StringFromCodePoint = String.fromCodePoint;
+const IDENTIFIER_START_PATTERN = /^[$_\p{ID_Start}]$/u;
+const IDENTIFIER_PART_PATTERN = /^[$_\p{ID_Continue}\u200C\u200D]$/u;
+const IDENTIFIER_ESCAPE_SOURCE = String.raw `\\u(?:[0-9A-Fa-f]{4}|\{[0-9A-Fa-f]+\})`;
+const IDENTIFIER_NAME_SOURCE = String
+    .raw `(?:[$_\p{ID_Start}]|${IDENTIFIER_ESCAPE_SOURCE})(?:[$\p{ID_Continue}\u200C\u200D]|${IDENTIFIER_ESCAPE_SOURCE})*`;
+const FUNCTION_DECLARATION_PREFIX_PATTERN = new RegExp(String
+    .raw `^(?:export\s+(?:default\s+)?)?(?:async\s+)?function(?:\s*\*)?(?:\s+${IDENTIFIER_NAME_SOURCE})?\s*$`, "u");
+const TYPESCRIPT_FUNCTION_DECLARATION_PREFIX_PATTERN = new RegExp(String
+    .raw `^(?:export\s+(?:default\s+)?)?(?:async\s+)?function(?:\s*\*)?(?:\s+${IDENTIFIER_NAME_SOURCE})?(?:\s*<[\s\S]*>)?\s*\([\s\S]*\)\s*(?::\s*[\s\S]*\S)?\s*$`, "u");
+const CLASS_DECLARATION_PREFIX_PATTERN = new RegExp(String
+    .raw `^(?:@[\s\S]+?\s+)*(?:export\s+(?:default\s+)?)?(?:declare\s+)?(?:abstract\s+)?class(?:\s+${IDENTIFIER_NAME_SOURCE})?(?:\s*<[\s\S]*>)?(?:\s+extends\s+[\s\S]+?)?(?:\s+implements\s+[\s\S]+)?\s*$`, "u");
+const TYPESCRIPT_DECLARATION_PREFIX_PATTERN = new RegExp(String
+    .raw `^(?:export\s+(?:default\s+)?)?(?:declare\s+)?(?:(?:interface\s+${IDENTIFIER_NAME_SOURCE}(?:\s*<[\s\S]*>)?(?:\s+extends\s+[\s\S]+)?)|(?:(?:const\s+)?enum\s+${IDENTIFIER_NAME_SOURCE})|(?:global)|(?:(?:namespace|module)\s+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|${IDENTIFIER_NAME_SOURCE}(?:\s*\.\s*${IDENTIFIER_NAME_SOURCE})*)))\s*$`, "u");
+const TYPESCRIPT_TYPE_ALIAS_PREFIX_PATTERN = new RegExp(String.raw `^(?:export\s+)?type\s+${IDENTIFIER_NAME_SOURCE}(?:\s*<[\s\S]*>)?\s*=\s*[\s\S]*\S\s*$`, "u");
+const TYPESCRIPT_AMBIENT_DECLARATION_PREFIX_PATTERN = new RegExp(String
+    .raw `^(?:export\s+)?declare\s+(?:(?:(?:const|let|var)\s+${IDENTIFIER_NAME_SOURCE}(?:\s*:\s*[\s\S]*\S)?)|(?:function\s+${IDENTIFIER_NAME_SOURCE}(?:\s*<[\s\S]*>)?\s*\([\s\S]*\)\s*(?::\s*[\s\S]*\S)?)|(?:class\s+${IDENTIFIER_NAME_SOURCE}(?:\s*<[\s\S]*>)?(?:\s+extends\s+[\s\S]+?)?(?:\s+implements\s+[\s\S]+)?))\s*$`, "u");
+const JSX_TEXT_BREAK_STATEMENT_KEYWORDS = new Set([
+    "async",
+    "await",
+    "break",
+    "case",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "do",
+    "else",
+    "export",
+    "for",
+    "function",
+    "if",
+    "import",
+    "let",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "var",
+    "while",
+    "with",
+    "yield",
+]);
+function assertTemplateLiteralDepth(depth) {
+    if (depth > MAX_TEMPLATE_LITERAL_DEPTH) {
+        throw new RangeError("Template literal nesting exceeds scanner limit");
+    }
+}
 export function replaceSourceSpans(source, replacements) {
     let result = source;
     // Sort descending by start so we apply back-to-front and earlier spans stay valid.
@@ -14,123 +65,1635 @@ export function replaceSourceSpans(source, replacements) {
             throw new RangeError(`Overlapping source replacement spans: [${earlier.start},${earlier.end}) and [${later.start},${later.end})`);
         }
     }
-    for (const { start, end, replacement, expected } of sorted) {
-        if (start < 0 || end < start || end > source.length) {
-            throw new RangeError(`Invalid source replacement span: ${start}-${end}`);
+    for (const { start, end, replacement, expected } of sorted) {
+        if (start < 0 || end < start || end > source.length) {
+            throw new RangeError(`Invalid source replacement span: ${start}-${end}`);
+        }
+        if (expected !== undefined && source.slice(start, end) !== expected) {
+            throw INVALID_ARGUMENT.create({
+                detail: `Source replacement span did not match expected text: ${expected}`,
+            });
+        }
+        result = result.slice(0, start) + replacement + result.slice(end);
+    }
+    return result;
+}
+function isIdentifierChar(char) {
+    return char !== undefined && IDENTIFIER_PART_PATTERN.test(char);
+}
+function isIdentifierStart(char) {
+    return char !== undefined && IDENTIFIER_START_PATTERN.test(char);
+}
+function identifierCharacterAt(source, index) {
+    if (index < 0 || index >= source.length)
+        return undefined;
+    let characterIndex = index;
+    const codeUnit = source.charCodeAt(characterIndex);
+    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff && characterIndex > 0) {
+        const previousCodeUnit = source.charCodeAt(characterIndex - 1);
+        if (previousCodeUnit >= 0xd800 && previousCodeUnit <= 0xdbff)
+            characterIndex--;
+    }
+    const codePoint = source.codePointAt(characterIndex);
+    return codePoint === undefined ? undefined : StringFromCodePoint(codePoint);
+}
+function isIdentifierPartAt(source, index) {
+    return isIdentifierChar(identifierCharacterAt(source, index));
+}
+function isIdentifierStartAt(source, index) {
+    return isIdentifierStart(identifierCharacterAt(source, index));
+}
+function isHexDigit(char) {
+    return char !== undefined && /[0-9A-Fa-f]/.test(char);
+}
+function identifierEscapeCodePoint(source, start) {
+    if (source[start] !== "\\" || source[start + 1] !== "u")
+        return undefined;
+    if (source[start + 2] === "{") {
+        let cursor = start + 3;
+        while (isHexDigit(source[cursor]))
+            cursor++;
+        if (cursor === start + 3 || source[cursor] !== "}")
+            return undefined;
+        const codePoint = Number.parseInt(source.slice(start + 3, cursor), 16);
+        if (!Number.isSafeInteger(codePoint) || codePoint < 0 || codePoint > 0x10ffff) {
+            return undefined;
+        }
+        return { codePoint, end: cursor + 1 };
+    }
+    for (let offset = 2; offset < 6; offset++) {
+        if (!isHexDigit(source[start + offset]))
+            return undefined;
+    }
+    return {
+        codePoint: Number.parseInt(source.slice(start + 2, start + 6), 16),
+        end: start + 6,
+    };
+}
+function isIdentifierEscapeStartingAt(source, index) {
+    const escape = identifierEscapeCodePoint(source, index);
+    return escape !== undefined && isIdentifierChar(StringFromCodePoint(escape.codePoint));
+}
+function identifierEscapeStartEndingAt(source, end) {
+    const fixedStart = end - "\\u0000".length;
+    const fixed = identifierEscapeCodePoint(source, fixedStart);
+    if (fixed?.end === end &&
+        isIdentifierChar(StringFromCodePoint(fixed.codePoint))) {
+        return fixedStart;
+    }
+    if (source[end - 1] !== "}")
+        return undefined;
+    let cursor = end - 2;
+    while (cursor >= 0 && isHexDigit(source[cursor]))
+        cursor--;
+    if (source[cursor] !== "{" || source[cursor - 1] !== "u" || source[cursor - 2] !== "\\") {
+        return undefined;
+    }
+    const braced = identifierEscapeCodePoint(source, cursor - 2);
+    return braced?.end === end && isIdentifierChar(StringFromCodePoint(braced.codePoint))
+        ? cursor - 2
+        : undefined;
+}
+function isIdentifierEscapeEndingAt(source, end) {
+    return identifierEscapeStartEndingAt(source, end) !== undefined;
+}
+function isIdentifierBoundaryBefore(source, index) {
+    return isIdentifierPartAt(source, index - 1) || isIdentifierEscapeEndingAt(source, index);
+}
+function isIdentifierBoundaryAfter(source, index) {
+    return isIdentifierPartAt(source, index) || isIdentifierEscapeStartingAt(source, index);
+}
+function skipLineComment(source, index) {
+    let cursor = index + 2;
+    while (cursor < source.length && !isLineTerminator(source[cursor]))
+        cursor++;
+    if (cursor >= source.length)
+        return source.length;
+    return source[cursor] === "\r" && source[cursor + 1] === "\n" ? cursor + 2 : cursor + 1;
+}
+function isStatementKeywordAt(source, index, keyword, atStatementStart) {
+    if (!atStatementStart)
+        return false;
+    if (!source.startsWith(keyword, index))
+        return false;
+    if (isIdentifierBoundaryBefore(source, index) || source[index - 1] === ".")
+        return false;
+    if (isIdentifierBoundaryAfter(source, index + keyword.length))
+        return false;
+    return true;
+}
+function skipIgnored(source, index) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (char === "/" && next === "/") {
+        return skipLineComment(source, index);
+    }
+    if (char === "/" && next === "*") {
+        const end = source.indexOf("*/", index + 2);
+        return end === -1 ? source.length : end + 2;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+        let cursor = index + 1;
+        while (cursor < source.length) {
+            if (source[cursor] === "\\") {
+                cursor += 2;
+                continue;
+            }
+            if (source[cursor] === char)
+                return cursor + 1;
+            cursor++;
+        }
+        return source.length;
+    }
+    return index;
+}
+function skipWhitespace(source, index) {
+    let cursor = index;
+    while (/\s/.test(source[cursor] ?? ""))
+        cursor++;
+    return cursor;
+}
+function hasLineTerminatorBetween(source, start, end) {
+    for (let cursor = start; cursor < end; cursor++) {
+        if (isLineTerminator(source[cursor]))
+            return true;
+    }
+    return false;
+}
+// Comments are legal wherever whitespace is, so a dynamic import can carry a
+// bundler hint between the keyword, the parentheses and the specifier. Treating
+// the comment as an unexpected character would leave the specifier unresolved.
+function skipWhitespaceAndComments(source, index) {
+    let cursor = index;
+    while (cursor < source.length) {
+        const afterWhitespace = skipWhitespace(source, cursor);
+        const char = source[afterWhitespace];
+        const next = source[afterWhitespace + 1];
+        if (char === "/" && (next === "/" || next === "*")) {
+            cursor = skipIgnored(source, afterWhitespace);
+            continue;
+        }
+        return afterWhitespace;
+    }
+    return cursor;
+}
+function nextStatementCursor(source, index) {
+    let cursor = index;
+    while (cursor < source.length) {
+        if (source[cursor] === ";")
+            return cursor + 1;
+        if (isLineTerminator(source[cursor])) {
+            return source[cursor] === "\r" && source[cursor + 1] === "\n" ? cursor + 2 : cursor + 1;
+        }
+        cursor++;
+    }
+    return source.length;
+}
+function hexDigitValue(char) {
+    if (char === undefined)
+        return -1;
+    const code = char.charCodeAt(0);
+    if (code >= 48 && code <= 57)
+        return code - 48;
+    if (code >= 65 && code <= 70)
+        return code - 55;
+    if (code >= 97 && code <= 102)
+        return code - 87;
+    return -1;
+}
+function decodeHexEscape(source, start, length) {
+    let value = 0;
+    for (let offset = 0; offset < length; offset++) {
+        const digit = hexDigitValue(source[start + offset]);
+        if (digit === -1)
+            return null;
+        value = value * 16 + digit;
+    }
+    return value;
+}
+function invalidEscapedSpecifier() {
+    throw new SyntaxError("Invalid escaped module specifier");
+}
+function isLineTerminator(char) {
+    return char === "\r" || char === "\n" || char === "\u2028" || char === "\u2029";
+}
+function decodeLiteralContents(source, start, end, allowLineTerminators) {
+    let result = "";
+    let cursor = start;
+    while (cursor < end) {
+        const char = source[cursor];
+        if (char !== "\\") {
+            if (isLineTerminator(char)) {
+                if (!allowLineTerminators)
+                    invalidEscapedSpecifier();
+                if (char === "\r") {
+                    result += "\n";
+                    cursor += source[cursor + 1] === "\n" ? 2 : 1;
+                    continue;
+                }
+            }
+            result += char;
+            cursor++;
+            continue;
+        }
+        const escaped = source[cursor + 1];
+        if (escaped === undefined || cursor + 1 >= end)
+            invalidEscapedSpecifier();
+        if (isLineTerminator(escaped)) {
+            cursor += escaped === "\r" && source[cursor + 2] === "\n" ? 3 : 2;
+            continue;
+        }
+        const simpleEscape = {
+            b: "\b",
+            f: "\f",
+            n: "\n",
+            r: "\r",
+            t: "\t",
+            v: "\v",
+        }[escaped];
+        if (simpleEscape !== undefined) {
+            result += simpleEscape;
+            cursor += 2;
+            continue;
+        }
+        if (escaped === "0") {
+            if (/[0-9]/.test(source[cursor + 2] ?? ""))
+                invalidEscapedSpecifier();
+            result += "\0";
+            cursor += 2;
+            continue;
+        }
+        if (/[1-9]/.test(escaped))
+            invalidEscapedSpecifier();
+        if (escaped === "x") {
+            const value = decodeHexEscape(source, cursor + 2, 2);
+            if (value === null || cursor + 4 > end)
+                invalidEscapedSpecifier();
+            result += StringFromCodePoint(value);
+            cursor += 4;
+            continue;
+        }
+        if (escaped === "u") {
+            if (source[cursor + 2] === "{") {
+                let escapeEnd = cursor + 3;
+                let value = 0;
+                let digitCount = 0;
+                while (escapeEnd < end && source[escapeEnd] !== "}") {
+                    const digit = hexDigitValue(source[escapeEnd]);
+                    if (digit === -1)
+                        invalidEscapedSpecifier();
+                    value = value * 16 + digit;
+                    digitCount++;
+                    escapeEnd++;
+                }
+                if (digitCount === 0 || source[escapeEnd] !== "}" || value > 0x10ffff)
+                    invalidEscapedSpecifier();
+                result += StringFromCodePoint(value);
+                cursor = escapeEnd + 1;
+                continue;
+            }
+            const value = decodeHexEscape(source, cursor + 2, 4);
+            if (value === null || cursor + 6 > end)
+                invalidEscapedSpecifier();
+            result += StringFromCodePoint(value);
+            cursor += 6;
+            continue;
+        }
+        result += escaped;
+        cursor += 2;
+    }
+    return result;
+}
+function readQuotedSpecifier(source, quoteIndex) {
+    const quote = source[quoteIndex];
+    if (quote !== '"' && quote !== "'")
+        return null;
+    let cursor = quoteIndex + 1;
+    while (cursor < source.length) {
+        if (source[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (source[cursor] === quote) {
+            const specifier = decodeLiteralContents(source, quoteIndex + 1, cursor, false);
+            return {
+                end: cursor + 1,
+                specifier,
+            };
+        }
+        cursor++;
+    }
+    return null;
+}
+function readLiteralSpecifier(source, literalIndex) {
+    const quote = source[literalIndex];
+    if (quote === '"' || quote === "'")
+        return readQuotedSpecifier(source, literalIndex);
+    if (quote !== "`")
+        return null;
+    let cursor = literalIndex + 1;
+    while (cursor < source.length) {
+        if (source[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (source[cursor] === "$" && source[cursor + 1] === "{")
+            return null;
+        if (source[cursor] === "`") {
+            const specifier = decodeLiteralContents(source, literalIndex + 1, cursor, true);
+            return {
+                end: cursor + 1,
+                specifier,
+            };
+        }
+        cursor++;
+    }
+    return null;
+}
+function skipFullTemplateLiteral(source, templateIndex, depth = 0) {
+    assertTemplateLiteralDepth(depth);
+    let cursor = templateIndex + 1;
+    while (cursor < source.length) {
+        if (source[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (source[cursor] === "`")
+            return cursor + 1;
+        if (source[cursor] === "$" && source[cursor + 1] === "{") {
+            const expressionEnd = findTemplateExpressionEnd(source, cursor + 2, depth + 1);
+            if (expressionEnd === null)
+                return source.length;
+            cursor = expressionEnd + 1;
+            continue;
+        }
+        cursor++;
+    }
+    return source.length;
+}
+function previousSignificantIndex(source, index) {
+    let cursor = index - 1;
+    while (cursor >= 0 && /\s/.test(source[cursor] ?? ""))
+        cursor--;
+    return cursor;
+}
+function lineCommentStart(source, index) {
+    let cursor = index;
+    while (cursor > 0 && !isLineTerminator(source[cursor - 1] ?? ""))
+        cursor--;
+    let quote = null;
+    for (; cursor <= index; cursor++) {
+        const char = source[cursor];
+        if (quote !== null) {
+            if (char === "\\")
+                cursor++;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "/" && source[cursor + 1] === "/")
+            return cursor;
+    }
+    return null;
+}
+function previousSignificantIndexBeforeIgnored(source, index) {
+    let cursor = index;
+    while (cursor >= 0) {
+        cursor = previousSignificantIndex(source, cursor);
+        if (cursor < 0)
+            return cursor;
+        if (source[cursor] === "/" && source[cursor - 1] === "*") {
+            const start = source.lastIndexOf("/*", cursor - 1);
+            if (start >= 0) {
+                cursor = start;
+                continue;
+            }
+        }
+        const lineStart = Math.max(source.lastIndexOf("\n", cursor), source.lastIndexOf("\r", cursor), source.lastIndexOf("\u2028", cursor), source.lastIndexOf("\u2029", cursor)) + 1;
+        if (source.lastIndexOf("//", cursor) >= lineStart) {
+            const commentStart = lineCommentStart(source, cursor);
+            if (commentStart !== null) {
+                cursor = commentStart;
+                continue;
+            }
+        }
+        return cursor;
+    }
+    return cursor;
+}
+function keywordBefore(source, index, previousTokenIndex = previousSignificantIndex(source, index)) {
+    const end = previousTokenIndex + 1;
+    let start = end;
+    while (start > 0 && isIdentifierPartAt(source, start - 1))
+        start--;
+    if (start === end)
+        return null;
+    return source.slice(start, end);
+}
+/**
+ * Whether the word ending at `previousTokenIndex` is a member name, not a keyword.
+ *
+ * Every keyword the classifier accepts as a regex prefix is also a legal
+ * property name in ES5+, so `metrics.in / 2` and `metrics.return / 2` are
+ * ordinary code in which the slash divides. Reading the word as a keyword
+ * opens a regex literal that never closes, and the scan then swallows the rest
+ * of the module — every later import disappears from nested materialization
+ * and from dependency collection alike.
+ *
+ * Covers `.name`, optional chaining `?.name` (the character before the word is
+ * `.` either way) and private fields `#name`.
+ */
+export function isMemberNameBefore(source, previousTokenIndex) {
+    const end = previousTokenIndex + 1;
+    let start = end;
+    while (start > 0 && isIdentifierPartAt(source, start - 1))
+        start--;
+    if (start === end)
+        return false;
+    const immediateBefore = previousSignificantIndex(source, start);
+    if (immediateBefore < 0)
+        return false;
+    // Most keyword-shaped identifiers are ordinary expression operands. Avoid
+    // rescanning the whole line for a comment unless the adjacent trivia can
+    // actually contain one; doing that for every `of` makes long declarations
+    // quadratic under coverage instrumentation.
+    if (source[immediateBefore] !== "/" &&
+        !hasLineTerminatorBetween(source, immediateBefore + 1, start)) {
+        const immediateChar = source[immediateBefore];
+        if (immediateChar === "#")
+            return true;
+        if (immediateChar !== ".")
+            return false;
+        return source[immediateBefore - 1] !== "." || source[immediateBefore - 2] !== ".";
+    }
+    const before = previousSignificantIndexBeforeIgnored(source, start);
+    if (before < 0)
+        return false;
+    const char = source[before];
+    if (char === "#")
+        return true;
+    if (char !== ".")
+        return false;
+    return source[before - 1] !== "." || source[before - 2] !== ".";
+}
+function restrictedStatementKeywordBeforeLabel(source, index, previousTokenIndex, rangeStart) {
+    const labelEnd = previousTokenIndex + 1;
+    let labelStart = labelEnd;
+    while (labelStart > rangeStart && isIdentifierPartAt(source, labelStart - 1))
+        labelStart--;
+    if (labelStart === labelEnd)
+        return null;
+    const beforeLabel = previousSignificantIndexBeforeIgnored(source, labelStart);
+    const keyword = keywordBefore(source, labelStart, beforeLabel);
+    if (keyword !== "break" && keyword !== "continue")
+        return null;
+    const keywordEnd = beforeLabel + 1;
+    if (hasLineTerminatorBetween(source, keywordEnd, labelStart))
+        return null;
+    if (!hasLineTerminatorBetween(source, labelEnd, index))
+        return null;
+    return keyword;
+}
+function openParenContext(source, index, previousTokenIndex) {
+    const keyword = keywordBefore(source, index, previousTokenIndex);
+    const keywordStart = previousTokenIndex - (keyword?.length ?? 0) + 1;
+    const previousKeyword = keyword === "await"
+        ? keywordBefore(source, keywordStart, previousSignificantIndexBeforeIgnored(source, keywordStart))
+        : null;
+    const isForAwaitHeader = previousKeyword === "for";
+    return {
+        index,
+        isControlCondition: keyword === "if" || keyword === "while" || keyword === "for" ||
+            keyword === "with" || keyword === "switch" || keyword === "catch" || isForAwaitHeader,
+        isForHeader: keyword === "for" || isForAwaitHeader,
+        hasSemicolon: false,
+    };
+}
+function isControlConditionCloseParen(index, rangeStart, matchingOpenParens) {
+    const openParen = matchingOpenParens.get(index);
+    return openParen !== undefined && openParen.index >= rangeStart &&
+        openParen.isControlCondition;
+}
+function isControlBlockCloseBrace(source, index, rangeStart, matchingOpenBraces, matchingOpenParens) {
+    const openBrace = matchingOpenBraces.get(index);
+    if (openBrace === undefined)
+        return false;
+    const beforeOpenBrace = openBrace.previousTokenIndex;
+    return beforeOpenBrace >= rangeStart &&
+        source[beforeOpenBrace] === ")" &&
+        isControlConditionCloseParen(beforeOpenBrace, rangeStart, matchingOpenParens);
+}
+function normalizedDeclarationPrefix(source, start, end) {
+    return source.slice(start, end).trimStart().replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n\u2028\u2029]*/g, " ");
+}
+function declarationStatementStartBefore(source, index, keywords = [
+    "async",
+    "export",
+    "function",
+]) {
+    const separatorStart = Math.max(source.lastIndexOf(";", index - 1), source.lastIndexOf("{", index - 1), source.lastIndexOf("}", index - 1)) + 1;
+    return declarationAsiBoundaryBefore(source, separatorStart, index, keywords) ?? separatorStart;
+}
+function balancedDeclarationStatementStartBefore(source, index, keywords) {
+    let cursor = index - 1;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    while (cursor >= 0) {
+        const char = source[cursor];
+        if (char === ")")
+            parenDepth++;
+        else if (char === "(" && parenDepth > 0)
+            parenDepth--;
+        else if (char === "}")
+            braceDepth++;
+        else if (char === "{" && braceDepth > 0)
+            braceDepth--;
+        else if (char === "]")
+            bracketDepth++;
+        else if (char === "[" && bracketDepth > 0)
+            bracketDepth--;
+        else if (parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+            if (char === ";" || char === "{" || char === "}") {
+                const separatorStart = cursor + 1;
+                return declarationAsiBoundaryBefore(source, separatorStart, index, keywords) ??
+                    separatorStart;
+            }
+        }
+        cursor--;
+    }
+    return declarationAsiBoundaryBefore(source, 0, index, keywords) ?? 0;
+}
+function classDeclarationStatementStartBefore(source, index) {
+    return balancedDeclarationStatementStartBefore(source, index, [
+        "class",
+        "declare",
+        "export",
+    ]);
+}
+function startsWithDeclarationKeywordAt(source, index, keywords) {
+    return keywords.some((keyword) => source.startsWith(keyword, index) &&
+        !isIdentifierBoundaryBefore(source, index) &&
+        !isIdentifierBoundaryAfter(source, index + keyword.length));
+}
+function hasDeclarationKeywordBefore(source, start, end, keywords) {
+    for (const keyword of keywords) {
+        let index = source.indexOf(keyword, start);
+        while (index >= 0 && index < end) {
+            if (!isIdentifierBoundaryBefore(source, index) &&
+                !isIdentifierBoundaryAfter(source, index + keyword.length)) {
+                return true;
+            }
+            index = source.indexOf(keyword, index + keyword.length);
+        }
+    }
+    return false;
+}
+function declarationAsiBoundaryBefore(source, start, end, keywords) {
+    let boundary = null;
+    let cursor = start;
+    while (cursor < end) {
+        const char = source[cursor];
+        if (char !== undefined && isLineTerminator(char)) {
+            const afterLine = char === "\r" && source[cursor + 1] === "\n" ? cursor + 2 : cursor + 1;
+            const previousTokenIndex = previousSignificantIndexBeforeIgnored(source, cursor);
+            const declarationStart = skipWhitespaceAndComments(source, afterLine);
+            if (previousTokenIndex >= start &&
+                canEndStatementBeforeLineTerminator(source, previousTokenIndex) &&
+                declarationStart < end &&
+                startsWithDeclarationKeywordAt(source, declarationStart, keywords)) {
+                boundary = declarationStart;
+            }
+            cursor = afterLine;
+            continue;
+        }
+        const skipped = skipIgnored(source, cursor);
+        if (skipped !== cursor) {
+            cursor = skipped;
+            continue;
+        }
+        cursor++;
+    }
+    return boundary;
+}
+function isFunctionDeclarationBlockOpenBrace(source, previousTokenIndex, matchingOpenParens) {
+    if (source[previousTokenIndex] !== ")")
+        return false;
+    const openParen = matchingOpenParens.get(previousTokenIndex);
+    if (openParen === undefined)
+        return false;
+    const declarationStart = declarationStatementStartBefore(source, openParen.index);
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, openParen.index);
+    return FUNCTION_DECLARATION_PREFIX_PATTERN.test(prefix);
+}
+function isTypeScriptFunctionDeclarationBlockOpenBrace(source, index, previousTokenIndex) {
+    const previousToken = source[previousTokenIndex];
+    if (previousToken !== ")" &&
+        previousToken !== "]" &&
+        previousToken !== "}" &&
+        !isIdentifierPartAt(source, previousTokenIndex) &&
+        !isIdentifierEscapeEndingAt(source, previousTokenIndex + 1)) {
+        return false;
+    }
+    const separatorStart = source.lastIndexOf(";", index - 1) + 1;
+    if (!hasDeclarationKeywordBefore(source, separatorStart, index, [
+        "async",
+        "export",
+        "function",
+    ])) {
+        return false;
+    }
+    const declarationStart = balancedDeclarationStatementStartBefore(source, index, [
+        "async",
+        "export",
+        "function",
+    ]);
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, index);
+    return TYPESCRIPT_FUNCTION_DECLARATION_PREFIX_PATTERN.test(prefix);
+}
+function isClassDeclarationBlockOpenBrace(source, index, previousTokenIndex, currentParen) {
+    const previousToken = source[previousTokenIndex];
+    if (previousToken !== ")" &&
+        previousToken !== "]" &&
+        previousToken !== ">" &&
+        !isIdentifierPartAt(source, previousTokenIndex) &&
+        !isIdentifierEscapeEndingAt(source, previousTokenIndex + 1)) {
+        return false;
+    }
+    const separatorStart = source.lastIndexOf(";", index - 1) + 1;
+    if (!hasDeclarationKeywordBefore(source, separatorStart, index, ["class", "export"])) {
+        return false;
+    }
+    const declarationStart = classDeclarationStatementStartBefore(source, index);
+    if (currentParen !== undefined && currentParen.index >= declarationStart)
+        return false;
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, index);
+    return CLASS_DECLARATION_PREFIX_PATTERN.test(prefix);
+}
+function isTypeScriptDeclarationBlockOpenBrace(source, index, previousTokenIndex) {
+    const previousToken = source[previousTokenIndex];
+    if (previousToken !== ">" &&
+        previousToken !== '"' &&
+        previousToken !== "'" &&
+        !isIdentifierPartAt(source, previousTokenIndex) &&
+        !isIdentifierEscapeEndingAt(source, previousTokenIndex + 1)) {
+        return false;
+    }
+    const keywords = [
+        "const",
+        "declare",
+        "enum",
+        "export",
+        "interface",
+        "module",
+        "namespace",
+    ];
+    const separatorStart = source.lastIndexOf(";", index - 1) + 1;
+    if (!hasDeclarationKeywordBefore(source, separatorStart, index, keywords)) {
+        return false;
+    }
+    const declarationStart = balancedDeclarationStatementStartBefore(source, index, keywords);
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, index);
+    return TYPESCRIPT_DECLARATION_PREFIX_PATTERN.test(prefix);
+}
+function identifierStartBefore(source, end, rangeStart) {
+    let start = end;
+    while (start > rangeStart) {
+        const escapeStart = identifierEscapeStartEndingAt(source, start);
+        if (escapeStart !== undefined && escapeStart >= rangeStart) {
+            start = escapeStart;
+            continue;
+        }
+        if (!isIdentifierPartAt(source, start - 1))
+            break;
+        start--;
+    }
+    return start;
+}
+function isIdentifierStartOrEscapeAt(source, index) {
+    const escape = identifierEscapeCodePoint(source, index);
+    if (escape !== undefined)
+        return isIdentifierStart(StringFromCodePoint(escape.codePoint));
+    return isIdentifierStartAt(source, index);
+}
+function switchClauseStartBeforeColon(source, start, colonIndex) {
+    let cursor = start;
+    let candidate = null;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    while (cursor < colonIndex) {
+        const skipped = skipIgnored(source, cursor);
+        if (skipped !== cursor) {
+            cursor = skipped;
+            continue;
+        }
+        const char = source[cursor];
+        if (char === "(")
+            parenDepth++;
+        else if (char === ")" && parenDepth > 0)
+            parenDepth--;
+        else if (char === "{")
+            braceDepth++;
+        else if (char === "}" && braceDepth > 0)
+            braceDepth--;
+        else if (char === "[")
+            bracketDepth++;
+        else if (char === "]" && bracketDepth > 0)
+            bracketDepth--;
+        if (parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+            if (source.startsWith("case", cursor) &&
+                !isIdentifierBoundaryBefore(source, cursor) &&
+                !isIdentifierBoundaryAfter(source, cursor + "case".length)) {
+                candidate = cursor;
+                cursor += "case".length;
+                continue;
+            }
+            if (source.startsWith("default", cursor) &&
+                !isIdentifierBoundaryBefore(source, cursor) &&
+                !isIdentifierBoundaryAfter(source, cursor + "default".length)) {
+                candidate = cursor;
+                cursor += "default".length;
+                continue;
+            }
+        }
+        cursor++;
+    }
+    return candidate;
+}
+function isSwitchClauseBlockOpenBrace(source, colonIndex, rangeStart, enclosingOpenBrace) {
+    const searchStart = Math.max(rangeStart, (enclosingOpenBrace?.index ?? rangeStart - 1) + 1);
+    const clauseStart = switchClauseStartBeforeColon(source, searchStart, colonIndex);
+    if (clauseStart === null)
+        return false;
+    const clausePrefix = normalizedDeclarationPrefix(source, clauseStart, colonIndex).trim();
+    return clausePrefix === "default" || /^case\b[\s\S]*\S$/.test(clausePrefix);
+}
+function canEndStatementBeforeLineTerminator(source, previousTokenIndex, completedRegexLiteralEnds) {
+    const char = source[previousTokenIndex];
+    if (char === ")" || char === "]" || char === "}")
+        return true;
+    if (char === '"' || char === "'" || char === "`")
+        return true;
+    if (char === "/") {
+        return completedRegexLiteralEnds?.has(previousTokenIndex) === true ||
+            isCompletedRegexLiteralEnd(source, previousTokenIndex);
+    }
+    if (char === "+" && source[previousTokenIndex - 1] === "+")
+        return true;
+    if (char === "-" && source[previousTokenIndex - 1] === "-")
+        return true;
+    return isIdentifierPartAt(source, previousTokenIndex) ||
+        isIdentifierEscapeEndingAt(source, previousTokenIndex + 1);
+}
+function isTypeAliasDeclarationBeforeRegex(source, regexIndex, previousTokenIndex, rangeStart) {
+    if (!hasLineTerminatorBetween(source, previousTokenIndex + 1, regexIndex) ||
+        !canEndStatementBeforeLineTerminator(source, previousTokenIndex)) {
+        return false;
+    }
+    const separatorStart = Math.max(source.lastIndexOf(";", regexIndex - 1), source.lastIndexOf("{", regexIndex - 1), source.lastIndexOf("}", regexIndex - 1)) + 1;
+    if (!hasDeclarationKeywordBefore(source, separatorStart, regexIndex, ["export", "type"])) {
+        return false;
+    }
+    const declarationStart = balancedDeclarationStatementStartBefore(source, regexIndex, [
+        "export",
+        "type",
+    ]);
+    if (declarationStart < rangeStart)
+        return false;
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, regexIndex);
+    return TYPESCRIPT_TYPE_ALIAS_PREFIX_PATTERN.test(prefix);
+}
+function isTypeScriptAmbientDeclarationBeforeRegex(source, regexIndex, previousTokenIndex, rangeStart) {
+    if (!hasLineTerminatorBetween(source, previousTokenIndex + 1, regexIndex) ||
+        !canEndStatementBeforeLineTerminator(source, previousTokenIndex)) {
+        return false;
+    }
+    const separatorStart = Math.max(source.lastIndexOf(";", regexIndex - 1), source.lastIndexOf("{", regexIndex - 1), source.lastIndexOf("}", regexIndex - 1)) + 1;
+    if (!hasDeclarationKeywordBefore(source, separatorStart, regexIndex, ["declare", "export"])) {
+        return false;
+    }
+    const declarationStart = balancedDeclarationStatementStartBefore(source, regexIndex, [
+        "declare",
+        "export",
+    ]);
+    if (declarationStart < rangeStart)
+        return false;
+    const prefix = normalizedDeclarationPrefix(source, declarationStart, regexIndex);
+    return TYPESCRIPT_AMBIENT_DECLARATION_PREFIX_PATTERN.test(prefix);
+}
+function isCompletedRegexLiteralEnd(source, endIndex) {
+    for (let start = endIndex - 1; start >= 0; start--) {
+        if (source[start] !== "/")
+            continue;
+        const before = previousSignificantIndexBeforeIgnored(source, start);
+        const beforeChar = source[before];
+        const canStart = before < 0 ||
+            (beforeChar !== undefined && "([{=,:;!~?&|+-*%^<>".includes(beforeChar)) ||
+            [
+                "case",
+                "default",
+                "delete",
+                "do",
+                "else",
+                "extends",
+                "in",
+                "instanceof",
+                "new",
+                "await",
+                "break",
+                "continue",
+                "debugger",
+                "return",
+                "throw",
+                "typeof",
+                "void",
+                "yield",
+            ].includes(keywordBefore(source, start, before) ?? "");
+        if (!canStart)
+            continue;
+        if (skipRegexLiteral(source, start) === endIndex + 1)
+            return true;
+    }
+    return false;
+}
+function isInRawJsxText(textDepth, expressionDepth) {
+    return textDepth > expressionDepth;
+}
+function isPlainStatementBlockOpenBrace(source, rangeStart, openBraceIndex, previousTokenIndex, enclosingOpenBrace, completedRegexLiteralEnds) {
+    if (previousTokenIndex < rangeStart)
+        return true;
+    if (source[previousTokenIndex] === ";" || source[previousTokenIndex] === "}")
+        return true;
+    if (hasLineTerminatorBetween(source, previousTokenIndex + 1, openBraceIndex) &&
+        canEndStatementBeforeLineTerminator(source, previousTokenIndex, completedRegexLiteralEnds)) {
+        return true;
+    }
+    if (source[previousTokenIndex] !== ":")
+        return false;
+    const labelEnd = previousSignificantIndex(source, previousTokenIndex) + 1;
+    const labelStart = identifierStartBefore(source, labelEnd, rangeStart);
+    if (labelStart < labelEnd &&
+        isIdentifierStartOrEscapeAt(source, labelStart)) {
+        const beforeLabel = previousSignificantIndex(source, labelStart);
+        if (beforeLabel < rangeStart || source[beforeLabel] === ";" || source[beforeLabel] === "}") {
+            return true;
+        }
+    }
+    return isSwitchClauseBlockOpenBrace(source, previousTokenIndex, rangeStart, enclosingOpenBrace);
+}
+function openBraceContext(source, rangeStart, index, previousTokenIndex, matchingOpenParens, currentParen, enclosingOpenBrace, completedRegexLiteralEnds) {
+    return {
+        index,
+        previousTokenIndex,
+        isDeclarationBlock: isFunctionDeclarationBlockOpenBrace(source, previousTokenIndex, matchingOpenParens) || isTypeScriptFunctionDeclarationBlockOpenBrace(source, index, previousTokenIndex) ||
+            isClassDeclarationBlockOpenBrace(source, index, previousTokenIndex, currentParen) ||
+            isTypeScriptDeclarationBlockOpenBrace(source, index, previousTokenIndex),
+        isPlainStatementBlock: isPlainStatementBlockOpenBrace(source, rangeStart, index, previousTokenIndex, enclosingOpenBrace, completedRegexLiteralEnds),
+    };
+}
+function isDeclarationBlockCloseBrace(index, matchingOpenBraces) {
+    return matchingOpenBraces.get(index)?.isDeclarationBlock === true;
+}
+function isStatementBlockCloseBrace(source, index, matchingOpenBraces) {
+    const openBrace = matchingOpenBraces.get(index);
+    if (openBrace === undefined)
+        return false;
+    const keyword = keywordBefore(source, openBrace.index, openBrace.previousTokenIndex);
+    return keyword === "try" || keyword === "catch" || keyword === "finally" ||
+        keyword === "do" || keyword === "else";
+}
+function isPlainStatementBlockCloseBrace(index, matchingOpenBraces) {
+    return matchingOpenBraces.get(index)?.isPlainStatementBlock === true;
+}
+function isArrowFunctionBodyCloseBraceAtAsiBoundary(source, index, nextTokenIndex, matchingOpenBraces) {
+    const openBrace = matchingOpenBraces.get(index);
+    if (openBrace === undefined || source[openBrace.previousTokenIndex] !== ">")
+        return false;
+    const beforeArrow = previousSignificantIndex(source, openBrace.previousTokenIndex);
+    return source[beforeArrow] === "=" &&
+        hasLineTerminatorBetween(source, index + 1, nextTokenIndex);
+}
+function isForOfKeywordBefore(source, rangeStart, currentParen, previousTokenIndex) {
+    const keywordEnd = previousTokenIndex + 1;
+    let keywordStart = keywordEnd;
+    while (keywordStart > rangeStart && /[A-Za-z_$]/.test(source[keywordStart - 1] ?? "")) {
+        keywordStart--;
+    }
+    if (source.slice(keywordStart, keywordEnd) !== "of")
+        return false;
+    const beforeKeyword = previousSignificantIndex(source, keywordStart);
+    if (beforeKeyword >= rangeStart && source[beforeKeyword] === ".")
+        return false;
+    const beforeKeywordChar = source[beforeKeyword];
+    if (!isIdentifierPartAt(source, beforeKeyword) &&
+        beforeKeywordChar !== "]" &&
+        beforeKeywordChar !== "}" &&
+        beforeKeywordChar !== ")") {
+        return false;
+    }
+    return currentParen?.isForHeader === true && !currentParen.hasSemicolon;
+}
+function createModuleDeclarationTracker(source, rangeStart) {
+    let cursor = rangeStart;
+    let atStatementStart = true;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let candidate = null;
+    return (end) => {
+        while (cursor <= end) {
+            const skipped = skipIgnored(source, cursor);
+            if (skipped !== cursor) {
+                if (source[cursor] === "/" && source[cursor + 1] === "/") {
+                    atStatementStart = true;
+                }
+                else if (source[cursor] === "/" &&
+                    source[cursor + 1] === "*" &&
+                    hasLineTerminatorBetween(source, cursor + 2, skipped - 2)) {
+                    atStatementStart = true;
+                }
+                else {
+                    atStatementStart = false;
+                }
+                cursor = skipped;
+                continue;
+            }
+            const char = source[cursor];
+            if (char === "(")
+                parenDepth++;
+            else if (char === ")" && parenDepth > 0)
+                parenDepth--;
+            else if (char === "{")
+                braceDepth++;
+            else if (char === "}" && braceDepth > 0)
+                braceDepth--;
+            else if (char === "[")
+                bracketDepth++;
+            else if (char === "]" && bracketDepth > 0)
+                bracketDepth--;
+            const atTopLevel = parenDepth === 0 && braceDepth === 0 && bracketDepth === 0;
+            if (atTopLevel && char === ";") {
+                candidate = null;
+                atStatementStart = true;
+                cursor++;
+                continue;
+            }
+            if (atTopLevel && char !== undefined && isLineTerminator(char)) {
+                atStatementStart = true;
+                cursor++;
+                continue;
+            }
+            if (/\s/.test(char ?? "")) {
+                cursor++;
+                continue;
+            }
+            if (atTopLevel && atStatementStart) {
+                if (source.startsWith("import", cursor) &&
+                    !isIdentifierBoundaryBefore(source, cursor) &&
+                    !isIdentifierBoundaryAfter(source, cursor + "import".length)) {
+                    candidate = { keyword: "import", index: cursor };
+                    atStatementStart = false;
+                    cursor += "import".length;
+                    continue;
+                }
+                if (source.startsWith("export", cursor) &&
+                    !isIdentifierBoundaryBefore(source, cursor) &&
+                    !isIdentifierBoundaryAfter(source, cursor + "export".length)) {
+                    candidate = { keyword: "export", index: cursor };
+                    atStatementStart = false;
+                    cursor += "export".length;
+                    continue;
+                }
+            }
+            if (atTopLevel)
+                atStatementStart = false;
+            cursor++;
+        }
+        return candidate;
+    };
+}
+function isCompletedModuleDeclarationBeforeRegex(source, index, previousTokenIndex, moduleDeclarationBefore) {
+    if (!hasLineTerminatorBetween(source, previousTokenIndex + 1, index))
+        return false;
+    const declaration = moduleDeclarationBefore(previousTokenIndex);
+    if (declaration === null)
+        return false;
+    const declarationSource = normalizedDeclarationPrefix(source, declaration.index, previousTokenIndex + 1).trim();
+    if (declaration.keyword === "import") {
+        return (/^import\s*["'`][\s\S]*["'`]$/.test(declarationSource) ||
+            /^import\b[\s\S]*\bfrom\s*["'`][\s\S]*["'`]$/.test(declarationSource)) && !/^import\s*[.(]/.test(declarationSource);
+    }
+    return /^export\b[\s\S]*\bfrom\s*["'`][\s\S]*["'`]$/.test(declarationSource) ||
+        /^export\s+(?:type\s+)?\{[\s\S]*\}$/.test(declarationSource);
+}
+function isCompletedLocalExportListBeforeRegex(source, index, previousTokenIndex, statementStart) {
+    if (!hasLineTerminatorBetween(source, previousTokenIndex + 1, index))
+        return false;
+    const declarationSource = normalizedDeclarationPrefix(source, statementStart, previousTokenIndex + 1).trim();
+    return /^(?:type\s+)?\{[\s\S]*\}$/.test(declarationSource);
+}
+function isPostfixNonNullAssertionBefore(source, index, rangeStart) {
+    const beforeBang = previousSignificantIndexBeforeIgnored(source, index);
+    return beforeBang >= rangeStart &&
+        !hasLineTerminatorBetween(source, beforeBang + 1, index) &&
+        canEndStatementBeforeLineTerminator(source, beforeBang);
+}
+function isCompletedTypeArgumentListBefore(source, closeIndex, rangeStart) {
+    let cursor = closeIndex - 1;
+    let angleDepth = 1;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let sawTypeContent = false;
+    while (cursor >= rangeStart) {
+        const char = source[cursor];
+        if (char === ")")
+            parenDepth++;
+        else if (char === "(" && parenDepth > 0)
+            parenDepth--;
+        else if (char === "}")
+            braceDepth++;
+        else if (char === "{" && braceDepth > 0)
+            braceDepth--;
+        else if (char === "]")
+            bracketDepth++;
+        else if (char === "[" && bracketDepth > 0)
+            bracketDepth--;
+        else if (parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+            if (char === ">") {
+                angleDepth++;
+            }
+            else if (char === "<") {
+                angleDepth--;
+                if (angleDepth === 0) {
+                    const beforeOpen = previousSignificantIndexBeforeIgnored(source, cursor);
+                    const beforeOpenChar = source[beforeOpen];
+                    return sawTypeContent && beforeOpen >= rangeStart &&
+                        (isIdentifierPartAt(source, beforeOpen) ||
+                            isIdentifierEscapeEndingAt(source, beforeOpen + 1) ||
+                            beforeOpenChar === ")" ||
+                            beforeOpenChar === "]");
+                }
+            }
+            else if (!/\s/.test(char ?? "")) {
+                sawTypeContent = true;
+            }
+        }
+        else if (!/\s/.test(char ?? "")) {
+            sawTypeContent = true;
+        }
+        cursor--;
+    }
+    return false;
+}
+function canStartRegexLiteral(source, index, rangeStart, matchingOpenBraces, matchingOpenParens, currentParen, previousTokenIndex, moduleDeclarationBefore) {
+    const previous = previousTokenIndex;
+    if (previous < rangeStart)
+        return true;
+    if (isCompletedModuleDeclarationBeforeRegex(source, index, previous, moduleDeclarationBefore))
+        return true;
+    const char = source[previous];
+    if (char === ")" &&
+        isControlConditionCloseParen(previous, rangeStart, matchingOpenParens))
+        return true;
+    if (char === "}" &&
+        (isControlBlockCloseBrace(source, previous, rangeStart, matchingOpenBraces, matchingOpenParens) ||
+            isDeclarationBlockCloseBrace(previous, matchingOpenBraces) ||
+            isStatementBlockCloseBrace(source, previous, matchingOpenBraces) ||
+            isPlainStatementBlockCloseBrace(previous, matchingOpenBraces) ||
+            isArrowFunctionBodyCloseBraceAtAsiBoundary(source, previous, index, matchingOpenBraces)))
+        return true;
+    if ((char === "+" || char === "-") &&
+        previous - 1 >= rangeStart &&
+        source[previous - 1] === char) {
+        return false;
+    }
+    if (char === "." &&
+        previous - 2 >= rangeStart &&
+        source[previous - 1] === "." &&
+        source[previous - 2] === ".") {
+        return true;
+    }
+    if (char === "!")
+        return !isPostfixNonNullAssertionBefore(source, previous, rangeStart);
+    if (char === ">" && isCompletedTypeArgumentListBefore(source, previous, rangeStart)) {
+        return false;
+    }
+    if (char !== undefined && "([{=,:;~?&|+-*%^<>".includes(char))
+        return true;
+    const keyword = keywordBefore(source, index, previous);
+    // One gate for every keyword in the list below, rather than a guard per
+    // keyword: one added later inherits it automatically.
+    if (keyword !== null && isMemberNameBefore(source, previous))
+        return false;
+    if (keyword === "of") {
+        return isForOfKeywordBefore(source, rangeStart, currentParen, previous);
+    }
+    const isKeywordRegexPrefix = [
+        "case",
+        "default",
+        "delete",
+        "do",
+        "else",
+        "extends",
+        "in",
+        "instanceof",
+        "new",
+        "await",
+        "break",
+        "continue",
+        "debugger",
+        "return",
+        "throw",
+        "typeof",
+        "void",
+        "yield",
+    ].includes(keyword ?? "");
+    if (isKeywordRegexPrefix)
+        return true;
+    if (isTypeAliasDeclarationBeforeRegex(source, index, previous, rangeStart))
+        return true;
+    if (isTypeScriptAmbientDeclarationBeforeRegex(source, index, previous, rangeStart))
+        return true;
+    return restrictedStatementKeywordBeforeLabel(source, index, previous, rangeStart) !== null;
+}
+function skipRegexLiteral(source, regexIndex) {
+    let cursor = regexIndex + 1;
+    let inCharacterClass = false;
+    while (cursor < source.length) {
+        const char = source[cursor];
+        if (char === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (char === "[" && !inCharacterClass) {
+            inCharacterClass = true;
+            cursor++;
+            continue;
+        }
+        if (char === "]" && inCharacterClass) {
+            inCharacterClass = false;
+            cursor++;
+            continue;
+        }
+        if (char === "/" && !inCharacterClass) {
+            cursor++;
+            while (/[A-Za-z]/.test(source[cursor] ?? ""))
+                cursor++;
+            return cursor;
+        }
+        cursor++;
+    }
+    return source.length;
+}
+function canStartRawJsxOpeningTag(source, index) {
+    if (source[index - 1] === "<")
+        return false;
+    const previous = previousSignificantIndex(source, index);
+    if (previous < 0)
+        return true;
+    const char = source[previous];
+    if (char !== undefined && "([{=,:;!~?&|+-*%^<>".includes(char))
+        return true;
+    if (char === "}")
+        return true;
+    const keyword = keywordBefore(source, index, previous);
+    return ["case", "default", "return", "throw", "yield"].includes(keyword ?? "");
+}
+function rawJsxTagName(source, index) {
+    if (source[index] === ">")
+        return { name: null, end: index };
+    let cursor = index;
+    while (cursor < source.length) {
+        const char = source[cursor];
+        if (char === "." ||
+            char === ":" ||
+            char === "-" ||
+            isIdentifierStartAt(source, cursor) ||
+            IDENTIFIER_PART_PATTERN.test(char ?? "")) {
+            cursor++;
+            continue;
+        }
+        break;
+    }
+    return { name: source.slice(index, cursor), end: cursor };
+}
+function findParenEnd(source, index) {
+    let cursor = index + 1;
+    let depth = 1;
+    while (cursor < source.length) {
+        const skipped = skipIgnored(source, cursor);
+        if (skipped !== cursor) {
+            cursor = skipped;
+            continue;
+        }
+        if (source[cursor] === "(")
+            depth++;
+        else if (source[cursor] === ")") {
+            depth--;
+            if (depth === 0)
+                return cursor + 1;
+        }
+        cursor++;
+    }
+    return null;
+}
+function createRawJsxLookaheadCache() {
+    return { closingTagsByStatementEnd: new Map(), statementEnds: [], statementEndCursor: 0 };
+}
+function statementEndAfter(source, start, cache) {
+    if (cache !== undefined) {
+        const ranges = cache.statementEnds;
+        let rangeIndex = Math.min(cache.statementEndCursor, ranges.length - 1);
+        if (rangeIndex >= 0) {
+            if (start < ranges[rangeIndex].start) {
+                let low = 0;
+                let high = rangeIndex;
+                while (low <= high) {
+                    const mid = Math.floor((low + high) / 2);
+                    const range = ranges[mid];
+                    if (start < range.start)
+                        high = mid - 1;
+                    else if (start >= range.end)
+                        low = mid + 1;
+                    else {
+                        cache.statementEndCursor = mid;
+                        return range.end;
+                    }
+                }
+            }
+            else {
+                while (rangeIndex < ranges.length && start >= ranges[rangeIndex].end)
+                    rangeIndex++;
+                if (rangeIndex < ranges.length &&
+                    start >= ranges[rangeIndex].start &&
+                    start < ranges[rangeIndex].end) {
+                    cache.statementEndCursor = rangeIndex;
+                    return ranges[rangeIndex].end;
+                }
+            }
+        }
+    }
+    const end = nextStatementCursor(source, start);
+    cache?.statementEnds.push({ start, end });
+    if (cache !== undefined)
+        cache.statementEndCursor = cache.statementEnds.length - 1;
+    return end;
+}
+function hasRawJsxClosingTagBeforeStatementEnd(source, name, start, cache) {
+    const statementEnd = statementEndAfter(source, start, cache);
+    const cached = cache?.closingTagsByStatementEnd.get(statementEnd);
+    const index = cached !== undefined && start >= cached.start
+        ? cached
+        : indexRawJsxClosingTags(source, start, statementEnd);
+    if (cache !== undefined && index !== cached) {
+        cache.closingTagsByStatementEnd.set(statementEnd, index);
+    }
+    const positions = index.tags.get(name);
+    if (positions !== undefined && hasPositionAtOrAfter(positions, start))
+        return true;
+    return hasRawJsxClosingTagAcrossText(source, name, start, statementEnd);
+}
+function indexRawJsxClosingTags(source, start, statementEnd) {
+    const tags = new Map();
+    let closing = source.indexOf("<", start);
+    while (closing >= 0 && closing < statementEnd) {
+        if (source[closing + 1] === "/") {
+            const tag = rawJsxTagName(source, closing + 2);
+            const afterName = source[tag.end];
+            if (tag.name !== null && tag.name !== "" &&
+                (afterName === ">" || afterName === "/" || /\s/.test(afterName ?? ""))) {
+                let positions = tags.get(tag.name);
+                if (positions === undefined) {
+                    positions = [];
+                    tags.set(tag.name, positions);
+                }
+                positions.push(closing);
+            }
+        }
+        closing = source.indexOf("<", closing + 1);
+    }
+    return { start, tags };
+}
+function identifierAt(source, index) {
+    if (!isIdentifierStartAt(source, index))
+        return null;
+    let cursor = index + 1;
+    while (cursor < source.length && isIdentifierPartAt(source, cursor))
+        cursor++;
+    return source.slice(index, cursor);
+}
+function looksLikeStatementAfterJsxTextBreak(source, index) {
+    const start = skipWhitespace(source, index);
+    const keyword = identifierAt(source, start);
+    return keyword !== null && JSX_TEXT_BREAK_STATEMENT_KEYWORDS.has(keyword);
+}
+function hasRawJsxClosingTagAcrossText(source, name, start, statementEnd) {
+    const limit = Math.min(source.length, start + MAX_RAW_JSX_TEXT_CLOSING_LOOKAHEAD);
+    let cursor = start;
+    while (cursor < limit) {
+        const char = source[cursor];
+        if (char === "<") {
+            if (source[cursor + 1] !== "/")
+                return false;
+            const tag = rawJsxTagName(source, cursor + 2);
+            const afterName = source[tag.end];
+            return tag.name === name &&
+                (afterName === ">" || afterName === "/" || /\s/.test(afterName ?? ""));
+        }
+        if (char === "{") {
+            const expressionEnd = findTemplateExpressionEnd(source, cursor + 1);
+            if (expressionEnd === null)
+                return false;
+            cursor = expressionEnd + 1;
+            continue;
+        }
+        if (char === "}" || char === ")" || char === "]")
+            return false;
+        if (cursor >= statementEnd &&
+            (char === ";" || (char !== undefined && isLineTerminator(char))) &&
+            looksLikeStatementAfterJsxTextBreak(source, cursor + 1)) {
+            return false;
+        }
+        cursor++;
+    }
+    return false;
+}
+function hasPositionAtOrAfter(positions, start) {
+    let low = 0;
+    let high = positions.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (positions[mid] < start)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    return low < positions.length;
+}
+function looksLikeTypeScriptAngleConstruct(source, tagStart, tagEnd, name, cache) {
+    if (name === null)
+        return false;
+    const next = skipWhitespaceAndComments(source, tagEnd);
+    if (source[next] === "(") {
+        const parenEnd = findParenEnd(source, next);
+        const afterParen = parenEnd === null ? -1 : skipWhitespaceAndComments(source, parenEnd);
+        if (afterParen >= 0 && source.slice(afterParen, afterParen + 2) === "=>") {
+            return true;
+        }
+    }
+    const quotedValueEnd = source[next] === '"' || source[next] === "'"
+        ? skipIgnored(source, next)
+        : next;
+    if (source[next] !== undefined &&
+        (isIdentifierStartAt(source, next) || source[next] === "(" || quotedValueEnd !== next) &&
+        !hasRawJsxClosingTagBeforeStatementEnd(source, name, quotedValueEnd, cache)) {
+        const before = previousSignificantIndex(source, tagStart);
+        return before >= 0 && "=(:,[!~?&|+-*%^<>".includes(source[before] ?? "");
+    }
+    return false;
+}
+function readRawJsxTag(source, index, options = {}) {
+    if (source[index] !== "<")
+        return null;
+    const isClosingTag = source[index + 1] === "/";
+    if (!canStartRawJsxOpeningTag(source, index) &&
+        !(isClosingTag && options.allowClosingTagAfterText === true)) {
+        return null;
+    }
+    const nameStart = isClosingTag ? index + 2 : index + 1;
+    if (source[nameStart] !== ">" && !isIdentifierStartAt(source, nameStart))
+        return null;
+    const name = rawJsxTagName(source, nameStart).name;
+    let cursor = nameStart;
+    let quote = null;
+    const expressionRanges = [];
+    while (cursor < source.length) {
+        const char = source[cursor];
+        if (quote !== null) {
+            if (char === "\\") {
+                cursor += 2;
+                continue;
+            }
+            if (char === quote)
+                quote = null;
+            cursor++;
+            continue;
         }
-        if (expected !== undefined && source.slice(start, end) !== expected) {
-            throw INVALID_ARGUMENT.create({
-                detail: `Source replacement span did not match expected text: ${expected}`,
-            });
+        if (char === '"' || char === "'") {
+            quote = char;
+            cursor++;
+            continue;
         }
-        result = result.slice(0, start) + replacement + result.slice(end);
+        if (char === "{") {
+            const expressionEnd = findTemplateExpressionEnd(source, cursor + 1);
+            if (expressionEnd === null)
+                return null;
+            expressionRanges.push({ start: cursor + 1, end: expressionEnd });
+            cursor = expressionEnd + 1;
+            continue;
+        }
+        if (char === ">") {
+            const beforeClose = previousSignificantIndex(source, cursor);
+            const isSelfClosingTag = !isClosingTag && source[beforeClose] === "/";
+            if (!isClosingTag &&
+                !isSelfClosingTag &&
+                looksLikeTypeScriptAngleConstruct(source, index, cursor + 1, name, options.lookaheadCache)) {
+                return null;
+            }
+            return {
+                end: cursor + 1,
+                expressionRanges,
+                name,
+                isClosingTag,
+                isSelfClosingTag,
+            };
+        }
+        cursor++;
     }
-    return result;
+    return null;
 }
-function isIdentifierChar(char) {
-    return char !== undefined && /[A-Za-z0-9_$]/.test(char);
+function skipRawJsxTag(source, index, lookaheadCache) {
+    return readRawJsxTag(source, index, { lookaheadCache })?.end ?? index;
 }
-function isStatementKeywordAt(source, index, keyword) {
-    if (!source.startsWith(keyword, index))
-        return false;
-    if (isIdentifierChar(source[index - 1]) || source[index - 1] === ".")
-        return false;
-    if (isIdentifierChar(source[index + keyword.length]))
-        return false;
-    const lineStart = source.lastIndexOf("\n", index - 1) + 1;
-    return /^[\t ]*$/.test(source.slice(lineStart, index));
+function skipRawJsxText(source, index) {
+    const nextTag = source.indexOf("<", index);
+    const nextExpression = source.indexOf("{", index);
+    if (nextTag === -1)
+        return nextExpression === -1 ? source.length : nextExpression;
+    if (nextExpression === -1)
+        return nextTag;
+    return Math.min(nextTag, nextExpression);
 }
-function skipIgnored(source, index) {
+function skipExpressionIgnored(source, index, rangeStart, depth, matchingOpenBraces, matchingOpenParens, currentParen, previousTokenIndex, moduleDeclarationBefore, rawJsxLookaheadCache, completedRegexLiteralEnds) {
     const char = source[index];
     const next = source[index + 1];
+    const jsxTagEnd = skipRawJsxTag(source, index, rawJsxLookaheadCache);
+    if (jsxTagEnd !== index)
+        return jsxTagEnd;
     if (char === "/" && next === "/") {
-        const newline = source.indexOf("\n", index + 2);
-        return newline === -1 ? source.length : newline + 1;
+        return skipLineComment(source, index);
     }
     if (char === "/" && next === "*") {
         const end = source.indexOf("*/", index + 2);
         return end === -1 ? source.length : end + 2;
     }
-    if (char === '"' || char === "'" || char === "`") {
-        let cursor = index + 1;
-        while (cursor < source.length) {
-            if (source[cursor] === "\\") {
-                cursor += 2;
-                continue;
-            }
-            if (source[cursor] === char)
-                return cursor + 1;
-            cursor++;
-        }
-        return source.length;
+    if (char === '"' || char === "'")
+        return skipIgnored(source, index);
+    if (char === "`")
+        return skipFullTemplateLiteral(source, index, depth + 1);
+    if (char === "/" &&
+        canStartRegexLiteral(source, index, rangeStart, matchingOpenBraces, matchingOpenParens, currentParen, previousTokenIndex, moduleDeclarationBefore)) {
+        const end = skipRegexLiteral(source, index);
+        completedRegexLiteralEnds?.add(end - 1);
+        return end;
     }
     return index;
 }
-function skipWhitespace(source, index) {
-    let cursor = index;
-    while (/\s/.test(source[cursor] ?? ""))
-        cursor++;
-    return cursor;
+function tokenIndexAfterIgnored(source, index, skipped, previousTokenIndex) {
+    const isComment = source[index] === "/" &&
+        (source[index + 1] === "/" || source[index + 1] === "*");
+    return isComment ? previousTokenIndex : Math.max(index, skipped - 1);
 }
-// Comments are legal wherever whitespace is, so a dynamic import can carry a
-// bundler hint between the keyword, the parentheses and the specifier. Treating
-// the comment as an unexpected character would leave the specifier unresolved.
-function skipWhitespaceAndComments(source, index) {
-    let cursor = index;
+function isPropertyAccessBeforeImport(source, previousTokenIndex, rangeStart) {
+    const previous = source[previousTokenIndex];
+    if (previous === "#")
+        return true;
+    if (previous !== ".")
+        return false;
+    const isSpread = previousTokenIndex - 2 >= rangeStart &&
+        source[previousTokenIndex - 1] === "." &&
+        source[previousTokenIndex - 2] === ".";
+    return !isSpread;
+}
+function findTemplateExpressionEnd(source, expressionIndex, depth = 0) {
+    assertTemplateLiteralDepth(depth);
+    let cursor = expressionIndex;
+    let braceDepth = 1;
+    const openBraces = [];
+    const matchingOpenBraces = new Map();
+    const openParens = [];
+    const matchingOpenParens = new Map();
+    let previousTokenIndex = expressionIndex - 1;
+    const moduleDeclarationBefore = createModuleDeclarationTracker(source, expressionIndex);
+    const rawJsxLookaheadCache = createRawJsxLookaheadCache();
+    const completedRegexLiteralEnds = new Set();
+    let rawJsxTextDepth = 0;
+    let rawJsxExpressionBraceDepth = 0;
+    const rawJsxExpressionBraceStack = [];
     while (cursor < source.length) {
-        const afterWhitespace = skipWhitespace(source, cursor);
-        const char = source[afterWhitespace];
-        const next = source[afterWhitespace + 1];
-        if (char === "/" && (next === "/" || next === "*")) {
-            cursor = skipIgnored(source, afterWhitespace);
+        const jsxTag = readRawJsxTag(source, cursor, {
+            allowClosingTagAfterText: isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth),
+            lookaheadCache: rawJsxLookaheadCache,
+        });
+        if (jsxTag !== null) {
+            if (jsxTag.isClosingTag) {
+                rawJsxTextDepth = Math.max(0, rawJsxTextDepth - 1);
+            }
+            else if (!jsxTag.isSelfClosingTag) {
+                rawJsxTextDepth++;
+            }
+            previousTokenIndex = jsxTag.end - 1;
+            cursor = jsxTag.end;
             continue;
         }
-        return afterWhitespace;
-    }
-    return cursor;
-}
-function nextStatementCursor(source, index) {
-    const semicolon = source.indexOf(";", index);
-    const newline = source.indexOf("\n", index);
-    const candidates = [semicolon, newline].filter((position) => position >= 0);
-    if (candidates.length === 0)
-        return source.length;
-    return Math.min(...candidates) + 1;
-}
-function readQuotedSpecifier(source, quoteIndex) {
-    const quote = source[quoteIndex];
-    if (quote !== '"' && quote !== "'")
-        return null;
-    let cursor = quoteIndex + 1;
-    while (cursor < source.length) {
-        if (source[cursor] === "\\") {
-            cursor += 2;
+        if (isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth)) {
+            const textEnd = skipRawJsxText(source, cursor);
+            if (textEnd !== cursor) {
+                cursor = textEnd;
+                continue;
+            }
+        }
+        const skipped = skipExpressionIgnored(source, cursor, expressionIndex, depth, matchingOpenBraces, matchingOpenParens, openParens.at(-1), previousTokenIndex, moduleDeclarationBefore, rawJsxLookaheadCache, completedRegexLiteralEnds);
+        if (skipped !== cursor) {
+            previousTokenIndex = tokenIndexAfterIgnored(source, cursor, skipped, previousTokenIndex);
+            cursor = skipped;
             continue;
         }
-        if (source[cursor] === quote) {
-            return {
-                end: cursor + 1,
-                specifier: source.slice(quoteIndex + 1, cursor),
-            };
+        if (source[cursor] === "{") {
+            const isRawJsxExpressionBrace = isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth);
+            rawJsxExpressionBraceStack.push(isRawJsxExpressionBrace);
+            if (isRawJsxExpressionBrace)
+                rawJsxExpressionBraceDepth++;
+            openBraces.push(openBraceContext(source, expressionIndex, cursor, previousTokenIndex, matchingOpenParens, openParens.at(-1), openBraces.at(-1), completedRegexLiteralEnds));
+            braceDepth++;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
         }
+        if (source[cursor] === "}") {
+            braceDepth--;
+            if (braceDepth === 0)
+                return cursor;
+            const isRawJsxExpressionBrace = rawJsxExpressionBraceStack.pop();
+            if (isRawJsxExpressionBrace) {
+                rawJsxExpressionBraceDepth = Math.max(0, rawJsxExpressionBraceDepth - 1);
+            }
+            const openBrace = openBraces.pop();
+            if (openBrace !== undefined)
+                matchingOpenBraces.set(cursor, openBrace);
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (source[cursor] === "(") {
+            openParens.push(openParenContext(source, cursor, previousTokenIndex));
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (source[cursor] === ")") {
+            const openParen = openParens.pop();
+            if (openParen !== undefined)
+                matchingOpenParens.set(cursor, openParen);
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (source[cursor] === ";" && openParens.at(-1)?.isForHeader) {
+            openParens.at(-1).hasSemicolon = true;
+        }
+        if (!/\s/.test(source[cursor] ?? ""))
+            previousTokenIndex = cursor;
         cursor++;
     }
     return null;
 }
-function findFromSpan(source, statementStart, matcher) {
+function findFromSpan(source, statementStart, matcher, isExportDeclaration) {
     let cursor = statementStart;
+    let previousTokenIndex = previousSignificantIndexBeforeIgnored(source, statementStart);
+    const matchingOpenBraces = new Map();
+    const matchingOpenParens = new Map();
+    const moduleDeclarationBefore = () => null;
     while (cursor < source.length) {
         const skipped = skipIgnored(source, cursor);
         if (skipped !== cursor) {
+            previousTokenIndex = tokenIndexAfterIgnored(source, cursor, skipped, previousTokenIndex);
             cursor = skipped;
             continue;
         }
         if (source[cursor] === ";")
             return null;
+        if (isExportDeclaration &&
+            source[cursor] === "/" &&
+            isCompletedLocalExportListBeforeRegex(source, cursor, previousTokenIndex, statementStart)) {
+            return null;
+        }
+        if (source[cursor] === "/" &&
+            canStartRegexLiteral(source, cursor, statementStart, matchingOpenBraces, matchingOpenParens, undefined, previousTokenIndex, moduleDeclarationBefore)) {
+            cursor = skipRegexLiteral(source, cursor);
+            previousTokenIndex = cursor - 1;
+            continue;
+        }
         if (source.startsWith("from", cursor) &&
-            !isIdentifierChar(source[cursor - 1]) &&
-            !isIdentifierChar(source[cursor + 4])) {
-            const quoteIndex = skipWhitespace(source, cursor + 4);
+            !isIdentifierPartAt(source, cursor - 1) &&
+            !isIdentifierPartAt(source, cursor + 4)) {
+            const quoteIndex = skipWhitespaceAndComments(source, cursor + 4);
             const quoted = readQuotedSpecifier(source, quoteIndex);
             if (!quoted) {
                 cursor++;
@@ -146,10 +1709,21 @@ function findFromSpan(source, statementStart, matcher) {
                 end: quoted.end,
             };
         }
+        if (!/\s/.test(source[cursor] ?? ""))
+            previousTokenIndex = cursor;
         cursor++;
     }
     return null;
 }
+function canExportHaveFromClause(source, statementStart) {
+    let cursor = skipWhitespaceAndComments(source, statementStart);
+    if (source.startsWith("type", cursor) &&
+        !isIdentifierPartAt(source, cursor - 1) &&
+        !isIdentifierPartAt(source, cursor + "type".length)) {
+        cursor = skipWhitespaceAndComments(source, cursor + "type".length);
+    }
+    return source[cursor] === "*" || source[cursor] === "{";
+}
 /**
  * Validate the match bound every scanner requires.
  *
@@ -170,97 +1744,368 @@ export function findStaticImportFromSpans(source, matcher, maxMatches) {
     assertMaxMatches(maxMatches);
     const spans = [];
     let cursor = 0;
+    let atStatementStart = true;
+    const openBraces = [];
+    const matchingOpenBraces = new Map();
+    const openParens = [];
+    const matchingOpenParens = new Map();
+    let previousTokenIndex = -1;
+    const moduleDeclarationBefore = createModuleDeclarationTracker(source, 0);
+    const completedRegexLiteralEnds = new Set();
+    let rawJsxTextDepth = 0;
+    let rawJsxExpressionBraceDepth = 0;
+    const rawJsxExpressionBraceStack = [];
+    const rawJsxLookaheadCache = createRawJsxLookaheadCache();
     while (cursor < source.length) {
-        const skipped = skipIgnored(source, cursor);
+        const char = source[cursor];
+        const jsxTag = readRawJsxTag(source, cursor, {
+            allowClosingTagAfterText: isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth),
+            lookaheadCache: rawJsxLookaheadCache,
+        });
+        if (jsxTag !== null) {
+            if (jsxTag.isClosingTag) {
+                rawJsxTextDepth = Math.max(0, rawJsxTextDepth - 1);
+            }
+            else if (!jsxTag.isSelfClosingTag) {
+                rawJsxTextDepth++;
+            }
+            atStatementStart = false;
+            previousTokenIndex = jsxTag.end - 1;
+            cursor = jsxTag.end;
+            continue;
+        }
+        if (isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth)) {
+            const textEnd = skipRawJsxText(source, cursor);
+            if (textEnd !== cursor) {
+                atStatementStart = false;
+                cursor = textEnd;
+                continue;
+            }
+        }
+        const skipped = skipExpressionIgnored(source, cursor, 0, 0, matchingOpenBraces, matchingOpenParens, openParens.at(-1), previousTokenIndex, moduleDeclarationBefore, rawJsxLookaheadCache, completedRegexLiteralEnds);
         if (skipped !== cursor) {
+            if (char === "/" && source[cursor + 1] === "/")
+                atStatementStart = true;
+            else if (char === "/" && source[cursor + 1] === "*") {
+                if (hasLineTerminatorBetween(source, cursor + 2, skipped - 2))
+                    atStatementStart = true;
+            }
+            else
+                atStatementStart = false;
+            previousTokenIndex = tokenIndexAfterIgnored(source, cursor, skipped, previousTokenIndex);
             cursor = skipped;
             continue;
         }
-        const isImport = isStatementKeywordAt(source, cursor, "import");
-        const isExport = isStatementKeywordAt(source, cursor, "export");
+        if (char === "{") {
+            const isRawJsxExpressionBrace = isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth);
+            rawJsxExpressionBraceStack.push(isRawJsxExpressionBrace);
+            if (isRawJsxExpressionBrace)
+                rawJsxExpressionBraceDepth++;
+            openBraces.push(openBraceContext(source, 0, cursor, previousTokenIndex, matchingOpenParens, openParens.at(-1), openBraces.at(-1), completedRegexLiteralEnds));
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "}") {
+            const isRawJsxExpressionBrace = rawJsxExpressionBraceStack.pop();
+            if (isRawJsxExpressionBrace) {
+                rawJsxExpressionBraceDepth = Math.max(0, rawJsxExpressionBraceDepth - 1);
+            }
+            const openBrace = openBraces.pop();
+            if (openBrace !== undefined)
+                matchingOpenBraces.set(cursor, openBrace);
+            atStatementStart = true;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "(") {
+            openParens.push(openParenContext(source, cursor, previousTokenIndex));
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ")") {
+            const openParen = openParens.pop();
+            if (openParen !== undefined)
+                matchingOpenParens.set(cursor, openParen);
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ";" && openParens.at(-1)?.isForHeader) {
+            openParens.at(-1).hasSemicolon = true;
+        }
+        if (char === ";" || (char !== undefined && isLineTerminator(char))) {
+            atStatementStart = true;
+            if (char === ";")
+                previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (/\s/.test(char ?? "")) {
+            cursor++;
+            continue;
+        }
+        const isImport = isStatementKeywordAt(source, cursor, "import", atStatementStart);
+        const isExport = isStatementKeywordAt(source, cursor, "export", atStatementStart);
         if (!isImport && !isExport) {
+            atStatementStart = false;
+            previousTokenIndex = cursor;
             cursor++;
             continue;
         }
         const keywordLength = isImport ? "import".length : "export".length;
-        const afterKeyword = skipWhitespace(source, cursor + keywordLength);
+        const afterKeyword = skipWhitespaceAndComments(source, cursor + keywordLength);
         if (isImport && source[afterKeyword] === "(") {
+            atStatementStart = false;
+            openParens.push({
+                index: afterKeyword,
+                isControlCondition: false,
+                isForHeader: false,
+                hasSemicolon: false,
+            });
+            previousTokenIndex = afterKeyword;
             cursor = afterKeyword + 1;
             continue;
         }
-        const span = findFromSpan(source, afterKeyword, matcher);
+        if (isExport && !canExportHaveFromClause(source, afterKeyword)) {
+            atStatementStart = false;
+            previousTokenIndex = cursor + keywordLength - 1;
+            cursor = afterKeyword;
+            continue;
+        }
+        const span = findFromSpan(source, afterKeyword, matcher, isExport);
         if (span) {
             spans.push(span);
             if (spans.length >= maxMatches)
                 return spans;
+            atStatementStart = false;
+            previousTokenIndex = span.end - 1;
             cursor = span.end;
             continue;
         }
+        atStatementStart = true;
         cursor = nextStatementCursor(source, afterKeyword);
+        previousTokenIndex = Math.max(previousTokenIndex, cursor - 1);
     }
     return spans;
 }
-/**
- * Find `import("…")` expressions with a literal specifier.
- *
- * The returned span covers the quoted specifier itself (quotes included), not
- * the surrounding `import(...)`, so a replacement is a bare quoted string.
- * Dynamic imports whose argument is not a string literal are skipped, since
- * their target is only known at runtime. That includes an argument the literal
- * merely starts: rewriting the `"./foo"` in `import("./foo" + suffix)` would
- * build a path out of a resolved prefix and an unresolved tail.
- *
- * `maxMatches` bounds the scan on the same terms as
- * {@link findStaticImportFromSpans}.
- */
-export function findDynamicImportSpans(source, matcher, maxMatches) {
-    assertMaxMatches(maxMatches);
-    const spans = [];
-    let cursor = 0;
-    while (cursor < source.length) {
-        const skipped = skipIgnored(source, cursor);
-        if (skipped !== cursor) {
+function scanTemplateExpressionDynamicImports(source, templateIndex, rangeEnd, matcher, maxMatches, spans) {
+    let cursor = templateIndex + 1;
+    while (cursor < rangeEnd && cursor < source.length) {
+        if (source[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (source[cursor] === "`")
+            return cursor + 1;
+        if (source[cursor] === "$" && source[cursor + 1] === "{") {
+            const expressionStart = cursor + 2;
+            const expressionEnd = findTemplateExpressionEnd(source, expressionStart);
+            if (expressionEnd === null)
+                return source.length;
+            scanDynamicImportRange(source, expressionStart, expressionEnd, matcher, maxMatches, spans);
+            if (spans.length >= maxMatches)
+                return expressionEnd + 1;
+            cursor = expressionEnd + 1;
+            continue;
+        }
+        cursor++;
+    }
+    return source.length;
+}
+function scanDynamicImportRange(source, rangeStart, rangeEnd, matcher, maxMatches, spans) {
+    let cursor = rangeStart;
+    const openBraces = [];
+    const matchingOpenBraces = new Map();
+    const openParens = [];
+    const matchingOpenParens = new Map();
+    let previousTokenIndex = rangeStart - 1;
+    let rawJsxTextDepth = 0;
+    let rawJsxExpressionBraceDepth = 0;
+    const rawJsxExpressionBraceStack = [];
+    const moduleDeclarationBefore = createModuleDeclarationTracker(source, rangeStart);
+    const rawJsxLookaheadCache = createRawJsxLookaheadCache();
+    const completedRegexLiteralEnds = new Set();
+    while (cursor < rangeEnd) {
+        const char = source[cursor];
+        const next = source[cursor + 1];
+        const jsxTag = readRawJsxTag(source, cursor, {
+            allowClosingTagAfterText: isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth),
+            lookaheadCache: rawJsxLookaheadCache,
+        });
+        if (jsxTag !== null) {
+            for (const range of jsxTag.expressionRanges) {
+                scanDynamicImportRange(source, range.start, range.end, matcher, maxMatches, spans);
+                if (spans.length >= maxMatches)
+                    return;
+            }
+            if (jsxTag.isClosingTag) {
+                rawJsxTextDepth = Math.max(0, rawJsxTextDepth - 1);
+            }
+            else if (!jsxTag.isSelfClosingTag) {
+                rawJsxTextDepth++;
+            }
+            previousTokenIndex = jsxTag.end - 1;
+            cursor = jsxTag.end;
+            continue;
+        }
+        if (isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth)) {
+            const textEnd = skipRawJsxText(source, cursor);
+            if (textEnd !== cursor) {
+                cursor = textEnd;
+                continue;
+            }
+        }
+        if ((char === "/" && (next === "/" || next === "*")) ||
+            char === '"' ||
+            char === "'") {
+            const skipped = skipIgnored(source, cursor);
+            previousTokenIndex = tokenIndexAfterIgnored(source, cursor, skipped, previousTokenIndex);
             cursor = skipped;
             continue;
         }
+        if (char === "/" &&
+            canStartRegexLiteral(source, cursor, rangeStart, matchingOpenBraces, matchingOpenParens, openParens.at(-1), previousTokenIndex, moduleDeclarationBefore)) {
+            cursor = skipRegexLiteral(source, cursor);
+            previousTokenIndex = cursor - 1;
+            completedRegexLiteralEnds.add(previousTokenIndex);
+            continue;
+        }
+        if (char === "`") {
+            cursor = scanTemplateExpressionDynamicImports(source, cursor, rangeEnd, matcher, maxMatches, spans);
+            if (spans.length >= maxMatches)
+                return;
+            previousTokenIndex = cursor - 1;
+            continue;
+        }
+        if (char === "{") {
+            const isRawJsxExpressionBrace = isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth);
+            rawJsxExpressionBraceStack.push(isRawJsxExpressionBrace);
+            if (isRawJsxExpressionBrace)
+                rawJsxExpressionBraceDepth++;
+            openBraces.push(openBraceContext(source, rangeStart, cursor, previousTokenIndex, matchingOpenParens, openParens.at(-1), openBraces.at(-1), completedRegexLiteralEnds));
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "}") {
+            const isRawJsxExpressionBrace = rawJsxExpressionBraceStack.pop();
+            if (isRawJsxExpressionBrace) {
+                rawJsxExpressionBraceDepth = Math.max(0, rawJsxExpressionBraceDepth - 1);
+            }
+            const openBrace = openBraces.pop();
+            if (openBrace !== undefined)
+                matchingOpenBraces.set(cursor, openBrace);
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "(") {
+            openParens.push(openParenContext(source, cursor, previousTokenIndex));
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ")") {
+            const openParen = openParens.pop();
+            if (openParen !== undefined)
+                matchingOpenParens.set(cursor, openParen);
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ";" && openParens.at(-1)?.isForHeader) {
+            openParens.at(-1).hasSemicolon = true;
+        }
+        if (/\s/.test(char ?? "")) {
+            cursor++;
+            continue;
+        }
         // `import` used as an expression: not preceded by an identifier char or a
         // dot (which would make it `foo.import` or part of a longer word).
         if (!source.startsWith("import", cursor) ||
-            isIdentifierChar(source[cursor - 1]) ||
-            source[cursor - 1] === "." ||
-            isIdentifierChar(source[cursor + "import".length])) {
+            isIdentifierBoundaryBefore(source, cursor) ||
+            isPropertyAccessBeforeImport(source, previousTokenIndex, rangeStart) ||
+            isIdentifierBoundaryAfter(source, cursor + "import".length)) {
+            previousTokenIndex = cursor;
             cursor++;
             continue;
         }
         const parenIndex = skipWhitespaceAndComments(source, cursor + "import".length);
-        if (source[parenIndex] !== "(") {
+        if (parenIndex >= rangeEnd || source[parenIndex] !== "(") {
+            previousTokenIndex = cursor;
             cursor++;
             continue;
         }
-        const quoteIndex = skipWhitespaceAndComments(source, parenIndex + 1);
-        const quoted = readQuotedSpecifier(source, quoteIndex);
-        if (!quoted) {
+        // The scanner jumps directly from `import` to its argument, so record the
+        // opening parenthesis that the ordinary character walk does not visit.
+        openParens.push({
+            index: parenIndex,
+            isControlCondition: false,
+            isForHeader: false,
+            hasSemicolon: false,
+        });
+        const literalIndex = skipWhitespaceAndComments(source, parenIndex + 1);
+        if (literalIndex >= rangeEnd) {
+            previousTokenIndex = parenIndex;
+            cursor = parenIndex + 1;
+            continue;
+        }
+        const literal = readLiteralSpecifier(source, literalIndex);
+        if (!literal || literal.end > rangeEnd) {
+            previousTokenIndex = parenIndex;
             cursor = parenIndex + 1;
             continue;
         }
         // The literal must be the whole first argument. `)` closes the call and `,`
         // starts the import-attributes argument; anything else (`+`, a template
         // continuation, a ternary) means the runtime specifier is not this string.
-        const afterSpecifier = skipWhitespaceAndComments(source, quoted.end);
-        const isWholeArgument = source[afterSpecifier] === ")" || source[afterSpecifier] === ",";
-        const matchedPath = isWholeArgument ? matcher(quoted.specifier) : null;
+        const afterSpecifier = skipWhitespaceAndComments(source, literal.end);
+        const isWholeArgument = afterSpecifier < rangeEnd &&
+            (source[afterSpecifier] === ")" || source[afterSpecifier] === ",");
+        const matchedPath = isWholeArgument ? matcher(literal.specifier) : null;
         if (matchedPath) {
             spans.push({
-                original: source.slice(quoteIndex, quoted.end),
+                original: source.slice(literalIndex, literal.end),
                 path: matchedPath,
-                start: quoteIndex,
-                end: quoted.end,
+                start: literalIndex,
+                end: literal.end,
             });
             if (spans.length >= maxMatches)
-                return spans;
+                return;
         }
-        cursor = quoted.end;
+        previousTokenIndex = literal.end - 1;
+        cursor = literal.end;
     }
+}
+/**
+ * Find `import("…")` expressions with a literal specifier.
+ *
+ * The returned span covers the quoted specifier itself (quotes included), not
+ * the surrounding `import(...)`, so a replacement is a bare quoted string.
+ *
+ * A literal here is a single- or double-quoted string, or a backtick template
+ * with no `${}` substitution — the three forms whose target is fully known at
+ * scan time. An interpolated template and any other expression are skipped,
+ * since their target is only known at runtime. So is an argument the literal
+ * merely starts: rewriting the `"./foo"` in `import("./foo" + suffix)` would
+ * build a path out of a resolved prefix and an unresolved tail.
+ *
+ * The scan also runs inside template substitutions, so a dynamic import nested
+ * in a `${…}` expression is found.
+ *
+ * `maxMatches` bounds the scan on the same terms as
+ * {@link findStaticImportFromSpans}.
+ */
+export function findDynamicImportSpans(source, matcher, maxMatches) {
+    assertMaxMatches(maxMatches);
+    const spans = [];
+    scanDynamicImportRange(source, 0, source.length, matcher, maxMatches, spans);
     return spans;
 }
 /**
@@ -273,34 +2118,140 @@ export function findStaticSideEffectImportSpans(source, matcher, maxMatches) {
     assertMaxMatches(maxMatches);
     const spans = [];
     let cursor = 0;
+    let atStatementStart = true;
+    const openBraces = [];
+    const matchingOpenBraces = new Map();
+    const openParens = [];
+    const matchingOpenParens = new Map();
+    let previousTokenIndex = -1;
+    const moduleDeclarationBefore = createModuleDeclarationTracker(source, 0);
+    const completedRegexLiteralEnds = new Set();
+    let rawJsxTextDepth = 0;
+    let rawJsxExpressionBraceDepth = 0;
+    const rawJsxExpressionBraceStack = [];
+    const rawJsxLookaheadCache = createRawJsxLookaheadCache();
     while (cursor < source.length) {
-        const skipped = skipIgnored(source, cursor);
+        const char = source[cursor];
+        const jsxTag = readRawJsxTag(source, cursor, {
+            allowClosingTagAfterText: isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth),
+            lookaheadCache: rawJsxLookaheadCache,
+        });
+        if (jsxTag !== null) {
+            if (jsxTag.isClosingTag) {
+                rawJsxTextDepth = Math.max(0, rawJsxTextDepth - 1);
+            }
+            else if (!jsxTag.isSelfClosingTag) {
+                rawJsxTextDepth++;
+            }
+            atStatementStart = false;
+            previousTokenIndex = jsxTag.end - 1;
+            cursor = jsxTag.end;
+            continue;
+        }
+        if (isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth)) {
+            const textEnd = skipRawJsxText(source, cursor);
+            if (textEnd !== cursor) {
+                atStatementStart = false;
+                cursor = textEnd;
+                continue;
+            }
+        }
+        const skipped = skipExpressionIgnored(source, cursor, 0, 0, matchingOpenBraces, matchingOpenParens, openParens.at(-1), previousTokenIndex, moduleDeclarationBefore, rawJsxLookaheadCache, completedRegexLiteralEnds);
         if (skipped !== cursor) {
+            if (char === "/" && source[cursor + 1] === "/")
+                atStatementStart = true;
+            else if (char === "/" && source[cursor + 1] === "*") {
+                if (hasLineTerminatorBetween(source, cursor + 2, skipped - 2))
+                    atStatementStart = true;
+            }
+            else
+                atStatementStart = false;
+            previousTokenIndex = tokenIndexAfterIgnored(source, cursor, skipped, previousTokenIndex);
             cursor = skipped;
             continue;
         }
-        if (!isStatementKeywordAt(source, cursor, "import")) {
+        if (char === "{") {
+            const isRawJsxExpressionBrace = isInRawJsxText(rawJsxTextDepth, rawJsxExpressionBraceDepth);
+            rawJsxExpressionBraceStack.push(isRawJsxExpressionBrace);
+            if (isRawJsxExpressionBrace)
+                rawJsxExpressionBraceDepth++;
+            openBraces.push(openBraceContext(source, 0, cursor, previousTokenIndex, matchingOpenParens, openParens.at(-1), openBraces.at(-1), completedRegexLiteralEnds));
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "}") {
+            const isRawJsxExpressionBrace = rawJsxExpressionBraceStack.pop();
+            if (isRawJsxExpressionBrace) {
+                rawJsxExpressionBraceDepth = Math.max(0, rawJsxExpressionBraceDepth - 1);
+            }
+            const openBrace = openBraces.pop();
+            if (openBrace !== undefined)
+                matchingOpenBraces.set(cursor, openBrace);
+            atStatementStart = true;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === "(") {
+            openParens.push(openParenContext(source, cursor, previousTokenIndex));
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ")") {
+            const openParen = openParens.pop();
+            if (openParen !== undefined)
+                matchingOpenParens.set(cursor, openParen);
+            atStatementStart = false;
+            previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (char === ";" && openParens.at(-1)?.isForHeader) {
+            openParens.at(-1).hasSemicolon = true;
+        }
+        if (char === ";" || (char !== undefined && isLineTerminator(char))) {
+            atStatementStart = true;
+            if (char === ";")
+                previousTokenIndex = cursor;
+            cursor++;
+            continue;
+        }
+        if (/\s/.test(char ?? "")) {
+            cursor++;
+            continue;
+        }
+        if (!isStatementKeywordAt(source, cursor, "import", atStatementStart)) {
+            atStatementStart = false;
+            previousTokenIndex = cursor;
             cursor++;
             continue;
         }
-        const quoteIndex = skipWhitespace(source, cursor + "import".length);
-        const quoted = readQuotedSpecifier(source, quoteIndex);
-        if (!quoted) {
-            cursor = nextStatementCursor(source, quoteIndex);
+        const literalIndex = skipWhitespaceAndComments(source, cursor + "import".length);
+        const literal = readLiteralSpecifier(source, literalIndex);
+        if (!literal) {
+            atStatementStart = true;
+            cursor = nextStatementCursor(source, literalIndex);
+            previousTokenIndex = Math.max(previousTokenIndex, cursor - 1);
             continue;
         }
-        const matchedPath = matcher(quoted.specifier);
+        const matchedPath = matcher(literal.specifier);
         if (matchedPath) {
             spans.push({
-                original: source.slice(cursor, quoted.end),
+                original: source.slice(cursor, literal.end),
                 path: matchedPath,
                 start: cursor,
-                end: quoted.end,
+                end: literal.end,
             });
             if (spans.length >= maxMatches)
                 return spans;
         }
-        cursor = quoted.end;
+        atStatementStart = false;
+        previousTokenIndex = literal.end - 1;
+        cursor = literal.end;
     }
     return spans;
 }