kibi-plugin-builtin 0.2.0

package/dist/symbols/ts-morph-enrichment.js

@@ -0,0 +1,371 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { access, readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { Project, SyntaxKind, } from "ts-morph";
+import { SUPPORTED_SOURCE_EXTENSIONS, onlyCandidate, } from "./ts-morph-shared.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export async function enrichSymbolCoordinatesWithTsMorph(entries, workspaceRoot) {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+    });
+    const sourceFileCache = new Map();
+    const enriched = [];
+    for (const entry of entries) {
+        try {
+            const absolutePath = await resolveSourcePath(entry.sourceFile, workspaceRoot);
+            if (!absolutePath) {
+                enriched.push(entry);
+                continue;
+            }
+            const sourceFile = getOrAddSourceFile(project, sourceFileCache, absolutePath);
+            if (!sourceFile) {
+                enriched.push(await enrichWithTextFallback(entry, absolutePath));
+                continue;
+            }
+            const match = findNamedDeclaration(sourceFile, entry.title);
+            if (!match) {
+                enriched.push(entry);
+                continue;
+            }
+            const nameStart = match.getNameNode().getStart();
+            const end = match.node.getEnd();
+            const startLc = sourceFile.getLineAndColumnAtPos(nameStart);
+            const endLc = sourceFile.getLineAndColumnAtPos(end);
+            const coordinates = {
+                sourceLine: startLc.line,
+                sourceColumn: Math.max(0, startLc.column - 1),
+                sourceEndLine: endLc.line,
+                sourceEndColumn: Math.max(0, endLc.column - 1),
+                coordinatesGeneratedAt: new Date().toISOString(),
+            };
+            enriched.push({
+                ...entry,
+                ...coordinates,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[kibi] Failed to enrich symbol coordinates for ${entry.id}: ${message}`);
+            const absolutePath = await resolveSourcePath(entry.sourceFile, workspaceRoot);
+            if (!absolutePath) {
+                enriched.push(entry);
+                continue;
+            }
+            enriched.push(await enrichWithTextFallback(entry, absolutePath));
+        }
+    }
+    return enriched;
+}
+async function resolveSourcePath(sourceFile, workspaceRoot) {
+    if (!sourceFile)
+        return null;
+    const absolute = path.isAbsolute(sourceFile)
+        ? sourceFile
+        : path.resolve(workspaceRoot, sourceFile);
+    const ext = path.extname(absolute).toLowerCase();
+    if (!SUPPORTED_SOURCE_EXTENSIONS.has(ext))
+        return null;
+    try {
+        await access(absolute);
+    }
+    catch {
+        return null;
+    }
+    return absolute;
+}
+function getOrAddSourceFile(project, cache, absolutePath) {
+    const cached = cache.get(absolutePath);
+    if (cached)
+        return cached;
+    try {
+        const sourceFile = project.addSourceFileAtPath(absolutePath);
+        cache.set(absolutePath, sourceFile);
+        return sourceFile;
+    }
+    catch {
+        return null;
+    }
+}
+async function enrichWithTextFallback(entry, absolutePath) {
+    try {
+        const content = await readFile(absolutePath, "utf8");
+        const lines = content.split(/\r?\n/);
+        const escapedTitle = entry.title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const pattern = new RegExp(`\\b${escapedTitle}\\b`);
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            const match = pattern.exec(line);
+            if (!match || match.index < 0)
+                continue;
+            return {
+                ...entry,
+                sourceLine: index + 1,
+                sourceColumn: match.index,
+                sourceEndLine: index + 1,
+                sourceEndColumn: match.index + entry.title.length,
+                coordinatesGeneratedAt: new Date().toISOString(),
+            };
+        }
+        return entry;
+    }
+    catch {
+        return entry;
+    }
+}
+function findNamedDeclaration(sourceFile, title) {
+    const qualifiedMethod = parseQualifiedMethodTitle(title);
+    if (qualifiedMethod) {
+        for (const cls of sourceFile.getClasses()) {
+            if (cls.getName() !== qualifiedMethod.className)
+                continue;
+            const match = findClassMember(cls, qualifiedMethod.methodName);
+            if (match)
+                return match;
+        }
+        for (const statement of sourceFile.getVariableStatements()) {
+            if (!statement.isExported())
+                continue;
+            for (const declaration of statement.getDeclarations()) {
+                if (declaration.getName() !== qualifiedMethod.className)
+                    continue;
+                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                const match = classExpression
+                    ? findClassMember(classExpression, qualifiedMethod.methodName)
+                    : null;
+                if (match)
+                    return match;
+            }
+        }
+        return null;
+    }
+    const candidates = [];
+    for (const decl of sourceFile.getFunctions()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getClasses()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getInterfaces()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getTypeAliases()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const decl of sourceFile.getEnums()) {
+        if (!decl.isExported())
+            continue;
+        if (decl.getName() !== title)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (!nameNode)
+            continue;
+        candidates.push({ node: decl, getNameNode: () => nameNode });
+    }
+    for (const statement of sourceFile.getVariableStatements()) {
+        if (!statement.isExported())
+            continue;
+        for (const declaration of statement.getDeclarations()) {
+            if (declaration.getName() !== title)
+                continue;
+            const nameNode = declaration.getNameNode();
+            candidates.push({ node: declaration, getNameNode: () => nameNode });
+        }
+    }
+    if (candidates.length === 0) {
+        const internalCandidates = [];
+        for (const decl of sourceFile.getFunctions()) {
+            if (decl.isExported())
+                continue;
+            if (decl.getName() !== title)
+                continue;
+            const nameNode = decl.getNameNode();
+            if (!nameNode)
+                continue;
+            internalCandidates.push({ node: decl, getNameNode: () => nameNode });
+        }
+        const uniqueInternal = onlyCandidate(internalCandidates);
+        if (uniqueInternal) {
+            return uniqueInternal;
+        }
+        const methodCandidates = [];
+        for (const cls of sourceFile.getClasses()) {
+            for (const method of cls.getMethods()) {
+                if (method.getName() !== title)
+                    continue;
+                const nameNode = method.getNameNode();
+                if (!nameNode)
+                    continue;
+                methodCandidates.push({ node: method, getNameNode: () => nameNode });
+            }
+        }
+        for (const statement of sourceFile.getVariableStatements()) {
+            if (!statement.isExported())
+                continue;
+            for (const declaration of statement.getDeclarations()) {
+                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                if (!classExpression)
+                    continue;
+                for (const method of classExpression.getMethods()) {
+                    if (method.getName() !== title)
+                        continue;
+                    const nameNode = method.getNameNode();
+                    if (!nameNode)
+                        continue;
+                    methodCandidates.push({
+                        node: method,
+                        getNameNode: () => nameNode,
+                    });
+                }
+            }
+        }
+        const uniqueMethod = onlyCandidate(methodCandidates);
+        if (uniqueMethod) {
+            return uniqueMethod;
+        }
+        const memberCandidates = [];
+        for (const cls of sourceFile.getClasses()) {
+            for (const property of cls.getProperties()) {
+                if (property.getName() !== title)
+                    continue;
+                const nameNode = property.getNameNode();
+                if (!nameNode)
+                    continue;
+                memberCandidates.push({ node: property, getNameNode: () => nameNode });
+            }
+            for (const accessor of [
+                ...cls.getGetAccessors(),
+                ...cls.getSetAccessors(),
+            ]) {
+                if (accessor.getName() !== title)
+                    continue;
+                const nameNode = accessor.getNameNode();
+                if (!nameNode)
+                    continue;
+                memberCandidates.push({ node: accessor, getNameNode: () => nameNode });
+            }
+        }
+        for (const statement of sourceFile.getVariableStatements()) {
+            if (!statement.isExported())
+                continue;
+            for (const declaration of statement.getDeclarations()) {
+                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                if (!classExpression)
+                    continue;
+                for (const property of classExpression.getProperties()) {
+                    if (property.getName() !== title)
+                        continue;
+                    const nameNode = property.getNameNode();
+                    if (!nameNode)
+                        continue;
+                    memberCandidates.push({
+                        node: property,
+                        getNameNode: () => nameNode,
+                    });
+                }
+                for (const accessor of [
+                    ...classExpression.getGetAccessors(),
+                    ...classExpression.getSetAccessors(),
+                ]) {
+                    if (accessor.getName() !== title)
+                        continue;
+                    const nameNode = accessor.getNameNode();
+                    if (!nameNode)
+                        continue;
+                    memberCandidates.push({
+                        node: accessor,
+                        getNameNode: () => nameNode,
+                    });
+                }
+            }
+        }
+        const uniqueMember = onlyCandidate(memberCandidates);
+        if (uniqueMember) {
+            return uniqueMember;
+        }
+        return null;
+    }
+    candidates.sort((a, b) => a.getNameNode().getStart() - b.getNameNode().getStart());
+    return candidates[0] ?? null;
+}
+function findClassMember(declaration, name) {
+    for (const method of declaration.getMethods()) {
+        if (method.getName() !== name)
+            continue;
+        const nameNode = method.getNameNode();
+        if (nameNode)
+            return { node: method, getNameNode: () => nameNode };
+    }
+    for (const property of declaration.getProperties()) {
+        if (property.getName() !== name)
+            continue;
+        const nameNode = property.getNameNode();
+        if (nameNode)
+            return { node: property, getNameNode: () => nameNode };
+    }
+    for (const accessor of [
+        ...declaration.getGetAccessors(),
+        ...declaration.getSetAccessors(),
+    ]) {
+        if (accessor.getName() !== name)
+            continue;
+        const nameNode = accessor.getNameNode();
+        if (nameNode)
+            return { node: accessor, getNameNode: () => nameNode };
+    }
+    return null;
+}
+function parseQualifiedMethodTitle(title) {
+    const separatorIndex = title.lastIndexOf(".");
+    if (separatorIndex <= 0 || separatorIndex === title.length - 1)
+        return null;
+    return {
+        className: title.slice(0, separatorIndex),
+        methodName: title.slice(separatorIndex + 1),
+    };
+}

package/dist/symbols/ts-morph-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { SourceAnalysisProvider, SymbolExtractorV1 } from "kibi-plugin-sdk";
+/**
+ * Built-in ts-morph symbol extractor. Behavior matches the historical CLI
+ * `createTsMorphSourceAnalysisProvider` analysis path.
+ */
+export declare function createBuiltinTsMorphSymbolExtractor(): SymbolExtractorV1;
+export declare function createBuiltinTsMorphSourceAnalysisProvider(): SourceAnalysisProvider;
+//# sourceMappingURL=ts-morph-extractor.d.ts.map

package/dist/symbols/ts-morph-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-extractor.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-extractor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,sBAAsB,EAItB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAmBzB;;;GAGG;AAEH,wBAAgB,mCAAmC,IAAI,iBAAiB,CA8BvE;AAGD,wBAAgB,0CAA0C,IAAI,sBAAsB,CAEnF"}

package/dist/symbols/ts-morph-extractor.js

@@ -0,0 +1,229 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import * as path from "node:path";
+import { toSourceAnalysisProvider } from "kibi-plugin-sdk";
+import { Project, SyntaxKind, } from "ts-morph";
+import { SUPPORTED_SOURCE_EXTENSIONS, chooseScriptKind, formatMethodSymbolName, isPrivateClassMember, } from "./ts-morph-shared.js";
+const EXTRACTOR_ID = "kibi-plugin-builtin.ts-morph";
+/**
+ * Built-in ts-morph symbol extractor. Behavior matches the historical CLI
+ * `createTsMorphSourceAnalysisProvider` analysis path.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+export function createBuiltinTsMorphSymbolExtractor() {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+    });
+    return {
+        id: EXTRACTOR_ID,
+        supports(input) {
+            return SUPPORTED_SOURCE_EXTENSIONS.has(path.extname(input.path).toLowerCase());
+        },
+        analyze(input) {
+            const sourceFile = project.createSourceFile(input.path, input.content, {
+                overwrite: true,
+                scriptKind: chooseScriptKind(input.path),
+            });
+            return {
+                sourceFile: input.path,
+                language: inferSourceLanguage(input.path),
+                module: {
+                    title: inferModuleTitle(input.path),
+                    language: inferSourceLanguage(input.path),
+                    analysisMode: "parser",
+                },
+                symbols: collectSourceSymbols(sourceFile),
+            };
+        },
+    };
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function createBuiltinTsMorphSourceAnalysisProvider() {
+    return toSourceAnalysisProvider(createBuiltinTsMorphSymbolExtractor());
+}
+function collectSourceSymbols(sourceFile) {
+    const symbols = [];
+    for (const decl of sourceFile.getFunctions()) {
+        if (!decl.isExported())
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "function", decl.getNameNode() ?? decl, decl, 
+        // Functions: leading trivia via getFullText + JSDoc (historical CLI).
+        fullTextWithJsDocs(decl)));
+    }
+    for (const decl of sourceFile.getClasses()) {
+        if (!decl.isExported())
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "class", decl.getNameNode() ?? decl, decl, 
+        // Leading comments + JSDoc only — never the class body (method
+        // `// implements` must stay on the method symbol).
+        leadingCommentsAndJsDocs(sourceFile, decl)));
+        try {
+            appendClassMembers(sourceFile, decl, decl.getName(), symbols);
+        }
+        catch {
+            // Skip malformed class member walks; keep the class symbol.
+        }
+    }
+    for (const decl of sourceFile.getInterfaces()) {
+        if (!decl.isExported())
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "interface", decl.getNameNode() ?? decl, decl, 
+        // Historical CLI used getText(); keep calling it so characterization
+        // mocks that throw from getText still isolate the failure.
+        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+    }
+    for (const decl of sourceFile.getTypeAliases()) {
+        if (!decl.isExported())
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "type", decl.getNameNode() ?? decl, decl, `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+    }
+    for (const decl of sourceFile.getEnums()) {
+        if (!decl.isExported())
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "enum", decl.getNameNode() ?? decl, decl, 
+        // Enums historically used getText(); prefer leading comments when the
+        // real AST is available, else getText for test doubles.
+        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+    }
+    for (const statement of sourceFile.getVariableStatements()) {
+        if (!statement.isExported())
+            continue;
+        for (const declaration of statement.getDeclarations()) {
+            pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, declaration.getName(), "variable", declaration.getNameNode() ?? declaration, declaration, 
+            // Statement carries leading `// implements`; declaration text is the
+            // historical fallback when only getText is stubbed in tests.
+            `${safeFullText(statement)}\n${safeGetText(declaration)}`));
+            try {
+                const classExpression = typeof declaration.getInitializerIfKind === "function"
+                    ? declaration.getInitializerIfKind(SyntaxKind.ClassExpression)
+                    : undefined;
+                if (classExpression) {
+                    appendClassMembers(sourceFile, classExpression, declaration.getName(), symbols);
+                }
+            }
+            catch {
+                // Skip malformed class-expression members; keep the variable symbol.
+            }
+        }
+    }
+    return symbols;
+}
+function jsDocsOnly(node) {
+    if (typeof node.getJsDocs !== "function")
+        return "";
+    return node
+        .getJsDocs()
+        .map((doc) => doc.getFullText())
+        .join("\n");
+}
+function leadingCommentsAndJsDocs(sourceFile, node) {
+    let leading = "";
+    try {
+        if (typeof node.getFullStart === "function" &&
+            typeof node.getStart === "function") {
+            const fullStart = node.getFullStart();
+            // Exclude JSDoc from the range so we don't double-count with jsDocsOnly.
+            const start = node.getStart(false);
+            if (Number.isFinite(fullStart) &&
+                Number.isFinite(start) &&
+                start > fullStart) {
+                leading = sourceFile.getFullText().slice(fullStart, start);
+            }
+        }
+    }
+    catch {
+        leading = "";
+    }
+    return `${leading}\n${jsDocsOnly(node)}`;
+}
+function fullTextWithJsDocs(node) {
+    return `${safeFullText(node)}\n${jsDocsOnly(node)}`;
+}
+function safeFullText(node) {
+    return typeof node.getFullText === "function" ? node.getFullText() : "";
+}
+function safeGetText(node) {
+    return typeof node.getText === "function" ? node.getText() : "";
+}
+function appendClassMembers(sourceFile, declaration, className, symbols) {
+    // Inherit class *leading* ownership comments onto members (not the class
+    // body). Method-local `// implements` stay on the method via getFullText.
+    const classLeading = leadingCommentsAndJsDocs(sourceFile, declaration);
+    const methods = typeof declaration.getMethods === "function"
+        ? declaration.getMethods()
+        : [];
+    for (const method of methods) {
+        if (isPrivateClassMember(method))
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, method.getName()), "method", method.getNameNode() ?? method, method, `${classLeading}\n${fullTextWithJsDocs(method)}`));
+    }
+    const properties = typeof declaration.getProperties === "function"
+        ? declaration.getProperties()
+        : [];
+    for (const property of properties) {
+        if (isPrivateClassMember(property))
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, property.getName()), "property", property.getNameNode() ?? property, property, `${classLeading}\n${fullTextWithJsDocs(property)}`));
+    }
+    const accessors = [
+        ...(typeof declaration.getGetAccessors === "function"
+            ? declaration.getGetAccessors()
+            : []),
+        ...(typeof declaration.getSetAccessors === "function"
+            ? declaration.getSetAccessors()
+            : []),
+    ];
+    for (const accessor of accessors) {
+        if (isPrivateClassMember(accessor))
+            continue;
+        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, accessor.getName()), "accessor", accessor.getNameNode() ?? accessor, accessor, `${classLeading}\n${fullTextWithJsDocs(accessor)}`));
+    }
+}
+function pushSymbol(symbols, build) {
+    try {
+        symbols.push(build());
+    }
+    catch {
+        // Skip malformed declarations; keep sibling symbols.
+    }
+}
+function toSourceSymbolAnalysis(sourceFile, name, kind, startNode, endNode, directiveText) {
+    const start = sourceFile.getLineAndColumnAtPos(startNode.getStart());
+    const end = sourceFile.getLineAndColumnAtPos(endNode.getEnd());
+    return {
+        name,
+        kind,
+        startLine: start.line,
+        startColumn: Math.max(0, start.column - 1),
+        endLine: end.line,
+        endColumn: Math.max(0, end.column - 1),
+        directiveText,
+    };
+}
+function inferSourceLanguage(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".mts", ".cts"].includes(extension)) {
+        return "typescript";
+    }
+    return "javascript";
+}
+function inferModuleTitle(filePath) {
+    const extension = path.extname(filePath);
+    const basename = path.basename(filePath, extension);
+    return basename.length > 0 ? basename : path.basename(filePath);
+}

package/dist/symbols/ts-morph-granularity.d.ts

@@ -0,0 +1,11 @@
+import type { SourceSymbolKind } from "kibi-plugin-sdk";
+export interface GranularitySymbolCandidate {
+    readonly name: string;
+    readonly kind: SourceSymbolKind;
+}
+/**
+ * Collect exported (and unique bare method) symbol candidates used by
+ * coarse-vs-granular symbol validation.
+ */
+export declare function collectGranularityCandidates(filePath: string, content: string): GranularitySymbolCandidate[];
+//# sourceMappingURL=ts-morph-granularity.d.ts.map

package/dist/symbols/ts-morph-granularity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-granularity.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-granularity.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKxD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;CACjC;AAED;;;GAGG;AAEH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,0BAA0B,EAAE,CA+D9B"}