@zvec/zvec-grep 0.2.2 → 0.3.0-rc.2

package/dist/engine/extraction/code/extractor.js

@@ -1,696 +0,0 @@
-import { EngineError } from "../../errors.js";
-import { COMPONENT_CODE_FORMATS } from "../../code-formats.js";
-import { makeEntityId } from "../ids.js";
-import { validateSourceFile } from "../source.js";
-import { hasGrammar } from "./tree-sitter/grammar.js";
-import { withParser } from "./tree-sitter/parser.js";
-import { extractPlainTextFragments } from "../text/extractor.js";
-import { chunkOptionsForMetadata } from "../vector-content.js";
-import { resolveAdapter } from "./adapter.js";
-import { hasJavascriptTypescriptFunctionValue } from "./families/js-ts.js";
-const DEFAULT_CODE_CHUNK_CHARS = 3600;
-const DEFAULT_CODE_CHUNK_OVERLAP_CHARS = 540;
-const COMPONENT_CODE_FORMAT_SET = new Set(COMPONENT_CODE_FORMATS);
-export class CodeExtractor {
-    async extract(source, options = {}) {
-        return (await this.extractForIndexing(source, options)).map((item) => item.fragment);
-    }
-    async extractForIndexing(source, options = {}) {
-        if (source.kind !== "text" || source.file.kind !== "code") {
-            return [];
-        }
-        validateSourceFile(source);
-        const chunkOptions = resolveCodeChunkOptions(options);
-        if (isScriptBlockFormat(source.file.format)) {
-            const fragments = await this.extractScriptBlocks(source, chunkOptions);
-            return fragments.length > 0
-                ? fragments
-                : this.fallback(source, chunkOptions);
-        }
-        const adapter = resolveAdapter(source.file.format);
-        if (!hasGrammar(source.file.format) || !adapter) {
-            return this.fallback(source, chunkOptions);
-        }
-        const extracted = await withParser(source.text, source.file.format, (tree) => {
-            const collected = [];
-            walkCodeNode(tree.rootNode, adapter, [], collected);
-            const output = [];
-            let entityIdIndex = 0;
-            const appendEntity = (entity) => {
-                const fragments = codeEntityToSearchFragments(source, adapter, entity, chunkOptions.maxChunkChars, chunkOptions.chunkOverlapChars);
-                const majorId = fragments[0]?.group === ""
-                    ? makeEntityId(source.file.id, entityIdIndex)
-                    : null;
-                for (const item of fragments) {
-                    const id = makeEntityId(source.file.id, entityIdIndex);
-                    const { embeddingText, ...fragment } = item;
-                    output.push({
-                        fragment: {
-                            id,
-                            ...fragment,
-                            group: fragment.group === "" ? id : (majorId ?? fragment.group),
-                        },
-                        embeddingText,
-                    });
-                    entityIdIndex++;
-                }
-            };
-            for (const entity of collected) {
-                appendEntity(entity);
-            }
-            return output;
-        });
-        if (!extracted || extracted.length === 0) {
-            return this.fallback(source, chunkOptions);
-        }
-        return extracted;
-    }
-    fallback(source, options) {
-        return extractPlainTextFragments(source, options.maxChunkChars, options.chunkOverlapChars).map((fragment) => ({ fragment }));
-    }
-    async extractScriptBlocks(source, options) {
-        const fragments = [];
-        for (const block of findScriptBlocks(source.text)) {
-            const blockFile = {
-                ...source.file,
-                format: block.format,
-            };
-            const blockFragments = await this.extractForIndexing({
-                kind: "text",
-                file: blockFile,
-                text: block.text,
-            }, options);
-            fragments.push(...remapScriptBlockFragments(source.file.id, blockFragments, fragments.length, block.startLine, block.startOffset));
-        }
-        return fragments;
-    }
-}
-function resolveCodeChunkOptions(options) {
-    const maxChunkChars = options.maxChunkChars ?? DEFAULT_CODE_CHUNK_CHARS;
-    const chunkOverlapChars = options.chunkOverlapChars ?? DEFAULT_CODE_CHUNK_OVERLAP_CHARS;
-    if (!Number.isInteger(maxChunkChars) || maxChunkChars <= 0) {
-        throw new EngineError("Code extractor requires a positive integer chunk size", {
-            code: "ZVEC_GREP.ENGINE.EXTRACTORS.CODE_INVALID_CHUNK_SIZE",
-            context: `maxChunkChars=${maxChunkChars}`,
-        });
-    }
-    if (!Number.isInteger(chunkOverlapChars) ||
-        chunkOverlapChars < 0 ||
-        chunkOverlapChars >= maxChunkChars) {
-        throw new EngineError("Code extractor requires overlap to be smaller than chunk size", {
-            code: "ZVEC_GREP.ENGINE.EXTRACTORS.CODE_INVALID_CHUNK_OVERLAP",
-            context: `maxChunkChars=${maxChunkChars} chunkOverlapChars=${chunkOverlapChars}`,
-        });
-    }
-    return { maxChunkChars, chunkOverlapChars };
-}
-function walkCodeNode(node, adapter, breadcrumb, out) {
-    for (const child of node.children) {
-        const isScope = adapter.scopeTypes.has(child.type) &&
-            adapter.shouldEnterScope?.(child) !== false;
-        const isEntity = adapter.entityTypes.has(child.type) &&
-            adapter.shouldIndexEntity?.(child) !== false;
-        if (isEntity) {
-            const entities = adapter.resolveEntities?.(child) ?? [
-                adapter.resolveEntity ? adapter.resolveEntity(child) : child,
-            ];
-            for (const entity of entities) {
-                const name = adapter.extractName(entity);
-                const entityBreadcrumb = adapter.scopeBreadcrumb?.(entity, breadcrumb) ?? breadcrumb;
-                const symbolType = adapter.classifyNode?.(entity, entityBreadcrumb) ??
-                    classifyCodeNode(entity, entityBreadcrumb);
-                out.push({
-                    node: entity,
-                    name,
-                    symbolType,
-                    breadcrumb: entityBreadcrumb,
-                    signature: adapter.extractSignature?.(entity),
-                    doc: adapter.extractDoc?.(entity),
-                    modifiers: adapter.extractModifiers?.(entity) ?? [],
-                });
-            }
-        }
-        if (isScope) {
-            const name = adapter.extractName(child);
-            const scopeNode = adapter.enterScopeNode?.(child) ?? child;
-            walkCodeNode(scopeNode, adapter, name ? [...breadcrumb, name] : breadcrumb, out);
-            continue;
-        }
-        if (!isEntity) {
-            walkCodeNode(child, adapter, breadcrumb, out);
-        }
-    }
-}
-function codeEntityToSearchFragments(source, adapter, entity, maxChars, overlapChars) {
-    const metadata = codeEntityMetadata(entity);
-    const contentChunkOptions = chunkOptionsForMetadata({ maxChunkChars: maxChars, chunkOverlapChars: overlapChars }, metadata);
-    const contentMaxChars = contentChunkOptions.maxChunkChars;
-    if (entity.node.text.length <= contentMaxChars) {
-        return [
-            codeEntityWindowToFragment(source, entity, nodeToWindow(entity.node)),
-        ];
-    }
-    const major = {
-        group: "",
-        fileId: source.file.id,
-        range: nodeToWindow(entity.node).range,
-        content: {
-            kind: "text",
-            text: codeEntityOutline(entity, adapter, contentMaxChars),
-        },
-        metadata,
-    };
-    return [
-        major,
-        ...[
-            ...splitLargeNode(entity.node, contentMaxChars, contentChunkOptions.chunkOverlapChars),
-        ].map((window) => codeEntityWindowToFragment(source, entity, window)),
-    ];
-}
-function codeEntityWindowToFragment(source, entity, window) {
-    return {
-        fileId: source.file.id,
-        range: window.range,
-        content: {
-            kind: "text",
-            text: window.text,
-        },
-        metadata: codeEntityMetadata(entity),
-        embeddingText: window.embeddingText,
-    };
-}
-function nodeToWindow(node) {
-    return {
-        text: node.text,
-        range: {
-            kind: "text",
-            startLine: node.startPosition.row + 1,
-            endLine: node.endPosition.row + 1,
-            startOffset: node.startIndex,
-            endOffset: node.endIndex,
-        },
-    };
-}
-function* splitLargeNode(node, maxChars, overlapChars) {
-    const body = node.childForFieldName("body") ?? node;
-    const statements = body.namedChildren;
-    if (statements.length <= 1) {
-        yield* splitTextByLines(node.text, maxChars, node.startPosition.row + 1, node.startIndex, overlapChars);
-        return;
-    }
-    const baseStart = node.startIndex;
-    const source = node.text;
-    let groupStart = 0;
-    let groupChars = 0;
-    for (let index = 0; index < statements.length; index++) {
-        const statement = statements[index];
-        const statementChars = statement.text.length;
-        if (statementChars > maxChars) {
-            if (index > groupStart) {
-                yield sliceStatements(source, baseStart, statements, groupStart, index - 1);
-            }
-            yield* splitTextByLines(statement.text, maxChars, statement.startPosition.row + 1, statement.startIndex, overlapChars);
-            groupStart = index + 1;
-            groupChars = 0;
-            continue;
-        }
-        const separatorChars = index > groupStart ? 1 : 0;
-        if (groupChars + separatorChars + statementChars > maxChars &&
-            index > groupStart) {
-            yield sliceStatements(source, baseStart, statements, groupStart, index - 1);
-            const overlapStart = computeOverlapStart(statements, groupStart, index - 1, overlapChars);
-            let candidateStart = overlapStart < index ? overlapStart : index;
-            let candidateChars = statementChars;
-            for (let previous = index - 1; previous >= candidateStart; previous--) {
-                const addedChars = statements[previous].text.length + 1;
-                if (candidateChars + addedChars > maxChars) {
-                    candidateStart = previous + 1;
-                    break;
-                }
-                candidateChars += addedChars;
-            }
-            groupStart = candidateStart;
-            groupChars = candidateChars;
-            continue;
-        }
-        groupChars += separatorChars + statementChars;
-    }
-    if (groupStart < statements.length) {
-        yield sliceStatements(source, baseStart, statements, groupStart, statements.length - 1);
-    }
-}
-function sliceStatements(source, baseStart, statements, startIndex, endIndex) {
-    const start = statements[startIndex].startIndex;
-    const end = statements[endIndex].endIndex;
-    return {
-        text: source.slice(start - baseStart, end - baseStart),
-        embeddingText: statements
-            .slice(startIndex, endIndex + 1)
-            .map((statement) => statement.text)
-            .join("\n"),
-        range: {
-            kind: "text",
-            startLine: statements[startIndex].startPosition.row + 1,
-            endLine: statements[endIndex].endPosition.row + 1,
-            startOffset: start,
-            endOffset: end,
-        },
-    };
-}
-function* splitTextByLines(text, maxChars, startLine, startOffset, overlapChars) {
-    const lines = text.split("\n");
-    let lineIndex = 0;
-    let offset = startOffset;
-    while (lineIndex < lines.length) {
-        if (lines[lineIndex].length > maxChars) {
-            yield* splitLongLineByChars(lines[lineIndex], maxChars, startLine + lineIndex, offset, overlapChars);
-            offset += lines[lineIndex].length + 1;
-            lineIndex++;
-            continue;
-        }
-        let endIndex = lineIndex;
-        let usedChars = 0;
-        while (endIndex < lines.length) {
-            const lineLength = lines[endIndex].length + 1;
-            if (usedChars + lineLength > maxChars && endIndex > lineIndex) {
-                break;
-            }
-            usedChars += lineLength;
-            endIndex++;
-        }
-        const chunk = lines.slice(lineIndex, endIndex).join("\n");
-        yield {
-            text: chunk,
-            range: {
-                kind: "text",
-                startLine: startLine + lineIndex,
-                endLine: startLine + endIndex - 1,
-                startOffset: offset,
-                endOffset: offset + chunk.length,
-            },
-        };
-        if (endIndex >= lines.length) {
-            break;
-        }
-        const overlapLines = computeLineOverlap(lines, lineIndex, endIndex, overlapChars);
-        const nextIndex = endIndex - overlapLines;
-        offset += lines.slice(lineIndex, nextIndex).join("\n").length;
-        if (nextIndex > lineIndex) {
-            offset += 1;
-        }
-        lineIndex = nextIndex;
-    }
-}
-function* splitLongLineByChars(text, maxChars, line, startOffset, overlapChars) {
-    let relativeStart = 0;
-    while (relativeStart < text.length) {
-        const rawEnd = Math.min(text.length, relativeStart + maxChars);
-        const relativeEnd = safeCharacterEnd(text, relativeStart, rawEnd);
-        yield {
-            text: text.slice(relativeStart, relativeEnd),
-            range: {
-                kind: "text",
-                startLine: line,
-                endLine: line,
-                startOffset: startOffset + relativeStart,
-                endOffset: startOffset + relativeEnd,
-            },
-        };
-        if (relativeEnd >= text.length) {
-            break;
-        }
-        const rawStart = Math.max(relativeStart + 1, relativeEnd - overlapChars);
-        relativeStart = safeCharacterStart(text, rawStart);
-    }
-}
-function safeCharacterEnd(text, start, end) {
-    if (end > start &&
-        end < text.length &&
-        isHighSurrogate(text.charCodeAt(end - 1)) &&
-        isLowSurrogate(text.charCodeAt(end))) {
-        return end - 1 > start ? end - 1 : end + 1;
-    }
-    return end;
-}
-function safeCharacterStart(text, start) {
-    if (start > 0 &&
-        start < text.length &&
-        isHighSurrogate(text.charCodeAt(start - 1)) &&
-        isLowSurrogate(text.charCodeAt(start))) {
-        return start + 1;
-    }
-    return start;
-}
-function isHighSurrogate(value) {
-    return value >= 0xd800 && value <= 0xdbff;
-}
-function isLowSurrogate(value) {
-    return value >= 0xdc00 && value <= 0xdfff;
-}
-function computeOverlapStart(statements, groupStart, groupEnd, overlapChars) {
-    if (overlapChars <= 0) {
-        return groupEnd + 1;
-    }
-    let chars = 0;
-    let index = groupEnd;
-    while (index >= groupStart && chars < overlapChars) {
-        chars += statements[index].text.length;
-        if (index < groupEnd) {
-            chars++;
-        }
-        index--;
-    }
-    return index + 1;
-}
-function computeLineOverlap(lines, startIndex, endIndex, overlapChars) {
-    if (overlapChars <= 0) {
-        return 0;
-    }
-    let chars = 0;
-    let count = 0;
-    for (let index = endIndex - 1; index >= startIndex; index--) {
-        chars += lines[index].length + 1;
-        if (chars > overlapChars) {
-            break;
-        }
-        count++;
-    }
-    return Math.min(count, Math.floor((endIndex - startIndex) / 2));
-}
-const STRUCTURAL_SYMBOL_TYPES = new Set([
-    "class",
-    "interface",
-    "module",
-]);
-const OUTLINE_MAX_MEMBERS = 32;
-const OUTLINE_MAX_CALLS = 24;
-const OUTLINE_MAX_LINE_CHARS = 180;
-function codeEntityOutline(entity, adapter, maxChars) {
-    const header = extractCodeHeader(entity.node.text);
-    const lines = [
-        header.length > 0 ? header : (entity.name ?? entity.symbolType),
-    ];
-    if (STRUCTURAL_SYMBOL_TYPES.has(entity.symbolType)) {
-        const members = collectStructureOutlineMembers(entity, adapter);
-        if (members.length > 0) {
-            lines.push("", "members:", ...members.map((member) => `- ${formatOutlineMember(member)}`));
-        }
-    }
-    else if (entity.symbolType === "function") {
-        const calls = collectFunctionCallNames(entity.node);
-        if (calls.length > 0) {
-            lines.push("", `calls: ${calls.join(", ")}`);
-        }
-    }
-    return truncateOutline(lines.join("\n").trim(), maxChars);
-}
-function truncateOutline(outline, maxChars) {
-    if (outline.length <= maxChars) {
-        return outline;
-    }
-    if (maxChars <= 3) {
-        return ".".repeat(maxChars);
-    }
-    return `${outline.slice(0, maxChars - 3).trimEnd()}...`;
-}
-function extractCodeHeader(text) {
-    const maxChars = 1200;
-    const maxLines = 24;
-    const lines = [];
-    for (const line of text.split(/\r?\n/)) {
-        lines.push(line);
-        if (line.includes("{") || lines.length >= maxLines) {
-            break;
-        }
-    }
-    const header = lines.join("\n").trim();
-    return header.length > maxChars
-        ? `${header.slice(0, maxChars).trimEnd()}\n...`
-        : header;
-}
-function collectStructureOutlineMembers(entity, adapter) {
-    const members = [];
-    const seen = new Set();
-    const visit = (node, depth) => {
-        if (members.length >= OUTLINE_MAX_MEMBERS || depth > 12) {
-            return;
-        }
-        if (!sameNode(node, entity.node) && adapter.entityTypes.has(node.type)) {
-            if (adapter.shouldIndexEntity?.(node) !== false) {
-                const resolved = adapter.resolveEntities?.(node) ?? [
-                    adapter.resolveEntity ? adapter.resolveEntity(node) : node,
-                ];
-                for (const resolvedNode of resolved) {
-                    if (members.length >= OUTLINE_MAX_MEMBERS ||
-                        sameNode(resolvedNode, entity.node)) {
-                        break;
-                    }
-                    const name = adapter.extractName(resolvedNode);
-                    const symbolType = adapter.classifyNode?.(resolvedNode, entity.breadcrumb) ??
-                        classifyCodeNode(resolvedNode, entity.breadcrumb);
-                    const signature = adapter.extractSignature?.(resolvedNode);
-                    const key = `${symbolType}:${name ?? ""}:${signature ?? ""}:${resolvedNode.startIndex}`;
-                    if (!seen.has(key)) {
-                        seen.add(key);
-                        members.push({ symbolType, name, signature });
-                    }
-                }
-            }
-            return;
-        }
-        for (const child of node.namedChildren) {
-            visit(child, depth + 1);
-        }
-    };
-    visit(entity.node, 0);
-    return members;
-}
-function formatOutlineMember(member) {
-    const name = member.name ?? "";
-    const signature = member.signature
-        ? truncateOutlineLine(oneLine(member.signature))
-        : "";
-    if (signature.length > 0) {
-        return name.length > 0 && !signature.includes(name)
-            ? `${member.symbolType} ${name}: ${signature}`
-            : `${member.symbolType} ${signature}`;
-    }
-    return name.length > 0 ? `${member.symbolType} ${name}` : member.symbolType;
-}
-function collectFunctionCallNames(node) {
-    const calls = [];
-    const seen = new Set();
-    const visit = (current) => {
-        if (calls.length >= OUTLINE_MAX_CALLS) {
-            return;
-        }
-        if (isCallNode(current)) {
-            const name = extractCallName(current);
-            if (name && !seen.has(name)) {
-                seen.add(name);
-                calls.push(name);
-            }
-        }
-        for (const child of current.namedChildren) {
-            visit(child);
-        }
-    };
-    visit(node);
-    return calls;
-}
-function isCallNode(node) {
-    return (node.type === "call" ||
-        node.type === "call_expression" ||
-        node.type === "function_call_expression" ||
-        node.type === "method_invocation" ||
-        node.type === "object_creation_expression" ||
-        node.type === "new_expression");
-}
-function extractCallName(node) {
-    const target = node.childForFieldName("function") ??
-        node.childForFieldName("name") ??
-        node.childForFieldName("constructor") ??
-        node.childForFieldName("type") ??
-        node.namedChildren[0];
-    if (!target) {
-        return undefined;
-    }
-    return normalizeCallName(target.text);
-}
-function normalizeCallName(value) {
-    const cleaned = value
-        .replace(/\s+/g, " ")
-        .replace(/^new\s+/, "")
-        .trim();
-    if (cleaned.length === 0 ||
-        cleaned.length > OUTLINE_MAX_LINE_CHARS ||
-        /[\n\r]/.test(cleaned) ||
-        !/[A-Za-z_$][A-Za-z0-9_$]*/.test(cleaned)) {
-        return undefined;
-    }
-    return cleaned;
-}
-function sameNode(left, right) {
-    return (left.startIndex === right.startIndex &&
-        left.endIndex === right.endIndex &&
-        left.type === right.type);
-}
-function oneLine(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
-function truncateOutlineLine(value) {
-    return value.length > OUTLINE_MAX_LINE_CHARS
-        ? `${value.slice(0, OUTLINE_MAX_LINE_CHARS - 3).trimEnd()}...`
-        : value;
-}
-function codeEntityMetadata(entity) {
-    return {
-        kind: "code",
-        symbolType: entity.symbolType,
-        symbolName: entity.name ?? null,
-        scope: entity.breadcrumb.length > 0 ? entity.breadcrumb.join("::") : null,
-        nodeType: entity.node.type,
-        signature: entity.signature ?? null,
-        doc: entity.doc ?? null,
-        modifiers: entity.modifiers,
-    };
-}
-function classifyCodeNode(node, breadcrumb) {
-    const nodeType = node.type;
-    if (nodeType === "decorated_definition") {
-        const inner = node.namedChildren.find((child) => child.type === "function_definition" ||
-            child.type === "class_definition");
-        return inner ? classifyCodeNode(inner, breadcrumb) : "value";
-    }
-    if ((nodeType === "field_definition" ||
-        nodeType === "public_field_definition" ||
-        nodeType === "variable_declarator") &&
-        hasJavascriptTypescriptFunctionValue(node)) {
-        return "function";
-    }
-    if (nodeType.includes("method") || nodeType.includes("constructor")) {
-        return "function";
-    }
-    if (breadcrumb.length > 0 &&
-        (nodeType.includes("function") ||
-            nodeType === "declaration" ||
-            nodeType === "function_item")) {
-        return "function";
-    }
-    if (nodeType.includes("function")) {
-        return "function";
-    }
-    if (nodeType === "declaration" || nodeType === "macro_type_specifier") {
-        return "function";
-    }
-    if (nodeType.includes("class") ||
-        nodeType.includes("struct") ||
-        nodeType.includes("impl") ||
-        nodeType.includes("enum") ||
-        nodeType.includes("union") ||
-        nodeType.includes("record")) {
-        return "class";
-    }
-    if (nodeType.includes("interface") ||
-        nodeType.includes("protocol") ||
-        nodeType.includes("trait")) {
-        return "interface";
-    }
-    if (nodeType.includes("module") ||
-        nodeType.includes("namespace") ||
-        nodeType === "mod_item") {
-        return "module";
-    }
-    if (nodeType.includes("alias") ||
-        nodeType.includes("typedef") ||
-        nodeType === "type_definition" ||
-        nodeType === "type_item") {
-        return "alias";
-    }
-    return "value";
-}
-function truncateInline(value, maxChars) {
-    const compact = value.replace(/\s+/g, " ").trim();
-    return compact.length > maxChars
-        ? `${compact.slice(0, maxChars).trimEnd()}...`
-        : compact;
-}
-function isScriptBlockFormat(format) {
-    return COMPONENT_CODE_FORMAT_SET.has(format);
-}
-function findScriptBlocks(text) {
-    const blocks = [];
-    const scriptPattern = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/gi;
-    for (const match of text.matchAll(scriptPattern)) {
-        const fullMatch = match[0];
-        const attrs = match[1] ?? "";
-        const blockText = match[2] ?? "";
-        const tagEndOffset = fullMatch.indexOf(">");
-        if (tagEndOffset < 0) {
-            continue;
-        }
-        const startOffset = match.index + tagEndOffset + 1;
-        blocks.push({
-            text: blockText,
-            format: scriptBlockFormat(attrs),
-            startLine: lineAtOffset(text, startOffset),
-            startOffset,
-        });
-    }
-    return blocks;
-}
-function scriptBlockFormat(attrs) {
-    const lang = attrs
-        .match(/\blang\s*=\s*["']?([A-Za-z0-9_-]+)/i)?.[1]
-        ?.toLowerCase();
-    if (lang === "ts" || lang === "typescript") {
-        return "typescript";
-    }
-    if (lang === "tsx") {
-        return "tsx";
-    }
-    if (lang === "jsx") {
-        return "jsx";
-    }
-    return "javascript";
-}
-function lineAtOffset(text, offset) {
-    let line = 1;
-    for (let index = 0; index < offset; index++) {
-        if (text.charCodeAt(index) === 10) {
-            line++;
-        }
-    }
-    return line;
-}
-function remapScriptBlockFragments(fileId, fragments, startIndex, startLine, startOffset) {
-    const idMap = new Map();
-    for (const [index, item] of fragments.entries()) {
-        idMap.set(item.fragment.id, makeEntityId(fileId, startIndex + index));
-    }
-    return fragments.map((item) => ({
-        ...item,
-        fragment: {
-            ...item.fragment,
-            id: idMap.get(item.fragment.id) ?? item.fragment.id,
-            group: item.fragment.group
-                ? (idMap.get(item.fragment.group) ?? item.fragment.group)
-                : undefined,
-            fileId,
-            range: remapScriptBlockRange(item.fragment.range, startLine, startOffset),
-        },
-    }));
-}
-function remapScriptBlockRange(range, startLine, startOffset) {
-    if (range.kind !== "text") {
-        return range;
-    }
-    return {
-        ...range,
-        startLine: startLine + range.startLine - 1,
-        endLine: startLine + range.endLine - 1,
-        startOffset: startOffset + range.startOffset,
-        endOffset: startOffset + range.endOffset,
-    };
-}
-//# sourceMappingURL=extractor.js.map