cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/field-extractors/configs/jvm.js

@@ -0,0 +1,172 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/jvm.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinConfig = exports.javaConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+const JAVA_VIS = new Set(['public', 'private', 'protected']);
+exports.javaConfig = {
+    language: index_js_1.SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['class_body', 'interface_body', 'enum_body'],
+    defaultVisibility: 'package',
+    extractName(node) {
+        // field_declaration > declarator:(variable_declarator name:(identifier))
+        const declarator = node.childForFieldName('declarator');
+        if (declarator) {
+            const name = declarator.childForFieldName('name');
+            return name?.text;
+        }
+        // fallback: walk children for variable_declarator
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declarator') {
+                const name = child.childForFieldName('name');
+                return name?.text;
+            }
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // field_declaration > type:(type_identifier|generic_type|...)
+        const t = (0, helpers_js_1.typeFromField)(node, 'type');
+        if (t)
+            return t;
+        // fallback: first named child that looks like a type
+        const first = node.firstNamedChild;
+        if (first && first.type !== 'modifiers') {
+            return (0, shared_js_1.extractSimpleTypeName)(first) ?? first.text?.trim();
+        }
+        return undefined;
+    },
+    extractRawType(node) {
+        // Verbatim type-node text — preserves generic arguments (`List<Shape>`)
+        // and qualifiers (`java.util.List<Shape>`) that extractType strips.
+        // Precedent: the JVM method extractor keeps raw `.text` for the same
+        // reason (method-extractors/configs/jvm.ts).
+        return node.childForFieldName('type')?.text?.trim();
+    },
+    extractAnnotations(node) {
+        // Same walk the JVM method extractor uses — field annotations live under
+        // the `modifiers` child of a `field_declaration` (e.g. `@Autowired`).
+        return (0, helpers_js_1.extractAnnotations)(node, 'modifiers');
+    },
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, JAVA_VIS, 'package', 'modifiers');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static') || (0, helpers_js_1.hasModifier)(node, 'modifiers', 'static');
+    },
+    isReadonly(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'final') || (0, helpers_js_1.hasModifier)(node, 'modifiers', 'final');
+    },
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/** A property_declaration is a companion-object member when its nearest
+ *  class-body ancestor is the body of a companion_object (F52, issue #1919).
+ *  Companion members are addressed statically through the enclosing class
+ *  (`C.TAG`), so they are marked static. */
+function isInsideKotlinCompanion(node) {
+    for (let cur = node.parent; cur !== null; cur = cur.parent) {
+        if (cur.type === 'class_body')
+            return cur.parent?.type === 'companion_object';
+        if (cur.type === 'companion_object')
+            return true;
+    }
+    return false;
+}
+exports.kotlinConfig = {
+    language: index_js_1.SupportedLanguages.Kotlin,
+    // F52: include companion_object so a companion property's innermost
+    // class-container owner (findEnclosingClassNode returns the companion_object)
+    // is recognized as a type declaration and its nested class_body is walked.
+    // The structure query already creates the Property node and owns it on the
+    // ENCLOSING class for anonymous companions / on the named companion Class —
+    // this entry only drives field-metadata enrichment, so it does NOT change
+    // ownership or emit a second node (no double-count).
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
+    fieldNodeTypes: ['property_declaration'],
+    bodyNodeTypes: ['class_body'],
+    defaultVisibility: 'public',
+    // F52: an anonymous `companion object { ... }` has no name child, so the
+    // generic factory's `childForFieldName('name')` owner lookup is empty and
+    // `extract()` would bail before walking the body. Supply a stable owner
+    // name (the named companion's identifier, else "Companion") so the body IS
+    // walked; the resulting FieldInfo map is keyed by field NAME only, so the
+    // owner name does not affect which Property node gets enriched.
+    extractOwnerName(node) {
+        const typeIdentifierText = node.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+        if (node.type === 'companion_object') {
+            // Anonymous companions have no type_identifier — fall back to "Companion".
+            return typeIdentifierText ?? 'Companion';
+        }
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        return typeIdentifierText;
+    },
+    extractName(node) {
+        // property_declaration > variable_declaration > simple_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const ident = child.namedChild(j);
+                    if (ident?.type === 'simple_identifier')
+                        return ident.text;
+                }
+            }
+            if (child?.type === 'simple_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // property_declaration may have a user_type or type_identifier under variable_declaration
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const t = child.namedChild(j);
+                    if (t &&
+                        (t.type === 'user_type' ||
+                            t.type === 'type_identifier' ||
+                            t.type === 'nullable_type' ||
+                            t.type === 'generic_type')) {
+                        return (0, shared_js_1.extractSimpleTypeName)(t) ?? t.text?.trim();
+                    }
+                }
+            }
+            if (child?.type === 'user_type' || child?.type === 'nullable_type') {
+                return (0, shared_js_1.extractSimpleTypeName)(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, KOTLIN_VIS, 'public', 'modifiers');
+    },
+    isStatic(node) {
+        // Kotlin has no `static`, but companion-object members are accessed
+        // statically through the enclosing class (`C.TAG`) — mark them static
+        // so the field metadata reflects that (F52).
+        return isInsideKotlinCompanion(node);
+    },
+    isReadonly(node) {
+        // 'val' = readonly, 'var' = mutable
+        return (0, helpers_js_1.hasKeyword)(node, 'val');
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/php.js

@@ -0,0 +1,67 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/php.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const PHP_VIS = new Set(['public', 'private', 'protected']);
+/**
+ * PHP field extraction config.
+ *
+ * Handles property_declaration inside class/interface/trait bodies.
+ * tree-sitter-php uses 'declaration_list' for the class body.
+ */
+exports.phpConfig = {
+    language: index_js_1.SupportedLanguages.PHP,
+    typeDeclarationNodes: ['class_declaration', 'interface_declaration', 'trait_declaration'],
+    fieldNodeTypes: ['property_declaration'],
+    bodyNodeTypes: ['declaration_list'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // property_declaration > property_element > variable_name ($varName)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'property_element') {
+                const varName = child.childForFieldName('name') ?? child.firstNamedChild;
+                if (varName) {
+                    // strip leading $ from PHP variable names
+                    const text = varName.text;
+                    return text.startsWith('$') ? text.slice(1) : text;
+                }
+            }
+            // fallback: variable_name direct child
+            if (child?.type === 'variable_name') {
+                const text = child.text;
+                return text.startsWith('$') ? text.slice(1) : text;
+            }
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // property_declaration may have a type before the property_element
+        // tree-sitter-php: type can be union_type, named_type, optional_type, primitive_type
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'union_type' ||
+                child.type === 'named_type' ||
+                child.type === 'optional_type' ||
+                child.type === 'primitive_type' ||
+                child.type === 'intersection_type') {
+                return (0, shared_js_1.extractSimpleTypeName)(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, PHP_VIS, 'public');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isReadonly(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'readonly');
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/python.js

@@ -0,0 +1,94 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/python.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Python field extraction config.
+ *
+ * Python class fields appear as:
+ * - Annotated assignments: `name: str = ""`
+ * - Plain assignments in __init__: `self.name = value`
+ *
+ * For AST-level extraction we handle expression_statement containing
+ * assignment or type nodes inside a class body block.
+ */
+exports.pythonConfig = {
+    language: index_js_1.SupportedLanguages.Python,
+    typeDeclarationNodes: ['class_definition'],
+    fieldNodeTypes: ['expression_statement'],
+    bodyNodeTypes: ['block'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // expression_statement wrapping an assignment or type
+        const inner = node.firstNamedChild;
+        if (!inner)
+            return undefined;
+        // Annotated assignment:  name: str = "default"
+        // tree-sitter node: type (expression_statement (type (identifier) (type) ...))
+        if (inner.type === 'type') {
+            const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+            return ident?.type === 'identifier' ? ident.text : undefined;
+        }
+        // assignment: x = 5  (class variable)
+        if (inner.type === 'assignment') {
+            const left = inner.childForFieldName('left');
+            if (left?.type === 'identifier')
+                return left.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        const inner = node.firstNamedChild;
+        if (!inner)
+            return undefined;
+        // Annotated assignment with value: `name: str = "default"`
+        // AST: expression_statement > type > [identifier, type, ...]
+        if (inner.type === 'type') {
+            const typeNode = inner.childForFieldName('type') ?? inner.namedChild(1);
+            if (typeNode)
+                return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        }
+        // Annotation without value: `address: Address`
+        // AST: expression_statement > assignment > [identifier, type]
+        if (inner.type === 'assignment') {
+            for (let i = 0; i < inner.childCount; i++) {
+                const child = inner.child(i);
+                if (child?.type === 'type') {
+                    const typeId = child.firstNamedChild;
+                    if (typeId)
+                        return (0, shared_js_1.extractSimpleTypeName)(typeId) ?? typeId.text?.trim();
+                }
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        const inner = node.firstNamedChild;
+        let name;
+        if (inner?.type === 'type') {
+            const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+            name = ident?.text;
+        }
+        else if (inner?.type === 'assignment') {
+            const left = inner.childForFieldName('left');
+            name = left?.text;
+        }
+        if (!name)
+            return 'public';
+        if (name.startsWith('__') && !name.endsWith('__'))
+            return 'private';
+        if (name.startsWith('_'))
+            return 'protected';
+        return 'public';
+    },
+    isStatic(_node) {
+        // Reports syntactic static keyword — Python class variables don't use explicit static keyword.
+        // Instance variables (self.x) live in __init__ and are not extracted here.
+        return false;
+    },
+    isReadonly(_node) {
+        return false;
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/ruby.js

@@ -0,0 +1,79 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/ruby.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+/**
+ * Collect all field names declared by an `attr_accessor`, `attr_reader`, or
+ * `attr_writer` call node.  A single call may list multiple symbols:
+ *   attr_accessor :foo, :bar, :baz
+ */
+function extractAttrNames(node) {
+    const method = node.childForFieldName('method');
+    if (!method)
+        return [];
+    const methodName = method.text;
+    if (methodName !== 'attr_accessor' &&
+        methodName !== 'attr_reader' &&
+        methodName !== 'attr_writer') {
+        return [];
+    }
+    const args = node.childForFieldName('arguments');
+    if (!args)
+        return [];
+    const names = [];
+    for (let i = 0; i < args.namedChildCount; i++) {
+        const arg = args.namedChild(i);
+        if (!arg)
+            continue;
+        // simple_symbol text is :name — strip the leading colon
+        const text = arg.text;
+        names.push(text.startsWith(':') ? text.slice(1) : text);
+    }
+    return names;
+}
+/**
+ * Ruby field extraction config.
+ *
+ * Ruby is unusual: there are no field declarations in the traditional sense.
+ * Fields are instance variables (@var) created by assignment, or declared
+ * via attr_accessor / attr_reader / attr_writer calls.
+ *
+ * We detect:
+ * - `call` nodes for attr_accessor / attr_reader / attr_writer
+ *   (their arguments are symbol names → field names)
+ *
+ * For simplicity we focus on attr_* calls in the class body.
+ * Instance variable assignments (self.x = ...) would require deeper analysis.
+ */
+exports.rubyConfig = {
+    language: index_js_1.SupportedLanguages.Ruby,
+    typeDeclarationNodes: ['class'],
+    fieldNodeTypes: ['call'],
+    bodyNodeTypes: ['body_statement'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // Returns the first symbol name for interface compatibility.
+        // Use extractNames to obtain all names from a single attr_* call.
+        return extractAttrNames(node)[0];
+    },
+    extractNames(node) {
+        return extractAttrNames(node);
+    },
+    extractType(_node) {
+        // Ruby is dynamically typed; no type annotations in standard Ruby
+        return undefined;
+    },
+    extractVisibility(_node) {
+        // attr_accessor/attr_writer fields are effectively public
+        // attr_reader fields are read-only from outside but still public
+        return 'public';
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isReadonly(node) {
+        const method = node.childForFieldName('method');
+        return method?.text === 'attr_reader';
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/rust.js

@@ -0,0 +1,55 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/rust.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Rust field extraction config.
+ *
+ * Handles struct fields (named and tuple variants are out of scope).
+ * Visibility: `pub` keyword = public, otherwise private (crate-private).
+ * All fields are immutable by default in Rust (mutability is on the binding).
+ */
+exports.rustConfig = {
+    language: index_js_1.SupportedLanguages.Rust,
+    typeDeclarationNodes: ['struct_item', 'enum_item'],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'private',
+    extractName(node) {
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // fallback: first field_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'field_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        // Check for visibility_modifier named child (pub, pub(crate), pub(super))
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'visibility_modifier')
+                return 'public';
+        }
+        return (0, helpers_js_1.hasKeyword)(node, 'pub') ? 'public' : 'private';
+    },
+    isStatic(_node) {
+        return false; // Rust struct fields are never static
+    },
+    isReadonly(_node) {
+        // All Rust fields are immutable by default (mutability is per-binding)
+        return true;
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/swift.js

@@ -0,0 +1,93 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/swift.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const SWIFT_VIS = new Set([
+    'public',
+    'private',
+    'fileprivate',
+    'internal',
+    'open',
+]);
+/**
+ * Swift field extraction config.
+ *
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
+ * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
+ */
+exports.swiftConfig = {
+    language: index_js_1.SupportedLanguages.Swift,
+    typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
+    fieldNodeTypes: ['property_declaration', 'protocol_property_declaration'],
+    bodyNodeTypes: ['class_body', 'protocol_body'],
+    defaultVisibility: 'internal',
+    extractName(node) {
+        // property_declaration > pattern > simple_identifier, and
+        // protocol_property_declaration > name: (pattern ... simple_identifier).
+        // For protocol_property_declaration the pattern wraps a leading
+        // value_binding_pattern ("var") plus the simple_identifier — the loop
+        // below skips the binding keyword and returns the identifier.
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'pattern') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const ident = child.namedChild(j);
+                    if (ident?.type === 'simple_identifier')
+                        return ident.text;
+                }
+                return child.text;
+            }
+            if (child?.type === 'simple_identifier')
+                return child.text;
+        }
+        // fallback: childForFieldName('name')
+        const name = node.childForFieldName('name');
+        return name?.text;
+    },
+    extractType(node) {
+        // property_declaration > type_annotation > type_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'type_annotation') {
+                const inner = child.firstNamedChild;
+                if (inner)
+                    return (0, shared_js_1.extractSimpleTypeName)(inner) ?? inner.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, SWIFT_VIS, 'internal', 'modifiers');
+    },
+    isStatic(node) {
+        // `static`/`class` (type-level) modifiers live inside a `modifiers`
+        // wrapper for both property_declaration and protocol_property_declaration
+        // (e.g. `static var shared: P { get }`), so check the wrapper too.
+        // `hasKeyword` compares each direct child by `.text` equality: it matches a
+        // single-modifier wrapper (`modifiers.text === 'static'`) but fails for a
+        // multi-modifier wrapper (`private static` → `modifiers.text === 'private static'`),
+        // which `hasModifier` handles by descending into the wrapper's children.
+        return ((0, helpers_js_1.hasKeyword)(node, 'static') ||
+            (0, helpers_js_1.hasKeyword)(node, 'class') ||
+            (0, helpers_js_1.hasModifier)(node, 'modifiers', 'static') ||
+            (0, helpers_js_1.hasModifier)(node, 'modifiers', 'class'));
+    },
+    isReadonly(node) {
+        // 'let' = constant/readonly, 'var' = variable
+        return (0, helpers_js_1.hasKeyword)(node, 'let');
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/typescript-javascript.js

@@ -0,0 +1,59 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/typescript-javascript.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptConfig = exports.typescriptConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+    ],
+    fieldNodeTypes: ['public_field_definition', 'property_signature', 'field_definition'],
+    bodyNodeTypes: ['class_body', 'interface_body', 'object_type'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        const nameNode = node.childForFieldName('name') ?? node.childForFieldName('property');
+        return nameNode?.text;
+    },
+    extractType(node) {
+        // tree-sitter TS uses a named 'type' field for type_annotation
+        const typeField = node.childForFieldName('type');
+        if (typeField) {
+            if (typeField.type === 'type_annotation') {
+                const inner = typeField.firstNamedChild;
+                return inner?.text?.trim();
+            }
+            return typeField.text?.trim();
+        }
+        return (0, helpers_js_1.typeFromAnnotation)(node);
+    },
+    extractVisibility(node) {
+        // TypeScript accessibility_modifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'accessibility_modifier') {
+                const t = child.text.trim();
+                if (VISIBILITY_KEYWORDS.has(t))
+                    return t;
+            }
+        }
+        return (0, helpers_js_1.findVisibility)(node, VISIBILITY_KEYWORDS, 'public', 'modifiers');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isReadonly(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'readonly');
+    },
+};
+exports.typescriptConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.TypeScript,
+};
+exports.javascriptConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.JavaScript,
+};