clinkx 0.2.3 → 1.0.0

package/dist/context-builder/codemap.js

@@ -0,0 +1,675 @@
+export function buildFileCodemap(relPath, content) {
+    const language = languageForPath(relPath);
+    if (language === "unknown") {
+        return { path: relPath, language, symbols: [] };
+    }
+    // Coordinates are relative to the content passed here. Callers that pass
+    // selected slices remap these lines back to source coordinates via
+    // remapCodemapToSourceCoordinates (bundle.ts does this using each file's
+    // selection ranges).
+    const lines = content.split(/\r?\n/);
+    return {
+        path: relPath,
+        language,
+        symbols: language === "py"
+            ? scanPython(lines)
+            : scanBraceLanguage(lines, language),
+    };
+}
+// Remaps a codemap's content-relative symbol lines back to source-file
+// coordinates. The rendered content at 1-based line i corresponds to source
+// line = expand(ranges)[i-1], where expand flattens each range's
+// start_line..end_line in order. Out-of-bounds indices clamp to the last valid
+// source line. Empty ranges leave the map unchanged. Pure: input is not mutated.
+export function remapCodemapToSourceCoordinates(map, ranges) {
+    if (ranges.length === 0) {
+        return map;
+    }
+    const sourceLines = [];
+    for (const range of ranges) {
+        for (let line = range.start_line; line <= range.end_line; line += 1) {
+            sourceLines.push(line);
+        }
+    }
+    if (sourceLines.length === 0) {
+        return map;
+    }
+    const lastSourceLine = sourceLines[sourceLines.length - 1];
+    const toSource = (renderedLine) => {
+        const index = renderedLine - 1;
+        if (index < 0) {
+            return sourceLines[0];
+        }
+        return sourceLines[index] ?? lastSourceLine;
+    };
+    return {
+        ...map,
+        symbols: map.symbols.map((symbol) => ({
+            ...symbol,
+            start_line: toSource(symbol.start_line),
+            end_line: toSource(symbol.end_line),
+        })),
+    };
+}
+export function renderCodemapJsonl(maps) {
+    if (maps.length === 0) {
+        return "";
+    }
+    return `${maps.map((map) => JSON.stringify(map)).join("\n")}\n`;
+}
+function languageForPath(path) {
+    const lowerPath = path.toLowerCase();
+    if (/\.(ts|tsx|mts|cts)$/.test(lowerPath)) {
+        return "ts";
+    }
+    if (/\.(js|jsx|mjs|cjs)$/.test(lowerPath)) {
+        return "js";
+    }
+    if (lowerPath.endsWith(".py")) {
+        return "py";
+    }
+    if (lowerPath.endsWith(".rs")) {
+        return "rust";
+    }
+    return "unknown";
+}
+function scanBraceLanguage(lines, language) {
+    const symbols = [];
+    let previousSignificant = "";
+    const topLevelDepths = language === "rust" ? [] : braceDepthBeforeLines(lines);
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        if (language === "rust") {
+            const rustSymbol = rustSymbolForLine(trimmed, previousSignificant);
+            if (rustSymbol != null) {
+                const endLine = endLineForBraces(lines, index);
+                symbols.push({
+                    kind: rustSymbol.kind,
+                    name: rustSymbol.name,
+                    start_line: lineNumber,
+                    end_line: endLine,
+                    scanner: "regex",
+                    confidence: "low",
+                });
+            }
+        }
+        else {
+            for (const symbol of tsJsSymbolsForLine(trimmed)) {
+                const topLevelSignature = topLevelDepths[index] === 0
+                    ? TopLevelScanner.signatureFor(lines, index, symbol)
+                    : undefined;
+                const blockStartIndex = topLevelSignature?.bodyStartLineOffset == null
+                    ? index
+                    : index + topLevelSignature.bodyStartLineOffset;
+                const endLine = symbol.kind === "import" || symbol.kind === "export"
+                    ? lineNumber
+                    : endLineForBraces(lines, blockStartIndex);
+                const scanner = topLevelSignature == null
+                    ? "regex"
+                    : "toplevel";
+                const confidence = topLevelSignature == null
+                    ? "low"
+                    : "high";
+                symbols.push({
+                    kind: symbol.kind,
+                    name: symbol.name,
+                    start_line: lineNumber,
+                    end_line: endLine,
+                    scanner,
+                    confidence,
+                    ...(topLevelSignature?.signature != null
+                        ? { signature: topLevelSignature.signature }
+                        : {}),
+                    ...(topLevelSignature?.exported === true || symbol.exported === true
+                        ? { exported: true }
+                        : {}),
+                    ...(symbol.container != null ? { container: symbol.container } : {}),
+                });
+            }
+        }
+        previousSignificant = trimmed;
+    });
+    return symbols;
+}
+function tsJsSymbolsForLine(line) {
+    const symbols = [];
+    const importMatch = line.match(/^import(?:\s+type)?(?:\s+[\s\S]*?\s+from)?\s+["']([^"']+)["'];?$/);
+    if (importMatch?.[1] != null) {
+        symbols.push({ kind: "import", name: importMatch[1] });
+        return symbols;
+    }
+    const namedExportMatch = line.match(/^export\s*\{([^}]+)\}/);
+    if (namedExportMatch?.[1] != null) {
+        for (const name of splitExportNames(namedExportMatch[1])) {
+            symbols.push({ kind: "export", name });
+        }
+        return symbols;
+    }
+    const requireMatch = line.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\(["'][^"']+["']\)/);
+    if (requireMatch?.[1] != null) {
+        symbols.push({ kind: "import", name: requireMatch[1] });
+        return symbols;
+    }
+    const testMatch = line.match(/^(?:describe|it|test)\s*\(\s*["'`]([^"'`]+)["'`]/);
+    if (testMatch?.[1] != null) {
+        symbols.push({ kind: "test", name: testMatch[1] });
+        return symbols;
+    }
+    const functionMatch = line.match(/^(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/);
+    if (functionMatch?.[1] != null) {
+        symbols.push({
+            kind: "function",
+            name: functionMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    // Recognizes arrow-function value declarations, including TS forms with a
+    // return-type annotation between the param list and `=>` (e.g.
+    // `const f = (x: T): R => …`, `async (x): Promise<void> =>`, and the simple
+    // generic `<T>(x: T): T =>`). The optional return-type segment deliberately
+    // EXCLUDES `=` from its char class so it stops before `=>` and never swallows
+    // the arrow; an exotic function-type return (e.g. `(): () => void =>`) stays
+    // best-effort. It still requires a trailing `=>`, so plain assignments
+    // (`const X = 5`) and call expressions (`const c = make()`) do not match here
+    // and fall through to exportValueMatch / callExpressionFunctionMatch.
+    const arrowFunctionMatch = line.match(/^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:<[^>]*>\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*(?::\s*[A-Za-z_$0-9.<>,\[\]{}|&'"\s()]+?\s*)?=>/);
+    if (arrowFunctionMatch?.[1] != null) {
+        symbols.push({
+            kind: "function",
+            name: arrowFunctionMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    const callExpressionFunctionMatch = line.match(/^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:[A-Za-z_$][\w$]*\.)?[A-Za-z_$][\w$]*\s*\(/);
+    if (callExpressionFunctionMatch?.[1] != null) {
+        symbols.push({
+            kind: "function",
+            name: callExpressionFunctionMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    const classMatch = line.match(/^(?:export\s+(?:default\s+)?)?class\s+([A-Za-z_$][\w$]*)/);
+    if (classMatch?.[1] != null) {
+        symbols.push({
+            kind: "class",
+            name: classMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    const interfaceMatch = line.match(/^(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/);
+    if (interfaceMatch?.[1] != null) {
+        symbols.push({
+            kind: "interface",
+            name: interfaceMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    const typeMatch = line.match(/^(?:export\s+)?type\s+([A-Za-z_$][\w$]*)/);
+    if (typeMatch?.[1] != null) {
+        symbols.push({
+            kind: "type",
+            name: typeMatch[1],
+            ...(isExportedTsJsLine(line) ? { exported: true } : {}),
+        });
+        return symbols;
+    }
+    const exportValueMatch = line.match(/^export\s+(?:default\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)/);
+    if (exportValueMatch?.[1] != null) {
+        symbols.push({ kind: "export", name: exportValueMatch[1] });
+        return symbols;
+    }
+    const defaultExportMatch = line.match(/^export\s+default\s+([A-Za-z_$][\w$]*)/);
+    if (defaultExportMatch?.[1] != null) {
+        symbols.push({ kind: "export", name: defaultExportMatch[1] });
+    }
+    return symbols;
+}
+function rustSymbolForLine(line, previousSignificant) {
+    const pubUseMatch = line.match(/^pub\s+use\s+([^;]+);/);
+    if (pubUseMatch?.[1] != null) {
+        return { kind: "export", name: pubUseMatch[1].trim() };
+    }
+    const useMatch = line.match(/^use\s+([^;]+);/);
+    if (useMatch?.[1] != null) {
+        return { kind: "import", name: useMatch[1].trim() };
+    }
+    const functionMatch = line.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)/);
+    if (functionMatch?.[1] != null) {
+        return {
+            kind: previousSignificant === "#[test]" ? "test" : "function",
+            name: functionMatch[1],
+        };
+    }
+    const typeMatch = line.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:struct|enum|type)\s+([A-Za-z_]\w*)/);
+    if (typeMatch?.[1] != null) {
+        return { kind: "type", name: typeMatch[1] };
+    }
+    const traitMatch = line.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)/);
+    if (traitMatch?.[1] != null) {
+        return { kind: "interface", name: traitMatch[1] };
+    }
+    return undefined;
+}
+function scanPython(lines) {
+    const symbols = [];
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        const importMatch = trimmed.match(/^from\s+([\w.]+)\s+import\s+(.+)$/)
+            ?? trimmed.match(/^import\s+(.+)$/);
+        if (importMatch != null) {
+            const moduleName = importMatch[1] ?? "";
+            const importedName = importMatch[2];
+            symbols.push({
+                kind: "import",
+                name: importedName == null
+                    ? moduleName.trim()
+                    : `${moduleName.trim()}:${importedName.trim()}`,
+                start_line: lineNumber,
+                end_line: lineNumber,
+                scanner: "regex",
+                confidence: "low",
+            });
+            return;
+        }
+        const classMatch = trimmed.match(/^class\s+([A-Za-z_]\w*)/);
+        if (classMatch?.[1] != null) {
+            symbols.push({
+                kind: "class",
+                name: classMatch[1],
+                start_line: lineNumber,
+                end_line: endLineForIndentedBlock(lines, index),
+                scanner: "regex",
+                confidence: "low",
+            });
+            return;
+        }
+        const functionMatch = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)/);
+        if (functionMatch?.[1] != null) {
+            symbols.push({
+                kind: functionMatch[1].startsWith("test_") ? "test" : "function",
+                name: functionMatch[1],
+                start_line: lineNumber,
+                end_line: endLineForIndentedBlock(lines, index),
+                scanner: "regex",
+                confidence: "low",
+            });
+        }
+    });
+    return symbols;
+}
+function isExportedTsJsLine(line) {
+    return /^export\b/.test(line);
+}
+class TopLevelScanner {
+    static signatureFor(lines, startIndex, symbol) {
+        if (symbol.kind !== "function") {
+            return undefined;
+        }
+        const text = declarationWindow(lines, startIndex);
+        return parseFunctionDeclaration(text, symbol.name)
+            ?? parseArrowDeclaration(text, symbol.name);
+    }
+}
+function declarationWindow(lines, startIndex) {
+    const maxLines = 80;
+    const maxChars = 12_000;
+    return lines
+        .slice(startIndex, Math.min(lines.length, startIndex + maxLines))
+        .join("\n")
+        .slice(0, maxChars);
+}
+function parseFunctionDeclaration(text, name) {
+    const match = new RegExp(`\\bfunction\\s+${escapeRegExp(name)}\\b`).exec(text);
+    if (match == null) {
+        return undefined;
+    }
+    let cursor = match.index + match[0].length;
+    const generic = readOptionalBalanced(text, cursor, "<", ">");
+    if (generic != null) {
+        cursor = generic.end + 1;
+    }
+    cursor = skipWhitespace(text, cursor);
+    if (text[cursor] !== "(") {
+        return undefined;
+    }
+    const parameters = readBalanced(text, cursor, "(", ")");
+    if (parameters == null) {
+        return undefined;
+    }
+    cursor = skipWhitespace(text, parameters.end + 1);
+    const returnType = text[cursor] === ":"
+        ? readReturnType(text, cursor, ["{", ";"])
+        : undefined;
+    const bodyStartIndex = findBodyStartIndex(text, returnType == null ? cursor : cursor + returnType.length);
+    const signature = normalizeSignatureText(`${name}${generic?.text ?? ""}${parameters.text}${returnType ?? ""}`);
+    return signature.length === 0
+        ? undefined
+        : {
+            signature,
+            ...(bodyStartIndex != null
+                ? { bodyStartLineOffset: lineOffsetForIndex(text, bodyStartIndex) }
+                : {}),
+            ...(isExportedTsJsLine(text.trimStart()) ? { exported: true } : {}),
+        };
+}
+function parseArrowDeclaration(text, name) {
+    const match = new RegExp(`^(?:export\\s+)?(?:const|let|var)\\s+${escapeRegExp(name)}\\b`).exec(text.trimStart());
+    if (match == null) {
+        return undefined;
+    }
+    const leadingTrimmed = text.trimStart();
+    const equalsIndex = leadingTrimmed.indexOf("=", match[0].length);
+    if (equalsIndex < 0) {
+        return undefined;
+    }
+    let cursor = skipWhitespace(leadingTrimmed, equalsIndex + 1);
+    if (leadingTrimmed.startsWith("async", cursor)) {
+        cursor = skipWhitespace(leadingTrimmed, cursor + "async".length);
+    }
+    const generic = readOptionalBalanced(leadingTrimmed, cursor, "<", ">");
+    if (generic != null) {
+        cursor = skipWhitespace(leadingTrimmed, generic.end + 1);
+    }
+    let parameters;
+    if (leadingTrimmed[cursor] === "(") {
+        const balancedParameters = readBalanced(leadingTrimmed, cursor, "(", ")");
+        if (balancedParameters == null) {
+            return undefined;
+        }
+        parameters = balancedParameters.text;
+        cursor = skipWhitespace(leadingTrimmed, balancedParameters.end + 1);
+    }
+    else {
+        const parameterMatch = /^[A-Za-z_$][\w$]*/.exec(leadingTrimmed.slice(cursor));
+        if (parameterMatch?.[0] == null) {
+            return undefined;
+        }
+        parameters = `(${parameterMatch[0]})`;
+        cursor = skipWhitespace(leadingTrimmed, cursor + parameterMatch[0].length);
+    }
+    const returnType = leadingTrimmed[cursor] === ":"
+        ? readReturnType(leadingTrimmed, cursor, ["=>"])
+        : undefined;
+    const arrowIndex = findTopLevelToken(leadingTrimmed, returnType == null ? cursor : cursor + returnType.length, "=>");
+    if (arrowIndex == null) {
+        return undefined;
+    }
+    const bodyStartIndex = findBodyStartIndex(leadingTrimmed, arrowIndex + 2);
+    const signature = normalizeSignatureText(`${name}${generic?.text ?? ""}${parameters}${returnType ?? ""}`);
+    return signature.length === 0
+        ? undefined
+        : {
+            signature,
+            ...(bodyStartIndex != null
+                ? { bodyStartLineOffset: lineOffsetForIndex(leadingTrimmed, bodyStartIndex) }
+                : {}),
+            ...(isExportedTsJsLine(leadingTrimmed) ? { exported: true } : {}),
+        };
+}
+function readOptionalBalanced(text, cursor, open, close) {
+    const start = skipWhitespace(text, cursor);
+    if (text[start] !== open) {
+        return undefined;
+    }
+    return readBalanced(text, start, open, close);
+}
+function readBalanced(text, start, open, close) {
+    const depths = { paren: 0, square: 0, brace: 0, angle: 0 };
+    const openKey = bracketKey(open);
+    const closeKey = bracketKey(close);
+    depths[openKey] = 1;
+    let quote;
+    for (let index = start + 1; index < text.length; index += 1) {
+        const char = text[index];
+        const previous = text[index - 1];
+        if (char == null) {
+            return undefined;
+        }
+        if (quote != null) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        updateDepths(depths, char, previous);
+        if (char === close && depths[closeKey] === 0) {
+            return { text: text.slice(start, index + 1), end: index };
+        }
+    }
+    return undefined;
+}
+function readReturnType(text, colonIndex, terminators) {
+    const depths = { paren: 0, square: 0, brace: 0, angle: 0 };
+    let quote;
+    for (let index = colonIndex + 1; index < text.length; index += 1) {
+        const char = text[index];
+        const previous = text[index - 1];
+        if (char == null) {
+            break;
+        }
+        if (quote != null) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (allDepthsZero(depths) && matchesTerminator(text, index, terminators)) {
+            if (char !== "{" || isReturnTypeObjectStart(text, colonIndex, index)) {
+                updateDepths(depths, char, previous);
+                continue;
+            }
+            return text.slice(colonIndex, index).trimEnd();
+        }
+        updateDepths(depths, char, previous);
+    }
+    const raw = text.slice(colonIndex).trimEnd();
+    return raw.length === 0 ? undefined : raw;
+}
+function findTopLevelToken(text, start, token) {
+    const depths = { paren: 0, square: 0, brace: 0, angle: 0 };
+    let quote;
+    for (let index = start; index < text.length; index += 1) {
+        const char = text[index];
+        const previous = text[index - 1];
+        if (char == null) {
+            return undefined;
+        }
+        if (quote != null) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (allDepthsZero(depths) && text.startsWith(token, index)) {
+            return index;
+        }
+        updateDepths(depths, char, previous);
+    }
+    return undefined;
+}
+function updateDepths(depths, char, previous) {
+    if (char === "(") {
+        depths.paren += 1;
+    }
+    else if (char === ")") {
+        depths.paren = Math.max(0, depths.paren - 1);
+    }
+    else if (char === "[") {
+        depths.square += 1;
+    }
+    else if (char === "]") {
+        depths.square = Math.max(0, depths.square - 1);
+    }
+    else if (char === "{") {
+        depths.brace += 1;
+    }
+    else if (char === "}") {
+        depths.brace = Math.max(0, depths.brace - 1);
+    }
+    else if (char === "<") {
+        depths.angle += 1;
+    }
+    else if (char === ">" && previous !== "=") {
+        depths.angle = Math.max(0, depths.angle - 1);
+    }
+}
+function bracketKey(bracket) {
+    return bracket === "<" || bracket === ">" ? "angle" : "paren";
+}
+function allDepthsZero(depths) {
+    return depths.paren === 0
+        && depths.square === 0
+        && depths.brace === 0
+        && depths.angle === 0;
+}
+function matchesTerminator(text, index, terminators) {
+    return terminators.some((terminator) => text.startsWith(terminator, index));
+}
+function isReturnTypeObjectStart(text, colonIndex, braceIndex) {
+    const rawType = text.slice(colonIndex + 1, braceIndex).trim();
+    if (rawType.length === 0) {
+        return true;
+    }
+    const previous = previousNonWhitespace(text, braceIndex - 1);
+    return previous != null && ":|&=,<([".includes(previous);
+}
+function previousNonWhitespace(text, start) {
+    for (let index = start; index >= 0; index -= 1) {
+        const char = text[index];
+        if (char != null && !/\s/.test(char)) {
+            return char;
+        }
+    }
+    return undefined;
+}
+function findBodyStartIndex(text, start) {
+    const cursor = skipWhitespace(text, start);
+    return text[cursor] === "{" ? cursor : undefined;
+}
+function lineOffsetForIndex(text, targetIndex) {
+    let lineOffset = 0;
+    for (let index = 0; index < targetIndex; index += 1) {
+        if (text[index] === "\n") {
+            lineOffset += 1;
+        }
+    }
+    return lineOffset;
+}
+function skipWhitespace(text, start) {
+    let cursor = start;
+    while (cursor < text.length && /\s/.test(text[cursor] ?? "")) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function normalizeSignatureText(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .replace(/<\s+/g, "<")
+        .replace(/\s+>/g, ">")
+        .replace(/,\s*\)/g, ")")
+        .replace(/\(\s+/g, "(")
+        .replace(/\s+\)/g, ")")
+        .trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function braceDepthBeforeLines(lines) {
+    const depths = [];
+    let depth = 0;
+    for (const line of lines) {
+        depths.push(depth);
+        const stripped = stripQuotedText(line);
+        for (const char of stripped) {
+            if (char === "{") {
+                depth += 1;
+            }
+            else if (char === "}") {
+                depth = Math.max(0, depth - 1);
+            }
+        }
+    }
+    return depths;
+}
+function splitExportNames(names) {
+    return names
+        .split(",")
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0)
+        .map((name) => {
+        const aliasMatch = name.match(/\s+as\s+([A-Za-z_$][\w$]*)$/);
+        return aliasMatch?.[1] ?? name;
+    });
+}
+function endLineForBraces(lines, startIndex) {
+    let depth = 0;
+    let sawBrace = false;
+    for (let index = startIndex; index < lines.length; index += 1) {
+        const line = stripQuotedText(lines[index] ?? "");
+        for (const char of line) {
+            if (char === "{") {
+                depth += 1;
+                sawBrace = true;
+            }
+            else if (char === "}") {
+                depth -= 1;
+            }
+        }
+        if (sawBrace && depth <= 0) {
+            return index + 1;
+        }
+    }
+    return startIndex + 1;
+}
+function endLineForIndentedBlock(lines, startIndex) {
+    const startIndent = indentationOf(lines[startIndex] ?? "");
+    let lastLine = startIndex + 1;
+    for (let index = startIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#")) {
+            continue;
+        }
+        if (indentationOf(line) <= startIndent) {
+            break;
+        }
+        lastLine = index + 1;
+    }
+    return lastLine;
+}
+function indentationOf(line) {
+    const match = line.match(/^\s*/);
+    return match?.[0].length ?? 0;
+}
+function stripQuotedText(line) {
+    return line
+        .replace(/(["'`])(?:\\.|(?!\1).)*\1/g, "")
+        .replace(/\/\/.*$/, "");
+}
+//# sourceMappingURL=codemap.js.map