cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/utils/template-arguments.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplateArguments = extractTemplateArguments;
+exports.stripTemplateArguments = stripTemplateArguments;
+exports.templateArgumentsIdTag = templateArgumentsIdTag;
+exports.constraintsHash = constraintsHash;
+exports.templateConstraintsIdTag = templateConstraintsIdTag;
+exports.erasedTypeApplication = erasedTypeApplication;
+/**
+ * Parse top-level generic/template arguments from a type-like string.
+ *
+ * Examples:
+ * - `List<int>` -> ['int']
+ * - `Map<string, vector<int>>` -> ['string', 'vector<int>']
+ * - `List<T*>` -> ['T*']
+ */
+function extractTemplateArguments(text) {
+    const start = text.indexOf('<');
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let end = -1;
+    for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '<')
+            depth += 1;
+        else if (ch === '>') {
+            depth -= 1;
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+            if (depth < 0)
+                return undefined;
+        }
+    }
+    if (end === -1)
+        return undefined;
+    const inner = text.slice(start + 1, end);
+    if (inner.trim().length === 0)
+        return undefined;
+    const args = [];
+    let tokenStart = 0;
+    let nested = 0;
+    for (let i = 0; i < inner.length; i += 1) {
+        const ch = inner[i];
+        if (ch === '<')
+            nested += 1;
+        else if (ch === '>')
+            nested -= 1;
+        else if (ch === ',' && nested === 0) {
+            const token = inner.slice(tokenStart, i).replace(/\s+/g, '');
+            if (token.length > 0)
+                args.push(token);
+            tokenStart = i + 1;
+        }
+    }
+    const last = inner.slice(tokenStart).replace(/\s+/g, '');
+    if (last.length > 0)
+        args.push(last);
+    return args.length > 0 ? args : undefined;
+}
+function stripTemplateArguments(text) {
+    const start = text.indexOf('<');
+    if (start === -1)
+        return text;
+    return text.slice(0, start);
+}
+function templateArgumentsIdTag(templateArguments) {
+    if (templateArguments === undefined || templateArguments.length === 0)
+        return '';
+    return `~${templateArguments.join(',')}`;
+}
+/**
+ * Stable short hash for the opaque `SymbolDefinition.templateConstraints`
+ * payload (issue #1579). Two function-template overloads with identical
+ * `parameterTypes` but mutually-exclusive SFINAE constraints
+ * (`enable_if_t<is_integral_v<T>>` vs `enable_if_t<is_floating_point_v<T>>`)
+ * must produce distinct graph node IDs so the constraint-filter step
+ * has two candidates to narrow between. Without this they collapse to
+ * a single Function node and the SFINAE golden case can only emit one
+ * edge regardless of resolver fixes.
+ *
+ * FNV-1a 32-bit, base36 encoded. Deterministic; non-cryptographic — the
+ * tag's job is collision-avoidance among same-name overloads in one
+ * file, not security.
+ */
+function constraintsHash(jsonText) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < jsonText.length; i++) {
+        h ^= jsonText.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(36);
+}
+/** Build the `~c:<hash>` ID suffix from an opaque constraint payload.
+ *  Returns empty string when the payload is absent so callers can
+ *  string-concatenate unconditionally. */
+function templateConstraintsIdTag(payload) {
+    if (payload === undefined || payload === null)
+        return '';
+    return `~c:${constraintsHash(JSON.stringify(payload))}`;
+}
+/**
+ * The type APPLICATION a type reference was reduced from — `Mapped[User]`,
+ * `Repo<User>` — restored to the `Base<Args>` spelling, or `undefined` when
+ * this reference is not that shape.
+ *
+ * ── WHY A LOOKUP MUST NOT BE HANDED THE REDUCED NAME ─────────────────────────
+ *
+ * `rawName` is post-normalization (see its docstring on `TypeRef`), and several
+ * providers reduce a type application to its BASE NAME at capture time —
+ * `Mapped[User]` → `Mapped`, `Repo<User>` → `Repo`. That erasure is what lets
+ * one declaration answer for every instantiation of it, and it is also the
+ * widest step any lookup in this pipeline takes: reaching a declaration by NAME
+ * ALONE binds whatever the workspace happens to declare under that name. A
+ * third-party `Mapped[User]` beside an unrelated workspace `class Mapped` is
+ * then a confident WRONG edge, which is strictly worse than the missing one it
+ * replaced.
+ *
+ * `resolveClassBindingForName` already owns the rule for this — it admits an
+ * erased base name only on grounds that connect the site to the declaration
+ * (the scope chain binds the name; the declaration is in the same file; the
+ * index proves the name is a template family; the file has no cross-file class
+ * channel to be absent from). But that route is entered on the SPELLING: a name
+ * carrying its arguments takes it, a name already reduced to its base cannot,
+ * because nothing distinguishes it from an ordinary class name. So a provider
+ * that reduces at capture time sends its receivers down the ungrounded route by
+ * construction, whatever the shared lookup does.
+ *
+ * Restoring the application from `declaredSpelling` — which keeps the
+ * annotation exactly as written whenever normalization changed it — puts those
+ * receivers back on the grounded route. Restoring rather than reimplementing
+ * the grounding here is deliberate: the rule is one rule, and a second copy of
+ * it in this file would be free to drift from the one in `scope/walkers.ts`
+ * that every other caller uses. (Its predicate is not exported; the exported
+ * entry point is the spelling.)
+ *
+ * ── WHAT COUNTS AS AN APPLICATION ────────────────────────────────────────────
+ *
+ * `rawName` must be the base the spelling APPLIES arguments to, and the
+ * argument list must be the whole of the rest of the spelling — one list,
+ * balanced, non-empty. Everything else is left exactly as it resolves today,
+ * because a transform that is not certain is a worse failure than no transform:
+ *
+ *   - `User[]` — an array whose ELEMENT the capture layer already reduced to
+ *     `User`. The position is the element, not an application of `User`, and
+ *     the empty list is what says so.
+ *   - `User[][]` — likewise, and it closes its first list before the end.
+ *   - `std::vector<Item>` reduced to `vector<Item>` — the spelling does not
+ *     start with the reduced name, so nothing was erased that this can restore.
+ *   - `Repo<User>?`, `Map<String, (Int) -> Unit>` — trailing decoration and an
+ *     argument list that does not close where it must. Declining leaves the
+ *     pre-existing behaviour, which is what "no transform" has to mean.
+ *
+ * The rebuilt spelling uses ANGLE brackets because that is the spelling
+ * `resolveClassBindingForName`'s contract is written against; the punctuation a
+ * language spells type application with is not otherwise meaningful here, and
+ * nothing downstream reads this string except that lookup.
+ */
+function erasedTypeApplication(typeRef) {
+    const spelling = typeRef.declaredSpelling?.trim();
+    if (spelling === undefined)
+        return undefined;
+    const base = typeRef.rawName.trim();
+    if (base.length === 0 || !spelling.startsWith(base))
+        return undefined;
+    const rest = spelling.slice(base.length).trimStart();
+    const opener = rest[0];
+    if (opener !== '<' && opener !== '[')
+        return undefined;
+    const closer = opener === '<' ? '>' : ']';
+    let depth = 0;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === opener)
+            depth++;
+        else if (rest[i] === closer) {
+            depth--;
+            // The list the spelling opened must close on the LAST character, and must
+            // have held something: `Repo[User]` yes, `User[]` no, `User[][]` no.
+            if (depth === 0) {
+                return i === rest.length - 1 && i > 1 ? `${base}<${rest.slice(1, i)}>` : undefined;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/core/code/engine/core/ingestion/utils/type-parameters.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Parse a declared TYPE-PARAMETER LIST out of its own source text.
+ *
+ * The sibling of `template-arguments.ts`, on the other axis: that file reads the
+ * arguments a declaration was written AGAINST (`Vec<bool>` → `['bool']`), this
+ * one reads the parameters it was written IN TERMS OF (`template <class T>`,
+ * `class Box<T extends Repo>`). See `TypeParameter` in `cgraph-shared` for why
+ * conflating them is a defect rather than a simplification.
+ *
+ * ── WHY TEXT AND NOT A PER-LANGUAGE JSON PAYLOAD ─────────────────────────────
+ *
+ * The `@declaration.parameter-types` precedent synthesizes JSON inside each
+ * language's `captures.ts`, because a *parameter type* can itself contain a
+ * comma (`Dict[str, int]`) and needs a quoting convention. A type-parameter list
+ * needs none: every language that has one delimits it with `<…>` and separates
+ * entries with commas, and the nesting those commas can hide (`T extends
+ * Map<K, V>`) is bracket nesting the same scanner already has to track. So the
+ * capture can be the raw list node and the whole parse is shared, which keeps
+ * the per-language cost at one query capture instead of a branch in six
+ * emitters.
+ *
+ * ── WHY THIS NAMES NO LANGUAGE (AGENTS.md R6) ────────────────────────────────
+ *
+ * It recognizes TOKENS, not languages, and every token it recognizes is
+ * recognized for all input. `extends` and `:` both introduce a bound wherever
+ * they appear; the name is the last identifier ahead of the bound wherever it
+ * appears, which is what makes `class T`, `typename T`, `in T`, `out T`,
+ * `reified T` and a bare `T` one rule rather than six. No caller passes a
+ * language tag and none is inspected — the direct analogue of
+ * `extractTemplateArguments`, which has parsed `<…>` for every language from
+ * shared code since it was written.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeParameterList = parseTypeParameterList;
+/** Matches a trailing identifier: the parameter's name sits at the END of the
+ *  pre-bound text, after any keyword or variance modifier. Unicode is not
+ *  attempted — every language measured restricts type-parameter names to ASCII
+ *  identifier characters, and a name this rejects yields no parameter rather
+ *  than a wrong one. */
+const TRAILING_IDENTIFIER = /([A-Za-z_$][A-Za-z0-9_$]*)\s*$/;
+/**
+ * The declared type parameters in `text`, in source order, or `undefined` when
+ * `text` holds no parseable list.
+ *
+ * `text` is the raw source of the list node — `<T extends Repo, U>`,
+ * `<class T, typename U = int>`, `[T any]` is NOT accepted (see the bracket note
+ * below). Leading content before the first `<` is skipped, so a capture that
+ * spans `template <class T>` parses identically to one spanning `<class T>`.
+ *
+ * ANGLE BRACKETS ONLY. Every language this is wired to delimits with `<…>`.
+ * Square brackets would be ambiguous against an array/subscript spelling in the
+ * same position, and the one language that uses them for this (Go) is served by
+ * its own main-thread reader — so accepting `[…]` here would buy nothing and
+ * risk reading `int[]` as a parameter list.
+ */
+function parseTypeParameterList(text) {
+    const inner = innerListText(text);
+    if (inner === undefined)
+        return undefined;
+    const out = [];
+    for (const entry of splitTopLevel(inner)) {
+        const parameter = parseEntry(entry);
+        if (parameter !== undefined)
+            out.push(parameter);
+    }
+    return out.length > 0 ? out : undefined;
+}
+/** The text between the outermost `<` and its matching `>`, or `undefined` when
+ *  there is no balanced pair or it is empty. */
+function innerListText(text) {
+    const start = text.indexOf('<');
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '<')
+            depth += 1;
+        else if (ch === '>') {
+            depth -= 1;
+            if (depth === 0) {
+                const inner = text.slice(start + 1, i);
+                return inner.trim().length === 0 ? undefined : inner;
+            }
+            if (depth < 0)
+                return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Split on commas that no bracket encloses.
+ *
+ * All four bracket families are tracked together because a bound can carry any
+ * of them and each hides commas that are NOT entry separators: `T extends
+ * Map<K, V>` (angle), `T extends Fn<(a, b) => void>` (paren), `N: [usize; 2]`
+ * (square), `T : suspend (Int, Int) -> Unit` (paren again).
+ */
+function splitTopLevel(inner) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < inner.length; i += 1) {
+        const ch = inner[i];
+        if (ch === '<' || ch === '(' || ch === '[' || ch === '{')
+            depth += 1;
+        else if (ch === '>' || ch === ')' || ch === ']' || ch === '}')
+            depth -= 1;
+        else if (ch === ',' && depth === 0) {
+            parts.push(inner.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(inner.slice(start));
+    return parts;
+}
+/**
+ * One list entry → its parameter, or `undefined` when the entry declares no
+ * type parameter this can name.
+ *
+ * DECLINING IS A RESULT, not a failure to handle: a Rust lifetime (`'a`) and a
+ * C++ non-type parameter spelled without a trailing identifier declare nothing
+ * a member lookup can be performed on, and admitting them under a made-up name
+ * would put a binding in the shadowing guard that shadows nothing real.
+ */
+function parseEntry(entry) {
+    // A default (`= int`, `= Repo<User>`) is not part of either the name or the
+    // bound. Cut it first so `class T = int` still ends in its name. Only a
+    // top-level `=` counts — `T extends Fn<() => void>` must keep its bound.
+    const head = beforeTopLevelDefault(entry);
+    const boundAt = findBoundIntroducer(head);
+    const namePart = boundAt === undefined ? head : head.slice(0, boundAt.index);
+    const bound = boundAt === undefined ? undefined : head.slice(boundAt.index + boundAt.length).trim();
+    // The NAME is the trailing identifier of the pre-bound text. That one rule
+    // covers a bare `T`, a keyword-prefixed `class T` / `typename T`, a
+    // variance-annotated `in T` / `out T`, a modifier-prefixed `reified T`, and a
+    // variadic `class... Ts` — every measured spelling puts the name last.
+    const matched = TRAILING_IDENTIFIER.exec(namePart);
+    const name = matched?.[1];
+    if (matched === undefined || matched === null || name === undefined)
+        return undefined;
+    // A LIFETIME (`'a`) is not a type parameter. Its name would otherwise be read
+    // as the bare identifier after the sigil, putting `a` into the shadowing set
+    // and hiding any real declaration by that name from every lookup in the
+    // declaration's body — a missing edge invented out of a construct that
+    // declares no type at all.
+    if (namePart[matched.index - 1] === "'")
+        return undefined;
+    return bound === undefined || bound.length === 0 ? { name } : { name, bound };
+}
+/** `entry` up to a top-level `=`, which introduces a DEFAULT rather than a
+ *  bound. `=>` and `>=`/`<=` are not defaults; only a bare `=` at depth 0 is. */
+function beforeTopLevelDefault(entry) {
+    let depth = 0;
+    for (let i = 0; i < entry.length; i += 1) {
+        const ch = entry[i];
+        if (ch === '<' || ch === '(' || ch === '[' || ch === '{')
+            depth += 1;
+        else if (ch === '>' || ch === ')' || ch === ']' || ch === '}')
+            depth -= 1;
+        else if (ch === '=' && depth === 0 && entry[i + 1] !== '=' && entry[i + 1] !== '>') {
+            return entry.slice(0, i);
+        }
+    }
+    return entry;
+}
+/**
+ * Where the bound starts in `head`, or `undefined` when the entry declares none.
+ *
+ * Two introducers, both at depth 0 only: the keyword `extends` and a bare `:`.
+ * `:` is checked as a single character rather than a word, and `extends` is
+ * required to stand as a whole word so a parameter named `extendsFoo` is not
+ * mistaken for one.
+ *
+ * A `:` that is NOT a bound — C++ `template <int N>` has none, and a Rust const
+ * generic `const N: usize` states a const parameter's TYPE — yields a `bound`
+ * that no consumer can resolve to a class and therefore falls out harmlessly at
+ * lookup. Reading it as a bound is the conservative direction: it can only fail
+ * to find a member, never invent one.
+ */
+function findBoundIntroducer(head) {
+    let depth = 0;
+    for (let i = 0; i < head.length; i += 1) {
+        const ch = head[i];
+        if (ch === '<' || ch === '(' || ch === '[' || ch === '{')
+            depth += 1;
+        else if (ch === '>' || ch === ')' || ch === ']' || ch === '}')
+            depth -= 1;
+        else if (depth !== 0)
+            continue;
+        else if (ch === ':')
+            return { index: i, length: 1 };
+        else if (ch === 'e' &&
+            head.startsWith('extends', i) &&
+            isWholeWord(head, i, 'extends'.length)) {
+            return { index: i, length: 'extends'.length };
+        }
+    }
+    return undefined;
+}
+function isWholeWord(text, index, length) {
+    const before = index === 0 ? '' : text[index - 1];
+    const after = text[index + length] ?? '';
+    return !isIdentifierChar(before) && !isIdentifierChar(after);
+}
+function isIdentifierChar(ch) {
+    return ch.length === 1 && /[A-Za-z0-9_$]/.test(ch);
+}

package/dist/core/code/engine/core/ingestion/utils/verbose.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVerboseIngestionEnabled = void 0;
+const env_js_1 = require("./env.js");
+const isVerboseIngestionEnabled = () => (0, env_js_1.parseTruthyEnv)(process.env.CGRAPH_VERBOSE);
+exports.isVerboseIngestionEnabled = isVerboseIngestionEnabled;

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/c-cpp.js

@@ -0,0 +1,133 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/c-cpp.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppVariableConfig = exports.cVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * C/C++ variable extraction config.
+ *
+ * Handles global/namespace-scoped variable declarations:
+ * - `int x = 5;`
+ * - `const int MAX = 100;`
+ * - `static int counter = 0;`
+ * - `constexpr int SIZE = 10;` (C++)
+ * - `extern int shared;`
+ *
+ * tree-sitter-c/cpp uses declaration for variable declarations.
+ */
+function extractCVarName(node) {
+    // declaration → declarator (init_declarator or identifier)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'init_declarator') {
+            const declarator = child.childForFieldName('declarator');
+            if (declarator?.type === 'identifier')
+                return declarator.text;
+            if (declarator?.type === 'pointer_declarator') {
+                const inner = declarator.namedChildren.find((c) => c.type === 'identifier');
+                return inner?.text;
+            }
+        }
+        if (child?.type === 'identifier')
+            return child.text;
+    }
+    return undefined;
+}
+/**
+ * Locate the `structured_binding_declarator` inside a `declaration` node, if any.
+ *
+ * C++ structured bindings (`auto [a, b] = pair;`) parse as:
+ *   declaration → init_declarator → structured_binding_declarator → identifier+
+ * The reference form (`auto& [x, y] = tup;`) wraps it one level deeper:
+ *   declaration → init_declarator → reference_declarator → structured_binding_declarator
+ */
+function findStructuredBindingDeclarator(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type !== 'init_declarator')
+            continue;
+        const declarator = child.childForFieldName('declarator');
+        if (declarator?.type === 'structured_binding_declarator')
+            return declarator;
+        // `auto& [x, y]` → reference_declarator wraps the structured_binding_declarator.
+        if (declarator?.type === 'reference_declarator') {
+            const inner = declarator.namedChildren.find((c) => c.type === 'structured_binding_declarator');
+            if (inner)
+                return inner;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract every bound name from a C/C++ declaration.
+ *
+ * For a structured binding `auto [a, b] = ...;` this returns each bound
+ * identifier (`['a', 'b']`); the binding's `structured_binding_declarator`
+ * lists one `identifier` per name. For an ordinary single-name declaration
+ * (`int n = 0;`) it falls back to the single name extractor so behaviour is
+ * unchanged (issue #1919 F9).
+ */
+function extractCVarNames(node) {
+    const binding = findStructuredBindingDeclarator(node);
+    if (binding !== undefined) {
+        const names = [];
+        for (let i = 0; i < binding.namedChildCount; i++) {
+            const child = binding.namedChild(i);
+            if (child?.type === 'identifier')
+                names.push(child.text);
+        }
+        return names;
+    }
+    const single = extractCVarName(node);
+    return single !== undefined ? [single] : [];
+}
+function extractCVarType(node) {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode)
+        return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+    // Fallback: first primitive_type or type_identifier child
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'primitive_type' ||
+            child?.type === 'type_identifier' ||
+            child?.type === 'sized_type_specifier') {
+            return child.text?.trim();
+        }
+    }
+    return undefined;
+}
+const shared = {
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['declaration'],
+    extractName: extractCVarName,
+    extractNames: extractCVarNames,
+    extractType: extractCVarType,
+    extractVisibility(node) {
+        // C/C++ visibility is file-scoped by default (static = file-private)
+        if ((0, helpers_js_1.hasKeyword)(node, 'static'))
+            return 'private';
+        if ((0, helpers_js_1.hasKeyword)(node, 'extern'))
+            return 'public';
+        return 'public';
+    },
+    isConst(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'const') || (0, helpers_js_1.hasKeyword)(node, 'constexpr');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isMutable(node) {
+        return !(0, helpers_js_1.hasKeyword)(node, 'const') && !(0, helpers_js_1.hasKeyword)(node, 'constexpr');
+    },
+};
+exports.cVariableConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.C,
+};
+exports.cppVariableConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.CPlusPlus,
+};

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/csharp.js

