@ltm-alpha/alpha-cs 1.6.0

package/dist/extraction/syntax-tokens.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * Syntax classification from the engine's own tree-sitter parse (CG-57).
+ *
+ * The viewer used to run a second highlighter (Shiki + 56 pruned TextMate
+ * grammars) over source the engine had already parsed with a real grammar. This
+ * takes the classification off the tree instead, which removes the second
+ * dependency, the second grammar set, and — the part that actually mattered —
+ * the second opinion: a `.ts` file is now read by exactly the grammar that
+ * decided what its symbols are.
+ *
+ * ## What comes out
+ *
+ * A flat, ordered, non-overlapping list of {@link SyntaxSpan}s over the source
+ * string. Gaps between spans are whitespace and are the caller's to fill. The
+ * classes are deliberately few, because the design's code colouring is
+ * near-monochrome: comments recede, strings and numbers recede one step less,
+ * keywords carry weight rather than hue, and the only colour in the body is a
+ * call site the graph resolved.
+ *
+ * ## How a node becomes a class
+ *
+ * The rules are language-agnostic on purpose — the engine indexes 40-odd
+ * languages and a per-grammar scope table would be 40 tables to keep true:
+ *
+ * * a node whose type mentions `comment` is a comment, whole, undescended;
+ * * inside a string node every leaf is string, *except* below an interpolation,
+ *   where the code starts again (so `${user.name()}` still links);
+ * * a numeric literal node is a number;
+ * * an **anonymous** leaf is a keyword when its text is a bare word and
+ *   punctuation otherwise — this is what makes `func`, `fn`, `def`, `END-IF`
+ *   and `Sub` all land as keywords without naming any of them;
+ * * a **named** leaf whose text is identifier-shaped is an identifier, unless
+ *   the grammar called it a type name, or the extractor's own definition tables
+ *   say it is the name of a definition.
+ *
+ * The last of those is the one place per-language knowledge is used, and it is
+ * reused rather than restated: {@link EXTRACTORS} already names every node type
+ * that declares something in each language, plus the field its name hangs on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTAX_TOKEN_CLASSES = void 0;
+exports.classifyTree = classifyTree;
+exports.syntaxRegionsFor = syntaxRegionsFor;
+exports.tokenizeSource = tokenizeSource;
+const languages_1 = require("./languages");
+const grammars_1 = require("./grammars");
+/* ------------------------------------------------------------- the classes -- */
+/**
+ * Every class a token can carry, in wire order.
+ *
+ * `other` is punctuation and whitespace both. The design spec lists them apart
+ * (`punct` vs the gaps) but they paint identically — plain ink — and splitting
+ * them would roughly double the token count on a dense line to express a
+ * difference nothing draws.
+ */
+exports.SYNTAX_TOKEN_CLASSES = [
+    'other',
+    'ident',
+    'comment',
+    'string',
+    'keyword',
+    'number',
+    'type',
+    'def',
+];
+/* ---------------------------------------------------------- node-type tests -- */
+/**
+ * Anything a grammar calls a comment.
+ *
+ * Substring rather than equality because the spelling is per-grammar:
+ * `comment`, `line_comment`, `block_comment`, `doc_comment`, `html_comment`,
+ * `comment_directive`, `preproc_comment`.
+ */
+function isCommentType(type) {
+    return type.includes('comment');
+}
+/**
+ * A node whose leaves are string content unless an interpolation interrupts.
+ *
+ * `string` covers the bulk (`string_literal`, `interpreted_string_literal`,
+ * `raw_string_literal`, `encapsed_string`, `string_content`); the rest are the
+ * spellings that avoid the word — Rust/Go/C character literals, shell and PHP
+ * heredocs, and regular expressions, which recede for the same reason a string
+ * does.
+ */
+function isStringType(type) {
+    return (type.includes('string') ||
+        type.includes('heredoc') ||
+        type.includes('regex') ||
+        type === 'char_literal' ||
+        type === 'character' ||
+        type === 'character_literal' ||
+        type === 'rune_literal' ||
+        type === 'quoted_attribute_value');
+}
+/**
+ * Where code resumes inside a string.
+ *
+ * A template literal's `${…}` and an f-string's `{…}` hold real expressions,
+ * and the graph records call sites inside them. Swallowing the whole literal as
+ * one string token would drop those links — the overlay refuses to claim a
+ * token classed `string`, deliberately, so that a word inside a message never
+ * gets underlined.
+ */
+function isInterpolationType(type) {
+    return (type.includes('interpolation') ||
+        type.includes('substitution') ||
+        type === 'template_substitution' ||
+        type === 'string_interpolation' ||
+        type === 'format_expression');
+}
+/** A numeric literal, plus the language constants a theme groups with them. */
+function isNumberType(type) {
+    return (type === 'number' ||
+        type === 'integer' ||
+        type === 'float' ||
+        type === 'number_literal' ||
+        type === 'integer_literal' ||
+        type === 'float_literal' ||
+        type === 'decimal_integer_literal' ||
+        type === 'decimal_floating_point_literal' ||
+        type === 'hex_integer_literal' ||
+        type === 'real_literal' ||
+        type === 'numeric_literal' ||
+        type === 'int_literal' ||
+        type === 'imaginary_literal');
+}
+/** A named type reference — `type_identifier` and the equivalents. */
+function isTypeNameType(type) {
+    return type.includes('type_identifier') || type === 'type_name' || type === 'class_type';
+}
+/**
+ * Built-in type words — `string`, `int`, `u32`, `void`.
+ *
+ * These are emitted WHOLE and undescended, and they carry the same `type` class
+ * a user-defined type name gets. Both halves of that matter, because the
+ * grammars disagree with each other about what a built-in type even is:
+ * tree-sitter-go calls `string` a `type_identifier` (so it would be a type),
+ * tree-sitter-typescript wraps it in a `predefined_type` whose child is an
+ * anonymous token spelled `string` (so it would be a keyword). Reading the
+ * wrapper rather than its children is what stops the same word from painting
+ * two different ways in two languages on the same screen.
+ */
+const BUILTIN_TYPE_TYPES = new Set([
+    'primitive_type',
+    'predefined_type',
+    'builtin_type',
+    'sized_type_specifier',
+]);
+/** Literal constants a theme groups with numbers (`constant.language`). */
+const CONSTANT_TYPES = new Set([
+    'true',
+    'false',
+    'null',
+    'nil',
+    'none',
+    'undefined',
+    'null_literal',
+    'nil_literal',
+    'boolean_literal',
+    'true_literal',
+    'false_literal',
+]);
+/**
+ * Identifier-shaped text, in the loosest sense every indexed language agrees on.
+ *
+ * The high range is there because `\w` is ASCII-only in JavaScript and a symbol
+ * name can be Chinese, Japanese or Cyrillic; a call site in those repositories
+ * has to be linkable too. Hyphens are in because COBOL and Erlang spell words
+ * with them (`END-IF`, `is_record`).
+ */
+const IDENT_SHAPE = /^[A-Za-z_$À-￿][\w$À-￿-]*$/;
+/** A bare word — what separates a keyword from punctuation among anonymous nodes. */
+const WORD_SHAPE = /^[A-Za-z_][A-Za-z_0-9-]*$/;
+/* ------------------------------------------------------- definition names -- */
+/**
+ * Every node type that declares something, per language, from the extractors.
+ *
+ * This is the single piece of per-language knowledge the classifier uses, and
+ * it is borrowed rather than restated: the same lists drive extraction, so a
+ * language that learns a new declaration form gets its name bolded here for
+ * free — and cannot drift, because there is only one list.
+ */
+function definitionTypesFor(extractor) {
+    return new Set([
+        ...extractor.functionTypes,
+        ...extractor.classTypes,
+        ...extractor.methodTypes,
+        ...extractor.interfaceTypes,
+        ...extractor.structTypes,
+        ...extractor.enumTypes,
+        ...extractor.typeAliasTypes,
+        ...(extractor.unionTypes ?? []),
+        ...(extractor.extraClassNodeTypes ?? []),
+    ]);
+}
+/**
+ * Classify one parsed tree into spans.
+ *
+ * Exported for tests and for anything that already holds a tree; the usual
+ * entry point is {@link tokenizeSource}, which parses first.
+ */
+function classifyTree(root, source, language, offset = 0) {
+    const extractor = languages_1.EXTRACTORS[language];
+    const ctx = {
+        source,
+        out: [],
+        defTypes: extractor ? definitionTypesFor(extractor) : new Set(),
+        nameField: extractor?.nameField ?? 'name',
+        defStarts: new Set(),
+        offset,
+    };
+    visit(root, ctx, false);
+    return ctx.out;
+}
+function visit(node, ctx, inString) {
+    const type = node.type;
+    if (node.isNamed && isCommentType(type)) {
+        emit(ctx, node.startIndex, node.endIndex, 'comment');
+        return;
+    }
+    if (node.isNamed && BUILTIN_TYPE_TYPES.has(type)) {
+        emit(ctx, node.startIndex, node.endIndex, 'type');
+        return;
+    }
+    // Record the definition's own name BEFORE descending — the name node is a
+    // descendant, so the mark has to be in place by the time the walk reaches it.
+    if (ctx.defTypes.has(type)) {
+        const name = node.childForFieldName(ctx.nameField);
+        if (name)
+            ctx.defStarts.add(name.startIndex);
+    }
+    const childCount = node.childCount;
+    if (childCount === 0) {
+        emit(ctx, node.startIndex, node.endIndex, leafClass(node, ctx, inString));
+        return;
+    }
+    const nested = isInterpolationType(type) ? false : inString || isStringType(type);
+    for (let i = 0; i < childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            visit(child, ctx, nested);
+    }
+}
+function leafClass(node, ctx, inString) {
+    const type = node.type;
+    // An ANONYMOUS node's `type` is its own literal text, so none of the
+    // type-name tests below may be applied to one: `key: string` in TypeScript or
+    // PHP is a token whose type is the word `string`, and reading that as a
+    // string literal greys out half of every signature. Anonymous means keyword
+    // or punctuation, decided on shape alone — which is also what makes `func`,
+    // `fn`, `def`, `Sub` and `END-IF` all land right without naming any of them.
+    if (!node.isNamed) {
+        if (inString)
+            return 'string';
+        if (CONSTANT_TYPES.has(type))
+            return 'number';
+        return WORD_SHAPE.test(type) ? 'keyword' : 'other';
+    }
+    if (inString || isStringType(type))
+        return 'string';
+    if (isNumberType(type) || CONSTANT_TYPES.has(type))
+        return 'number';
+    const text = ctx.source.slice(node.startIndex, node.endIndex);
+    // Ahead of the type tests: a class name is a `type_identifier` in half these
+    // grammars and a plain `identifier` in the other half, and the design bolds
+    // the thing being DECLARED either way.
+    if (ctx.defStarts.has(node.startIndex) && IDENT_SHAPE.test(text))
+        return 'def';
+    if (isTypeNameType(type))
+        return 'type';
+    return IDENT_SHAPE.test(text) ? 'ident' : 'other';
+}
+/**
+ * Append a span, skipping empties and merging a run of the same class.
+ *
+ * Zero-width nodes are real: every grammar with a layout-sensitive scanner
+ * (Python's `_newline`, Erlang's, Swift's) emits them, and a zero-width span
+ * would put an empty token on the wire for nothing.
+ */
+function emit(ctx, start, end, cls) {
+    if (end <= start)
+        return;
+    const last = ctx.out[ctx.out.length - 1];
+    const from = start + ctx.offset;
+    if (last && last.cls === cls && last.end === from) {
+        last.end = end + ctx.offset;
+        return;
+    }
+    ctx.out.push({ start: from, end: end + ctx.offset, cls });
+}
+const SCRIPT_BLOCK = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/gi;
+const TS_LANG_ATTR = /lang\s*=\s*["'](ts|typescript)["']/i;
+/** Astro's frontmatter: a `---` fence at the very top of the file. */
+const ASTRO_FRONTMATTER = /^(---\r?\n)([\s\S]*?)\r?\n---/;
+/**
+ * The sub-language regions of a file, or null when the file is one language.
+ *
+ * Null and an empty array mean different things: null is "parse the whole file
+ * as `language`", empty is "this file has a grammar for none of it".
+ */
+function syntaxRegionsFor(source, language) {
+    if (language !== 'svelte' && language !== 'vue' && language !== 'astro')
+        return null;
+    const regions = [];
+    if (language === 'astro') {
+        const front = ASTRO_FRONTMATTER.exec(source);
+        if (front && front[2]) {
+            const start = front[1].length;
+            regions.push({ start, end: start + front[2].length, language: 'typescript' });
+        }
+    }
+    SCRIPT_BLOCK.lastIndex = 0;
+    let match;
+    while ((match = SCRIPT_BLOCK.exec(source)) !== null) {
+        const body = match[2] ?? '';
+        if (body.trim() === '')
+            continue;
+        const start = match.index + match[0].length - body.length - '</script>'.length;
+        regions.push({
+            start,
+            end: start + body.length,
+            language: TS_LANG_ATTR.test(match[1] ?? '') ? 'typescript' : 'javascript',
+        });
+    }
+    return regions;
+}
+/**
+ * Parse `source` and classify it.
+ *
+ * Returns null when nothing in the file has a grammar — a plain answer, which
+ * every caller here already knows how to serve. Never throws: a grammar that
+ * fails to load or a parse that comes back empty is the same outcome as not
+ * having one.
+ */
+async function tokenizeSource(source, language) {
+    const regions = syntaxRegionsFor(source, language);
+    if (regions === null) {
+        const spans = await tokenizeRegion(source, language, 0);
+        return spans ? { spans, grammars: [language] } : null;
+    }
+    if (regions.length === 0)
+        return null;
+    const spans = [];
+    const grammars = new Set();
+    for (const region of regions) {
+        const part = await tokenizeRegion(source.slice(region.start, region.end), region.language, region.start);
+        if (!part)
+            continue;
+        grammars.add(region.language);
+        spans.push(...part);
+    }
+    if (spans.length === 0)
+        return null;
+    spans.sort((a, b) => a.start - b.start);
+    return { spans, grammars: [...grammars] };
+}
+async function tokenizeRegion(source, language, offset) {
+    try {
+        await (0, grammars_1.loadGrammarsForLanguages)([language]);
+        const parser = (0, grammars_1.getParser)(language);
+        if (!parser)
+            return null;
+        const tree = parser.parse(source);
+        if (!tree?.rootNode)
+            return null;
+        try {
+            return classifyTree(tree.rootNode, source, language, offset);
+        }
+        finally {
+            tree.delete();
+        }
+    }
+    catch {
+        // A grammar that will not load, or a parse that threw: the caller serves
+        // the source unclassified, which is the whole point of the plain path.
+        return null;
+    }
+}
+//# sourceMappingURL=syntax-tokens.js.map

package/dist/extraction/syntax-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax-tokens.js","sourceRoot":"","sources":["../../src/extraction/syntax-tokens.ts"],"names":[],"mappings":"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"}

package/dist/extraction/tree-sitter-helpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Tree-sitter Shared Helpers
+ *
+ * Utility functions used by the core TreeSitterExtractor and per-language extractors.
+ * Extracted to a leaf module to avoid circular imports between tree-sitter.ts and languages/.
+ */
+import { Node as SyntaxNode } from 'web-tree-sitter';
+import { NodeKind } from '../types';
+/**
+ * Generate a unique node ID
+ *
+ * Uses a 32-character (128-bit) hash to avoid collisions when indexing
+ * large codebases with many files containing similar symbols.
+ */
+export declare function generateNodeId(filePath: string, kind: NodeKind, name: string, line: number): string;
+/**
+ * Extract text from a syntax node
+ */
+export declare function getNodeText(node: SyntaxNode, source: string): string;
+/**
+ * Find a child node by field name
+ */
+export declare function getChildByField(node: SyntaxNode, fieldName: string): SyntaxNode | null;
+/**
+ * Get the docstring/comment preceding a node
+ */
+export declare function getPrecedingDocstring(node: SyntaxNode, source: string): string | undefined;
+//# sourceMappingURL=tree-sitter-helpers.d.ts.map

package/dist/extraction/tree-sitter-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-helpers.d.ts","sourceRoot":"","sources":["../../src/extraction/tree-sitter-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,CAOR;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEtF;AAgDD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgC1F"}

package/dist/extraction/tree-sitter-helpers.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Tree-sitter Shared Helpers
+ *
+ * Utility functions used by the core TreeSitterExtractor and per-language extractors.
+ * Extracted to a leaf module to avoid circular imports between tree-sitter.ts and languages/.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNodeId = generateNodeId;
+exports.getNodeText = getNodeText;
+exports.getChildByField = getChildByField;
+exports.getPrecedingDocstring = getPrecedingDocstring;
+const crypto = __importStar(require("crypto"));
+/**
+ * Generate a unique node ID
+ *
+ * Uses a 32-character (128-bit) hash to avoid collisions when indexing
+ * large codebases with many files containing similar symbols.
+ */
+function generateNodeId(filePath, kind, name, line) {
+    const hash = crypto
+        .createHash('sha256')
+        .update(`${filePath}:${kind}:${name}:${line}`)
+        .digest('hex')
+        .substring(0, 32);
+    return `${kind}:${hash}`;
+}
+/**
+ * Extract text from a syntax node
+ */
+function getNodeText(node, source) {
+    return source.substring(node.startIndex, node.endIndex);
+}
+/**
+ * Find a child node by field name
+ */
+function getChildByField(node, fieldName) {
+    return node.childForFieldName(fieldName);
+}
+/**
+ * Node types that *wrap* a declaration so a leading comment is a sibling of the
+ * wrapper, not of the emitted (inner) declaration node. Alpha Code Sense emits the
+ * inner node, so before looking for its preceding comment we climb out through
+ * these. Examples: `export class X {}` (export_statement), `@dec\ndef f()`
+ * (decorated_definition), `const f = () => {}` (lexical_declaration →
+ * variable_declarator). Each wraps exactly one declaration, so climbing can't
+ * mis-attribute a comment to a sibling. (#780)
+ */
+const DOCSTRING_WRAPPER_TYPES = new Set([
+    'export_statement', // JS/TS: export class/function/const ...
+    'decorated_definition', // Python: @decorator over def/class
+    'lexical_declaration', // JS/TS: const/let x = () => {}
+    'variable_declaration', // JS/TS: var x = ...
+    'variable_declarator', // JS/TS: the `x = () => {}` inside the declaration
+    'ambient_declaration', // TS: declare ...
+]);
+/**
+ * Strip comment-syntax markers from a raw comment so the stored docstring is
+ * just the prose. Covers the marker styles across every supported language:
+ * C-family line and block comments and their doc variants, Rust/Swift/Kotlin
+ * triple-slash and bang doc lines, hash lines (Python/Ruby/shell), Lua/Luau
+ * line and long-bracket comments, and Pascal brace and paren-star comments.
+ * (#780)
+ *
+ * Paired block delimiters are stripped only when the comment OPENS with one,
+ * so a line comment that merely happens to END with a closing delimiter is
+ * never truncated. The per-line markers are anchored at line start, so
+ * they're safe to apply to any comment.
+ */
+function cleanCommentMarkers(comment) {
+    let c = comment.trim();
+    if (c.startsWith('/*'))
+        c = c.replace(/^\/\*+!?/, '').replace(/\*+\/$/, '');
+    else if (c.startsWith('--['))
+        c = c.replace(/^--\[=*\[/, '').replace(/\]=*\]$/, '');
+    else if (c.startsWith('(*'))
+        c = c.replace(/^\(\*/, '').replace(/\*\)$/, '');
+    else if (c.startsWith('{'))
+        c = c.replace(/^\{/, '').replace(/\}$/, '');
+    return c
+        .replace(/^\/\/[/!]?\s?/gm, '') // // , and Rust/Swift doc lines /// //!
+        .replace(/^--\s?/gm, '') //        Lua/Luau line comments
+        .replace(/^#\s?/gm, '') //         Python/Ruby/shell line comments
+        .replace(/^%+\s?/gm, '') //        Erlang line comments (% / %% / %%%)
+        .replace(/^\s*\*\s?/gm, '') //     block-comment continuation (* foo)
+        .trim();
+}
+/**
+ * Get the docstring/comment preceding a node
+ */
+function getPrecedingDocstring(node, source) {
+    // Climb out of any wrapper(s) so a comment preceding the WHOLE construct
+    // (export-, decorator-, or const-arrow-wrapped) is reachable as a sibling.
+    // The emitted node's own `previousNamedSibling` is empty (export/const) or a
+    // decorator (Python) in those cases, so without this the docstring was
+    // dropped. (#780)
+    let anchor = node;
+    while (anchor.parent && DOCSTRING_WRAPPER_TYPES.has(anchor.parent.type)) {
+        anchor = anchor.parent;
+    }
+    let sibling = anchor.previousNamedSibling;
+    const comments = [];
+    while (sibling) {
+        if (sibling.type === 'comment' ||
+            sibling.type === 'line_comment' ||
+            sibling.type === 'block_comment' ||
+            sibling.type === 'documentation_comment') {
+            comments.unshift(getNodeText(sibling, source));
+            sibling = sibling.previousNamedSibling;
+        }
+        else {
+            break;
+        }
+    }
+    if (comments.length === 0)
+        return undefined;
+    // Strip each comment's syntax markers (language-aware), then join.
+    return comments.map(cleanCommentMarkers).join('\n').trim();
+}
+//# sourceMappingURL=tree-sitter-helpers.js.map

package/dist/extraction/tree-sitter-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-helpers.js","sourceRoot":"","sources":["../../src/extraction/tree-sitter-helpers.ts"],"names":[],"mappings":"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"}