graph-indexer 2.1.1 → 3.0.0

package/src/parse/lang/csharp.mjs

@@ -0,0 +1,106 @@
+/** C# extraction spec. */
+
+const T = (cap) => `[(identifier) @${cap} (generic_name (identifier) @${cap}) (qualified_name name: (identifier) @${cap}) (qualified_name name: (generic_name (identifier) @${cap})) (nullable_type (identifier) @${cap})]`;
+
+const QUERY = `
+(class_declaration name: (identifier) @name) @def.class
+(interface_declaration name: (identifier) @name) @def.interface
+(struct_declaration name: (identifier) @name) @def.struct
+(enum_declaration name: (identifier) @name) @def.enum
+(record_declaration name: (identifier) @name) @def.class
+(delegate_declaration name: (identifier) @name) @def.type
+(method_declaration returns: (_) @type name: (identifier) @name) @def.method
+(method_declaration name: (identifier) @name) @def.method
+(constructor_declaration name: (identifier) @name) @def.constructor
+(property_declaration type: (_) @type name: (identifier) @name) @def.property
+(property_declaration name: (identifier) @name) @def.property
+(field_declaration (variable_declaration type: (_) @type (variable_declarator name: (identifier) @name))) @def.field
+(field_declaration (variable_declaration (variable_declarator name: (identifier) @name))) @def.field
+(enum_member_declaration name: (identifier) @name) @def.constant
+
+(invocation_expression function: (identifier) @name) @ref.call
+(invocation_expression function: (generic_name (identifier) @name)) @ref.call
+(invocation_expression function: (member_access_expression expression: (_) @recv name: [(identifier) @name (generic_name (identifier) @name)])) @ref.call
+(object_creation_expression type: ${T('name')}) @ref.new
+(base_list ${T('name')}) @ref.inherit
+(base_list (primary_constructor_base_type type: ${T('name')})) @ref.inherit
+(attribute name: ${T('name')}) @ref.decorator
+(variable_declaration type: ${T('name')}) @ref.type
+(parameter type: ${T('name')}) @ref.type
+(method_declaration returns: ${T('name')}) @ref.type
+(property_declaration type: ${T('name')}) @ref.type
+(type_argument_list ${T('name')}) @ref.type
+(typeof_expression type: ${T('name')}) @ref.type
+(argument (identifier) @name) @ref.value
+
+[(lambda_expression) (anonymous_method_expression)] @scope
+(return_statement (_) @ret)
+(using_directive) @import
+
+(variable_declaration type: (_) @bind.type (variable_declarator name: (identifier) @bind.name)) @bind
+(variable_declaration (variable_declarator name: (identifier) @bind.name (object_creation_expression type: ${T('bind.new')}))) @bind
+(variable_declaration (variable_declarator name: (identifier) @bind.name (_) @bind.expr)) @bind
+(parameter type: (_) @bind.type name: (identifier) @bind.name) @bind
+(foreach_statement type: (_) @bind.type left: (identifier) @bind.name right: (_) @bind.elem) @bind
+(field_declaration (variable_declaration type: (_) @field.type (variable_declarator name: (identifier) @field.name))) @field
+(property_declaration type: (_) @field.type name: (identifier) @field.name) @field
+`;
+
+const BUILTIN = new Set(['string', 'String', 'int', 'long', 'bool', 'double', 'float', 'decimal', 'object', 'Object',
+    'void', 'dynamic', 'List', 'Dictionary', 'IEnumerable', 'IList', 'ICollection', 'Task', 'Guid', 'DateTime',
+    'TimeSpan', 'Exception', 'Func', 'Action', 'IReadOnlyList', 'IReadOnlyCollection', 'HashSet', 'Nullable',
+    'CancellationToken', 'Array', 'Type', 'byte', 'char', 'short', 'uint', 'ulong']);
+
+function usingImport(node) {
+    const text = node.text.replace(/^global\s+/, '').replace(/^using\s+(static\s+)?/, '').replace(/;\s*$/, '').trim();
+    const alias = /^(\w+)\s*=\s*(.+)$/.exec(text);
+    if (alias) return [{ source: alias[2].trim(), imported: '*', local: alias[1] }];
+    return [{ source: text, imported: '*', local: null, wildcard: true }];
+}
+
+function modifiers(node) { return node.namedChildren.filter(c => c.type === 'modifier').map(c => c.text).join(' '); }
+
+function fileInfo(root) {
+    const ns = [];
+    (function walk(n, depth) {
+        if (depth > 3) return;
+        for (const c of n.namedChildren) {
+            if (c.type === 'namespace_declaration' || c.type === 'file_scoped_namespace_declaration') ns.push(c.childForFieldName('name')?.text);
+            else if (c.type === 'declaration_list') walk(c, depth + 1);
+        }
+    })(root, 0);
+    return { package: ns.filter(Boolean)[0] ?? null };
+}
+
+export const csharp = {
+    id: 'csharp',
+    grammar: 'c_sharp',
+    extensions: ['.cs'],
+    family: 'dotnet',
+    query: QUERY,
+    implicitThis: true,
+    selfNames: ['this'],
+    externalReceivers: new Set(['Console', 'Math', 'String', 'Task', 'Enumerable', 'Guid', 'DateTime', 'Convert',
+        'Assert', 'Mock', 'JsonSerializer', 'File', 'Path', 'Directory', 'Environment', 'Debug', 'Trace', '_logger', 'logger', 'Logger']),
+    builtinCalls: new Set(['nameof', 'typeof', 'ToString', 'Equals', 'GetHashCode', 'GetType']),
+    testFile: /(^|\/)(tests?|Tests?|[\w.]*\.Tests?)\/|Tests?\.cs$/,
+    commentTypes: ['comment'],
+    parseImport: usingImport,
+    isExported: (node) => /\b(public|internal)\b/.test(modifiers(node)) || node.parent?.parent?.type === 'interface_declaration',
+    visibility: (node) => { const m = modifiers(node); return /\bprivate\b/.test(m) ? 'private' : /\bprotected\b/.test(m) ? 'protected' : /\bpublic\b/.test(m) ? 'public' : null; },
+    isPrimitiveType: (t) => BUILTIN.has(t),
+    transparentTypes: new Set(['Task', 'ValueTask', 'Nullable']),
+    elementTypes: new Set(['List', 'IList', 'IEnumerable', 'ICollection', 'IReadOnlyList', 'IReadOnlyCollection', 'HashSet', 'ISet', 'Queue', 'Stack',
+        'LinkedList', 'Collection', 'ObservableCollection', 'ImmutableList', 'ImmutableArray', 'IAsyncEnumerable', 'IQueryable', 'Span', 'ReadOnlySpan', 'Memory']),
+    elementMethods: new Set(['First', 'FirstOrDefault', 'Last', 'LastOrDefault', 'Single', 'SingleOrDefault', 'ElementAt', 'ElementAtOrDefault', 'Find', 'Dequeue', 'Peek', 'Pop']),
+    mapTypes: new Set(['Dictionary', 'IDictionary', 'IReadOnlyDictionary', 'ConcurrentDictionary', 'SortedDictionary', 'ImmutableDictionary']),
+    mapMethods: new Set(['GetValueOrDefault', 'GetOrAdd']),
+    mapValueMethods: new Set(['Values']),
+    decoratorsOf(node) {
+        return node.namedChildren.filter(c => c.type === 'attribute_list')
+            .flatMap(l => l.namedChildren.filter(a => a.type === 'attribute').map(a => a.childForFieldName('name')?.text))
+            .filter(Boolean).slice(0, 8);
+    },
+    fileInfo,
+    bodyField: 'body',
+};