@@ -0,0 +1,66 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/csharp.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * C# variable extraction config.
+ *
+ * C# does not have true top-level variables (pre-C# 9). In C# 9+ top-level
+ * statements, local_declaration_statement can appear at program scope.
+ * Class-scoped fields are handled by the field extractor.
+ */
+exports.csharpVariableConfig = {
+    language: index_js_1.SupportedLanguages.CSharp,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['local_declaration_statement'],
+    extractName(node) {
+        // local_declaration_statement → variable_declaration → variable_declarator → identifier
+        const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (!varDecl)
+            return undefined;
+        const declarator = varDecl.namedChildren.find((c) => c.type === 'variable_declarator');
+        const name = declarator?.childForFieldName('name');
+        return name?.type === 'identifier' ? name.text : undefined;
+    },
+    extractType(node) {
+        const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (!varDecl)
+            return undefined;
+        const typeNode = varDecl.childForFieldName('type');
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        const mods = (0, helpers_js_1.collectModifierTexts)(node);
+        if (mods.has('public'))
+            return 'public';
+        if (mods.has('private'))
+            return 'private';
+        if (mods.has('protected') && mods.has('internal'))
+            return 'protected internal';
+        if (mods.has('private') && mods.has('protected'))
+            return 'private protected';
+        if (mods.has('protected'))
+            return 'protected';
+        if (mods.has('internal'))
+            return 'internal';
+        return 'private';
+    },
+    isConst(node) {
+        const mods = (0, helpers_js_1.collectModifierTexts)(node);
+        return mods.has('const');
+    },
+    isStatic(node) {
+        const mods = (0, helpers_js_1.collectModifierTexts)(node);
+        return mods.has('static');
+    },
+    isMutable(node) {
+        const mods = (0, helpers_js_1.collectModifierTexts)(node);
+        return !mods.has('const') && !mods.has('readonly');
+    },
+};