package/src/parse/lang/ecma.mjs

@@ -0,0 +1,438 @@
+/**
+ * JavaScript / TypeScript / TSX extraction specs.
+ *
+ * Captures follow the engine convention (see ../extract.mjs):
+ *   @def.<kind> + @name [+ @owner]        a definition
+ *   @ref.<kind> + @name [+ @recv]         a reference (call/new/type/inherit/decorator/value)
+ *   @import                               an import/export-from statement (parsed by the hook)
+ *   @import.require + @src                a CommonJS require() call
+ *   @bind + @bind.name + @bind.(type|new|call|expr|elem)    local variable → type evidence
+ *   @field + @field.name + @field.(type|new|expr)           class field → type evidence
+ * (`expr` = the initialiser expression, `elem` = a collection whose element the name is bound to)
+ */
+
+const DEFS_COMMON = `
+(function_declaration name: (identifier) @name) @def.function
+(generator_function_declaration name: (identifier) @name) @def.function
+(class_declaration name: (_) @name) @def.class
+(class name: (_) @name) @def.class
+(class "class" @name !name) @def.class
+(method_definition name: (_) @name) @def.method
+(lexical_declaration (variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression) (generator_function)]) @def.function)
+(variable_declaration (variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression) (generator_function)]) @def.function)
+(variable_declarator name: (identifier) @name value: (class)) @def.class
+(lexical_declaration (variable_declarator name: (identifier) @name value: (_) @_v) @def.variable (#not-match? @_v "^(async\\\\s*)?(function|\\\\(|[A-Za-z_$][A-Za-z0-9_$]*\\\\s*=>)"))
+(variable_declaration (variable_declarator name: (identifier) @name value: (_) @_v) @def.variable (#not-match? @_v "^(async\\\\s*)?(function|\\\\(|[A-Za-z_$][A-Za-z0-9_$]*\\\\s*=>)"))
+(assignment_expression
+  left: (member_expression
+    object: (member_expression object: (identifier) @owner property: (property_identifier) @_proto)
+    property: (property_identifier) @name)
+  right: [(function_expression) (arrow_function)]
+  (#eq? @_proto "prototype")) @def.method
+(expression_statement (assignment_expression
+  left: (member_expression object: (identifier) @owner property: (property_identifier) @name)
+  right: [(function_expression) (arrow_function)])) @def.function
+(expression_statement (assignment_expression
+  left: (member_expression object: (member_expression object: (identifier) @_m property: (property_identifier) @_e) property: (property_identifier) @name)
+  right: [(function_expression) (arrow_function)]
+  (#eq? @_m "module") (#eq? @_e "exports"))) @def.function
+(pair key: (property_identifier) @name value: [(function_expression) (arrow_function)]) @def.method
+(export_statement "default" value: [(function_expression) (arrow_function) (object) (call_expression) (binary_expression) (class)] @name) @def.function
+(export_statement "default" declaration: [(function_declaration !name) (class_declaration !name)] @name) @def.function
+`;
+
+const DEFS_JS = `
+(field_definition property: (_) @name value: [(arrow_function) (function_expression)]) @def.method
+(field_definition property: (_) @name value: (class)) @def.class
+(field_definition property: (_) @name) @def.field
+`;
+
+const DEFS_TS = `
+(function_signature name: (identifier) @name) @def.function
+(abstract_class_declaration name: (type_identifier) @name) @def.class
+(interface_declaration name: (type_identifier) @name) @def.interface
+(type_alias_declaration name: (type_identifier) @name) @def.type
+(enum_declaration name: (identifier) @name) @def.enum
+(internal_module name: (_) @name) @def.module
+(module name: (_) @name) @def.module
+(method_signature name: (_) @name) @def.method
+(abstract_method_signature name: (_) @name) @def.method
+(public_field_definition name: (_) @name value: [(arrow_function) (function_expression)]) @def.method
+(public_field_definition name: (_) @name value: (class)) @def.class
+(public_field_definition name: (_) @name) @def.field
+(required_parameter (accessibility_modifier) pattern: (identifier) @name) @def.field
+(required_parameter "readonly" pattern: (identifier) @name) @def.field
+(optional_parameter (accessibility_modifier) pattern: (identifier) @name) @def.field
+(property_signature name: (_) @name) @def.field
+(function_declaration name: (identifier) @name return_type: (type_annotation (_) @type)) @def.function
+(function_signature name: (identifier) @name return_type: (type_annotation (_) @type)) @def.function
+(method_definition name: (_) @name return_type: (type_annotation (_) @type)) @def.method
+(method_signature name: (_) @name return_type: (type_annotation (_) @type)) @def.method
+(abstract_method_signature name: (_) @name return_type: (type_annotation (_) @type)) @def.method
+(lexical_declaration (variable_declarator name: (identifier) @name value: (arrow_function return_type: (type_annotation (_) @type))) @def.function)
+(public_field_definition name: (_) @name type: (type_annotation (_) @type)) @def.field
+(property_signature name: (_) @name type: (type_annotation (_) @type)) @def.field
+(class_declaration name: (_) @name (class_heritage (extends_clause) @type)) @def.class
+(abstract_class_declaration name: (_) @name (class_heritage (extends_clause) @type)) @def.class
+(class name: (_) @name (class_heritage (extends_clause) @type)) @def.class
+(class "class" @name !name (class_heritage (extends_clause) @type)) @def.class
+(variable_declarator name: (identifier) @name value: (class (class_heritage (extends_clause) @type))) @def.class
+(required_parameter (accessibility_modifier) pattern: (identifier) @name type: (type_annotation (_) @type)) @def.field
+(required_parameter "readonly" pattern: (identifier) @name type: (type_annotation (_) @type)) @def.field
+(optional_parameter (accessibility_modifier) pattern: (identifier) @name type: (type_annotation (_) @type)) @def.field
+`;
+
+const REFS_COMMON = `
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (member_expression object: (_) @recv property: (_) @name)) @ref.call
+(call_expression function: (await_expression (identifier) @name)) @ref.call
+(call_expression function: (await_expression (member_expression object: (_) @recv property: (_) @name))) @ref.call
+(new_expression constructor: (identifier) @name) @ref.new
+(new_expression constructor: (member_expression object: (_) @recv property: (_) @name)) @ref.new
+(decorator (identifier) @name) @ref.decorator
+(decorator (call_expression function: (identifier) @name)) @ref.decorator
+(decorator (call_expression function: (member_expression object: (_) @recv property: (_) @name))) @ref.decorator
+(arguments (identifier) @name) @ref.value
+(pair value: (identifier) @name) @ref.value
+(array (identifier) @name) @ref.value
+(shorthand_property_identifier) @name @ref.value
+(member_expression object: (_) @recv property: (property_identifier) @name) @ref.read
+(member_expression object: (identifier) @name) @ref.value
+(binary_expression operator: "instanceof" right: (identifier) @name) @ref.type
+(computed_property_name (identifier) @name) @ref.value
+(computed_property_name (member_expression object: (_) @recv property: (property_identifier) @name)) @ref.read
+(unary_expression operator: "typeof" argument: (identifier) @name) @ref.value
+(arrow_function body: (identifier) @name) @ref.value
+(ternary_expression consequence: (identifier) @name) @ref.value
+(ternary_expression alternative: (identifier) @name) @ref.value
+(return_statement (identifier) @name) @ref.value
+(variable_declarator value: (identifier) @name) @ref.value
+(assignment_expression right: (identifier) @name) @ref.value
+`;
+
+const REFS_JSX = `
+(jsx_opening_element name: (identifier) @name) @ref.call
+(jsx_self_closing_element name: (identifier) @name) @ref.call
+(jsx_opening_element name: (member_expression object: (_) @recv property: (_) @name)) @ref.call
+(jsx_self_closing_element name: (member_expression object: (_) @recv property: (_) @name)) @ref.call
+`;
+
+const REFS_JS = `
+(class_heritage (identifier) @name) @ref.inherit
+(class_heritage (member_expression object: (_) @recv property: (_) @name)) @ref.inherit
+`;
+
+const REFS_TS = `
+(extends_clause value: (identifier) @name) @ref.inherit
+(extends_clause value: (member_expression object: (_) @recv property: (_) @name)) @ref.inherit
+(implements_clause (type_identifier) @name) @ref.inherit
+(implements_clause (generic_type name: (type_identifier) @name)) @ref.inherit
+(extends_type_clause type: (type_identifier) @name) @ref.inherit
+(extends_type_clause type: (generic_type name: (type_identifier) @name)) @ref.inherit
+(type_identifier) @name @ref.type
+(nested_type_identifier module: (_) @recv name: (type_identifier) @name) @ref.type
+(type_query (identifier) @name) @ref.value
+(type_query (member_expression object: (_) @recv property: (property_identifier) @name)) @ref.type
+`;
+
+const IMPORTS_COMMON = `
+(import_statement) @import
+(export_statement source: (string)) @import
+(call_expression function: (identifier) @_req arguments: (arguments . (string) @src) (#eq? @_req "require")) @import.require
+
+[(arrow_function) (function_expression) (generator_function)] @scope
+(return_statement (_) @ret)
+(arrow_function body: [(call_expression) (new_expression) (member_expression) (identifier) (await_expression) (parenthesized_expression) (this) (subscript_expression)] @ret)
+`;
+
+// `xs.forEach(x => …)`: the first callback parameter of an element-wise method is an element (a
+// map's value for `m.forEach(v => …)`).
+const callbackParam = (param) => `(call_expression
+  function: (member_expression object: (_) @bind.each property: (property_identifier) @_m)
+  arguments: (arguments . (arrow_function ${param}))
+  (#match? @_m "^(forEach|map|filter|find|findLast|findIndex|findLastIndex|some|every|flatMap)$")) @bind`;
+
+const BINDINGS_COMMON = `
+(variable_declarator name: (identifier) @bind.name value: (_) @bind.expr) @bind
+(for_in_statement left: (identifier) @bind.name "of" right: (_) @bind.elem) @bind
+${callbackParam('parameter: (identifier) @bind.name')}
+(assignment_expression left: (member_expression object: (this) property: (property_identifier) @field.name) right: (_) @field.expr) @field
+`;
+
+const BINDINGS_TS = `
+${callbackParam('parameters: (formal_parameters . (required_parameter pattern: (identifier) @bind.name))')}
+(call_expression function: [(identifier) (member_expression)] @cb.fn arguments: (arguments [(arrow_function) (function_expression)] @cb.arg)) @cb
+(variable_declarator name: (identifier) @bind.name type: (type_annotation (_) @bind.type)) @bind
+(required_parameter pattern: (identifier) @bind.name type: (type_annotation (_) @bind.type)) @bind
+(optional_parameter pattern: (identifier) @bind.name type: (type_annotation (_) @bind.type)) @bind
+(variable_declarator name: (object_pattern (pair_pattern key: (property_identifier) @bind.key value: (identifier) @bind.name)) value: (_) @bind.expr) @bind
+(variable_declarator name: (object_pattern (shorthand_property_identifier_pattern) @bind.name @bind.key) value: (_) @bind.expr) @bind
+(required_parameter pattern: (object_pattern (pair_pattern key: (property_identifier) @bind.key value: (identifier) @bind.name)) type: (type_annotation (_) @bind.of)) @bind
+(required_parameter pattern: (object_pattern (shorthand_property_identifier_pattern) @bind.name @bind.key) type: (type_annotation (_) @bind.of)) @bind
+(public_field_definition name: (property_identifier) @field.name type: (type_annotation (_) @field.type)) @field
+(public_field_definition name: (property_identifier) @field.name value: (_) @field.expr) @field
+(required_parameter (accessibility_modifier) pattern: (identifier) @field.name type: (type_annotation (_) @field.type)) @field
+(required_parameter "readonly" pattern: (identifier) @field.name type: (type_annotation (_) @field.type)) @field
+(optional_parameter (accessibility_modifier) pattern: (identifier) @field.name type: (type_annotation (_) @field.type)) @field
+`;
+
+const BINDINGS_JS = `
+${callbackParam('parameters: (formal_parameters . (identifier) @bind.name)')}
+(field_definition property: (property_identifier) @field.name value: (_) @field.expr) @field
+`;
+
+// Wrappers whose members are reached through the wrapped type (after await / by convention).
+const TRANSPARENT_TYPES = new Set(['Promise', 'PromiseLike', 'Awaited', 'Readonly', 'Partial', 'Required', 'NonNullable', 'DeepPartial', 'DeepReadonly', 'Mutable', 'Pick', 'Omit']);
+/**
+ * What a type alias has the members of: `type E = Pick<Entry, 'a'>`, `type E = Entry & { b: B }`,
+ * `type E = Readonly<Entry>` — each named type it is made of (through the wrappers above).
+ */
+function aliasBases(node) {
+    if (node.type !== 'type_alias_declaration') return [];
+    const value = node.childForFieldName('value');
+    const out = [];
+    const visit = (n, depth = 0) => {
+        if (!n || depth > 4) return;
+        if (n.type === 'intersection_type' || n.type === 'parenthesized_type') { for (const c of n.namedChildren) visit(c, depth + 1); return; }
+        if (n.type === 'type_identifier') { out.push(n.text); return; }
+        if (n.type === 'nested_type_identifier') { out.push(n.childForFieldName('name')?.text); return; }
+        if (n.type === 'generic_type') {
+            const head = n.childForFieldName('name');
+            const name = head?.type === 'nested_type_identifier' ? head.childForFieldName('name')?.text : head?.text;
+            if (TRANSPARENT_TYPES.has(name)) visit(n.childForFieldName('type_arguments')?.namedChildren[0], depth + 1);
+            else if (name) out.push(name);
+        }
+    };
+    visit(value);
+    return out.filter(Boolean);
+}
+
+// Collections: `x[i]`, `for (const e of x)` and `x.forEach(e => …)` see the element type.
+const ELEMENT_TYPES = new Set(['Array', 'ReadonlyArray', 'Set', 'ReadonlySet', 'Iterable', 'IterableIterator', 'Iterator', 'AsyncIterable', 'AsyncIterableIterator', 'Generator', 'AsyncGenerator']);
+// Types whose members never live in the repository.
+// (`any` / `unknown` are not here: a value of that type may well be an instance of a repository class)
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'symbol', 'object', 'void', 'never', 'undefined', 'null',
+    'String', 'Number', 'Boolean', 'Object', 'Function', 'Date', 'RegExp', 'Map', 'WeakMap', 'WeakSet', 'Record', 'Error', 'Buffer',
+    'ArrayBuffer', 'Uint8Array', 'DataView', 'URL', 'URLSearchParams', 'Headers', 'Request', 'Response', 'AbortController', 'AbortSignal']);
+
+// Ubiquitous globals whose members never resolve into the repository.
+const EXTERNAL_RECEIVERS = new Set([
+    'console', 'JSON', 'Math', 'Object', 'Array', 'Promise', 'Reflect', 'Number', 'String', 'Symbol',
+    'Date', 'process', 'window', 'document', 'globalThis', 'Buffer', 'Intl', 'navigator', 'performance',
+    'localStorage', 'sessionStorage', 'location', 'history', 'Error', 'Map', 'Set', 'WeakMap', 'RegExp',
+    'module', 'exports', 'require', 'jest', 'vi', 'expect', 'assert', 'chai', 'sinon',
+]);
+const BUILTIN_CALLS = new Set([
+    'require', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'setImmediate', 'parseInt',
+    'parseFloat', 'isNaN', 'isFinite', 'encodeURIComponent', 'decodeURIComponent', 'encodeURI', 'decodeURI',
+    'String', 'Number', 'Boolean', 'Symbol', 'BigInt', 'queueMicrotask', 'structuredClone', 'fetch', 'eval',
+    'describe', 'it', 'test', 'expect', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll', 'suite', 'context',
+]);
+
+// a top-level integration/ directory holds integration-test apps (nestjs, many monorepos)
+const TEST_FILE_RE = /(^|\/)(__tests__|__mocks__|tests?|spec|e2e)\/|^integration\/|\.(test|spec|e2e-spec|cy)\.[cm]?[jt]sx?$/;
+
+function stripQuotes(s) { return s.replace(/^['"`]|['"`]$/g, ''); }
+
+/** Parse an ES import / export-from statement node into import records. */
+function parseImportNode(node) {
+    const out = [];
+    const srcNode = node.childForFieldName('source');
+    if (!srcNode) return out;
+    const source = stripQuotes(srcNode.text);
+    if (node.type === 'import_statement') {
+        let any = false;
+        for (const child of node.namedChildren) {
+            if (child.type === 'import_clause') {
+                for (const c of child.namedChildren) {
+                    if (c.type === 'identifier') { out.push({ source, imported: 'default', local: c.text }); any = true; }
+                    else if (c.type === 'namespace_import') {
+                        const id = c.namedChildren.find(n => n.type === 'identifier');
+                        if (id) { out.push({ source, imported: '*', local: id.text }); any = true; }
+                    } else if (c.type === 'named_imports') {
+                        for (const spec of c.namedChildren) {
+                            if (spec.type !== 'import_specifier') continue;
+                            const name = spec.childForFieldName('name')?.text;
+                            const alias = spec.childForFieldName('alias')?.text;
+                            if (name) { out.push({ source, imported: stripQuotes(name), local: alias || stripQuotes(name) }); any = true; }
+                        }
+                    }
+                }
+            } else if (child.type === 'import_require_clause') {
+                const id = child.namedChildren.find(n => n.type === 'identifier');
+                if (id) { out.push({ source, imported: '*', local: id.text }); any = true; }
+            }
+        }
+        if (!any) out.push({ source, imported: null, local: null }); // side-effect import
+    } else if (node.type === 'export_statement') {
+        const clause = node.namedChildren.find(n => n.type === 'export_clause');
+        const nsExport = node.namedChildren.find(n => n.type === 'namespace_export');
+        if (clause) {
+            for (const spec of clause.namedChildren) {
+                if (spec.type !== 'export_specifier') continue;
+                const name = spec.childForFieldName('name')?.text;
+                const alias = spec.childForFieldName('alias')?.text;
+                if (name) out.push({ source, imported: stripQuotes(name), local: null, reexport: stripQuotes(alias || name) });
+            }
+        } else if (nsExport) {
+            const id = nsExport.namedChildren[0];
+            out.push({ source, imported: '*', local: null, reexport: id ? stripQuotes(id.text) : '*' });
+        } else {
+            out.push({ source, imported: '*', local: null, reexport: '*' });
+        }
+    }
+    return out;
+}
+
+/** const x = require('m') / const { a, b: c } = require('m') / require('m') */
+function parseRequire(callNode, srcNode) {
+    const source = stripQuotes(srcNode.text);
+    let p = callNode.parent;
+    if (p?.type === 'await_expression') p = p.parent;
+    if (p?.type === 'variable_declarator') {
+        const nameNode = p.childForFieldName('name');
+        if (nameNode?.type === 'identifier') return [{ source, imported: '*', local: nameNode.text }];
+        if (nameNode?.type === 'object_pattern') {
+            const out = [];
+            for (const c of nameNode.namedChildren) {
+                if (c.type === 'shorthand_property_identifier_pattern') out.push({ source, imported: c.text, local: c.text });
+                else if (c.type === 'pair_pattern') {
+                    const k = c.childForFieldName('key')?.text, v = c.childForFieldName('value');
+                    if (k && v?.type === 'identifier') out.push({ source, imported: k, local: v.text });
+                }
+            }
+            if (out.length) return out;
+        }
+    }
+    return [{ source, imported: null, local: null }];
+}
+
+// what names a class expression (`const X = class {}`, a field, a default export) is the definition
+const CLASS_HOLDERS = new Set(['variable_declarator', 'public_field_definition', 'field_definition', 'export_statement']);
+const isAnonymousClass = (node) => node.type === 'class' && !node.childForFieldName('name');
+
+/**
+ * The name of an anonymous class expression: what importers call it when it is a CommonJS export
+ * (`module.exports = class …`, `exports.Foo = class …`), else `<anonymous>` (`return class extends
+ * ModuleRef {…}`, `{ useClass: class {…} }`), a name no code can refer to. It is a symbol of its
+ * own so that `this` in its methods is an instance of it and its bases.
+ */
+function anonymousClassName(node, relPath) {
+    const p = node.parent;
+    const left = p?.type === 'assignment_expression' && p.childForFieldName('right')?.id === node.id ? p.childForFieldName('left') : null;
+    const target = left?.type === 'member_expression' ? left.text.replace(/\s+/g, '') : '';
+    if (target === 'module.exports') return fileStem(relPath) || '<anonymous>';
+    if (/^(module\.)?exports\.[A-Za-z_$][\w$]*$/.test(target)) return target.slice(target.lastIndexOf('.') + 1);
+    return '<anonymous>';
+}
+
+/** What importers call a module's default export: its file name in camel case (`index` → its directory). */
+function fileStem(relPath) {
+    const base = String(relPath ?? '').split('/').pop().replace(/\.[^.]+$/, '');
+    const stem = base === 'index' ? String(relPath).split('/').slice(-2, -1)[0] ?? base : base;
+    return stem.replace(/[-_.](\w)/g, (_, c) => c.toUpperCase()) || null;
+}
+
+/** `Array.from(xs)` and `[...xs]` hold the elements of xs: the node of xs, else null. */
+function collectionSource(node) {
+    const only = (list) => { const kids = list?.namedChildren.filter(n => n.type !== 'comment') ?? []; return kids.length === 1 ? kids[0] : null; };
+    if (node.type === 'call_expression' && node.childForFieldName('function')?.text.replace(/\s+/g, '') === 'Array.from') {
+        const arg = only(node.childForFieldName('arguments')); // a second argument maps the elements
+        return arg && arg.type !== 'spread_element' ? arg : null;
+    }
+    if (node.type === 'array') {
+        const el = only(node);
+        return el?.type === 'spread_element' ? el.namedChildren[0] ?? null : null;
+    }
+    return null;
+}
+
+/** `const x = require('y')` / `const x = require('y').z` / `const {a} = require('y')` are imports, not definitions. */
+function isRequireBinding(node) {
+    const decl = node.type === 'variable_declarator' ? node : node.namedChildren?.find(c => c.type === 'variable_declarator');
+    const v = decl?.childForFieldName('value');
+    return !!v && /^(await\s+)?require\s*\(/.test(v.text);
+}
+
+function isModuleLevel(node) {
+    // a variable declarator is module-level if its declaration sits in program / export_statement
+    let decl = node.type === 'variable_declarator' ? node.parent : node;
+    const p = decl?.parent;
+    return p?.type === 'program' || (p?.type === 'export_statement' && p.parent?.type === 'program');
+}
+
+function isExported(defNode) {
+    let n = defNode;
+    if (n.type === 'variable_declarator') n = n.parent;
+    const p = n.parent;
+    if (p?.type === 'export_statement') return true;
+    // `module.exports.x = ...`, `exports.x = ...`
+    if (defNode.type === 'expression_statement') return /^(module\.)?exports\./.test(defNode.text);
+    return false;
+}
+
+function visibility(defNode) {
+    for (const c of defNode.children) {
+        if (c.type === 'accessibility_modifier') return c.text; // public/private/protected
+    }
+    const name = defNode.childForFieldName('name');
+    if (name?.type === 'private_property_identifier') return 'private';
+    return null;
+}
+
+function makeSpec(id, grammar, extensions, { ts, jsx }) {
+    return {
+        id,
+        grammar,
+        extensions,
+        family: 'ecma',
+        query: [
+            DEFS_COMMON, ts ? DEFS_TS : DEFS_JS,
+            REFS_COMMON, ts ? REFS_TS : REFS_JS, jsx ? REFS_JSX : '',
+            IMPORTS_COMMON, BINDINGS_COMMON, ts ? BINDINGS_TS : BINDINGS_JS,
+        ].join('\n'),
+        implicitThis: false,
+        implicitBases: aliasBases,
+        selfNames: ['this'],
+        externalReceivers: EXTERNAL_RECEIVERS,
+        builtinCalls: BUILTIN_CALLS,
+        transparentTypes: TRANSPARENT_TYPES,
+        elementTypes: ELEMENT_TYPES,
+        isPrimitiveType: (t) => PRIMITIVE_TYPES.has(t),
+        elementMethods: new Set(['at', 'find', 'findLast', 'pop', 'shift']),
+        mapTypes: new Set(['Map', 'ReadonlyMap', 'WeakMap', 'Record']),
+        mapMethods: new Set(['get']),
+        mapValueMethods: new Set(['values']),
+        cleanType: (t) => t.replace(/^extends\s+/, ''),
+        testFile: TEST_FILE_RE,
+        commentTypes: ['comment'],
+        containerKinds: new Set(['class', 'interface', 'module', 'enum', 'function', 'method']),
+        parseImport: parseImportNode,
+        collectionSource,
+        filterDef: (d) => !((d.kind === 'variable') && isRequireBinding(d.node))
+            && !(isAnonymousClass(d.node) && CLASS_HOLDERS.has(d.node.parent?.type)), // named by its holder
+        // `export default class extends Base {…}` is a class (its methods' `this`), not a function
+        refineKind: (kind, d) => (d.node.type === 'export_statement' && (d.nameNode.type === 'class' || d.nameNode.type === 'class_declaration') ? 'class' : kind),
+        normalizeName: (name, d, relPath) => {
+            if (d.node.type === 'export_statement') {
+                // default export → its own name, else named after its file (what importers call it)
+                d.isDefault = true;
+                const inner = d.nameNode;
+                let own = inner.childForFieldName?.('name')?.text;
+                if (!own && inner.type === 'binary_expression') own = inner.childForFieldName('right')?.childForFieldName?.('name')?.text;
+                return own || fileStem(relPath);
+            }
+            if (isAnonymousClass(d.node)) return anonymousClassName(d.node, relPath);
+            return name;
+        },
+        parseRequire,
+        isModuleLevel,
+        isExported,
+        visibility,
+        bodyField: 'body',
+    };
+}
+
+export const javascript = makeSpec('javascript', 'javascript', ['.js', '.jsx', '.mjs', '.cjs'], { ts: false, jsx: true });
+export const typescript = makeSpec('typescript', 'typescript', ['.ts', '.mts', '.cts'], { ts: true, jsx: false });
+export const tsx = makeSpec('tsx', 'tsx', ['.tsx'], { ts: true, jsx: true });