brainclaw 1.24.0 → 1.26.0

package/dist/core/code-map/lang/typescript/config.js

@@ -0,0 +1,271 @@
+/**
+ * Bounded, local TypeScript/JavaScript resolver configuration.
+ *
+ * Only root tsconfig/jsconfig, local extends, baseUrl and paths are supported.
+ * Package extends and node_modules are deliberately never read. Any malformed,
+ * escaping, cyclic, or ambiguous configuration is invalid so callers abstain.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_EXTENDS_DEPTH = 8;
+const CONFIG_FILENAMES = ['tsconfig.json', 'jsconfig.json'];
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+function configFingerprint(parts) {
+    return `sha256:${crypto.createHash('sha256').update(parts.join('\n'), 'utf8').digest('hex')}`;
+}
+/** Strip JSONC comments without changing comment-looking text inside strings. */
+function stripJsonComments(source) {
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        const next = source[i + 1];
+        if (inString) {
+            out += ch;
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            i++;
+            while (i + 1 < source.length && source[i + 1] !== '\n' && source[i + 1] !== '\r')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            const close = source.indexOf('*/', i + 2);
+            if (close < 0)
+                return null;
+            i = close + 1;
+            continue;
+        }
+        out += ch;
+    }
+    return inString ? null : out;
+}
+/** JSONC permits trailing commas; remove them only outside quoted strings. */
+function stripTrailingCommas(source) {
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (inString) {
+            out += ch;
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            let next = i + 1;
+            while (next < source.length && /\s/.test(source[next]))
+                next++;
+            if (source[next] === '}' || source[next] === ']')
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function parseJsonc(source) {
+    const withoutComments = stripJsonComments(source);
+    if (withoutComments === null)
+        return null;
+    try {
+        const parsed = JSON.parse(stripTrailingCommas(withoutComments));
+        return isObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isWithin(root, absolute) {
+    const rel = path.relative(root, absolute);
+    return rel === '' || (!path.isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path.sep}`));
+}
+function projectRelative(root, absolute) {
+    return isWithin(root, absolute) ? toPosix(path.relative(root, absolute)) : null;
+}
+/** Resolve a config-local directory, refusing absolute and project-escaping values. */
+function localDirectory(root, configDir, value) {
+    if (path.isAbsolute(value))
+        return null;
+    return projectRelative(root, path.resolve(configDir, value));
+}
+function starCount(value) {
+    return [...value].filter((c) => c === '*').length;
+}
+function parsePaths(raw, root, configDir, baseUrl) {
+    if (!isObject(raw))
+        return null;
+    const targetDir = baseUrl === null ? configDir : path.resolve(root, baseUrl);
+    const mappings = [];
+    for (const pattern of Object.keys(raw).sort()) {
+        const values = raw[pattern];
+        const stars = starCount(pattern);
+        if (pattern.length === 0 || stars > 1 || !Array.isArray(values) || values.length === 0)
+            return null;
+        const targets = [];
+        for (const value of values) {
+            if (typeof value !== 'string' || starCount(value) > 1 || (stars === 0 && starCount(value) !== 0))
+                return null;
+            const target = localDirectory(root, targetDir, value);
+            if (target === null)
+                return null;
+            targets.push(target);
+        }
+        mappings.push({ pattern, targets });
+    }
+    return mappings;
+}
+function localExtendsPath(root, configDir, value) {
+    // Bare values name packages; never follow them, even if node_modules is present.
+    if (!value.startsWith('./') && !value.startsWith('../'))
+        return null;
+    const candidate = path.resolve(configDir, value);
+    if (!isWithin(root, candidate))
+        return null;
+    const jsonPath = path.extname(candidate) ? candidate : `${candidate}.json`;
+    return isWithin(root, jsonPath) ? jsonPath : null;
+}
+function readConfig(filename, depth, state) {
+    const empty = { baseUrl: null, paths: [] };
+    if (depth > MAX_EXTENDS_DEPTH || state.seen.has(filename) || !isWithin(state.root, filename)) {
+        return { valid: false, options: empty };
+    }
+    state.seen.add(filename);
+    let source;
+    try {
+        source = fs.readFileSync(filename, 'utf8');
+    }
+    catch {
+        return { valid: false, options: empty };
+    }
+    state.fingerprintParts.push(`${projectRelative(state.root, filename) ?? filename}\u0000${source}`);
+    const json = parseJsonc(source);
+    if (!json)
+        return { valid: false, options: empty };
+    const configDir = path.dirname(filename);
+    let inherited = empty;
+    if (json.extends !== undefined) {
+        if (typeof json.extends !== 'string')
+            return { valid: false, options: empty };
+        const parent = localExtendsPath(state.root, configDir, json.extends);
+        if (!parent)
+            return { valid: false, options: empty };
+        const parentResult = readConfig(parent, depth + 1, state);
+        if (!parentResult.valid)
+            return { valid: false, options: empty };
+        inherited = parentResult.options;
+    }
+    if (json.compilerOptions !== undefined && !isObject(json.compilerOptions))
+        return { valid: false, options: empty };
+    const options = json.compilerOptions ?? {};
+    let baseUrl = inherited.baseUrl;
+    if (options.baseUrl !== undefined) {
+        if (typeof options.baseUrl !== 'string')
+            return { valid: false, options: empty };
+        baseUrl = localDirectory(state.root, configDir, options.baseUrl);
+        if (baseUrl === null)
+            return { valid: false, options: empty };
+    }
+    let paths = inherited.paths;
+    if (options.paths !== undefined) {
+        const parsedPaths = parsePaths(options.paths, state.root, configDir, baseUrl);
+        if (!parsedPaths)
+            return { valid: false, options: empty };
+        paths = parsedPaths;
+    }
+    return { valid: true, options: { baseUrl, paths } };
+}
+/**
+ * Read exactly one root configuration. Two root configs are intentionally
+ * ambiguous: TypeScript tooling can choose based on invocation, Code Map cannot.
+ */
+export function loadTypeScriptResolutionConfig(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const found = CONFIG_FILENAMES.map((name) => path.join(root, name)).filter((filename) => fs.existsSync(filename));
+    if (found.length === 0) {
+        return { kind: 'typescript-resolution-config', fingerprint: configFingerprint([]), valid: true, baseUrl: null, paths: [] };
+    }
+    if (found.length > 1) {
+        const parts = found.map((filename) => {
+            try {
+                return `${path.basename(filename)}\u0000${fs.readFileSync(filename, 'utf8')}`;
+            }
+            catch {
+                return `${path.basename(filename)}\u0000<unreadable>`;
+            }
+        });
+        return { kind: 'typescript-resolution-config', fingerprint: configFingerprint(parts), valid: false, baseUrl: null, paths: [] };
+    }
+    const state = { root, seen: new Set(), fingerprintParts: [] };
+    const result = readConfig(found[0], 0, state);
+    return {
+        kind: 'typescript-resolution-config',
+        fingerprint: configFingerprint(state.fingerprintParts),
+        valid: result.valid,
+        baseUrl: result.valid ? result.options.baseUrl : null,
+        paths: result.valid ? result.options.paths : [],
+    };
+}
+export function isTypeScriptResolutionConfig(value) {
+    return !!value && typeof value === 'object' && value.kind === 'typescript-resolution-config';
+}
+function matchPattern(pattern, specifier) {
+    const star = pattern.indexOf('*');
+    if (star < 0)
+        return pattern === specifier ? '' : null;
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+        return null;
+    return specifier.slice(prefix.length, specifier.length - suffix.length);
+}
+/** Map a bare specifier to project-relative candidate bases, or no candidates. */
+export function typeScriptSpecifierBases(specifier, config) {
+    if (!config?.valid)
+        return [];
+    const matches = config.paths
+        .map((mapping) => ({ mapping, wildcard: matchPattern(mapping.pattern, specifier) }))
+        .filter((match) => match.wildcard !== null);
+    // Overlapping paths patterns are intentionally not ranked: ambiguity abstains.
+    if (matches.length > 1)
+        return [];
+    if (matches.length === 1) {
+        const { mapping, wildcard } = matches[0];
+        // `parsePaths` garantit AU PLUS une `*` par cible (starCount > 1 ⇒ config invalide,
+        // donc abstention totale) : split/join et replace-première-occurrence sont ici
+        // équivalents. split/join est préféré parce qu'il reste correct même si cet
+        // invariant bougeait — et il est lisible par l'analyse statique (js/incomplete-
+        // sanitization signalait le replace sans pouvoir voir l'invariant amont).
+        return mapping.targets.map((target) => target.split('*').join(wildcard));
+    }
+    return config.baseUrl === null ? [] : [path.posix.join(config.baseUrl, specifier)];
+}
+//# sourceMappingURL=config.js.map

package/dist/core/code-map/lang/typescript/index.js

@@ -26,6 +26,8 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { grammarHash, grammarName, loadGrammar } from '../../wasm-loader.js';
 import { extractWithQueries } from '../query-runtime.js';
+import { extractLexicalUsages } from '../usages.js';
+import { isTypeScriptResolutionConfig, typeScriptSpecifierBases, } from './config.js';
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 /** Resolve a vendored `.scm` next to this module (dist) or from the source tree. */
 function readScm(basename) {
@@ -149,7 +151,7 @@ const queries = {
 };
 const vocabulary = {
     nodeSubtypes: ['function', 'class', 'type', 'interface', 'variable', 'component', 'hook', 'export'],
-    edgeKinds: ['contains', 'defines', 'imports', 'exports'],
+    edgeKinds: ['contains', 'defines', 'imports', 'exports', 'calls', 'references', 'possible_textual_match'],
     captureMap: queries.captureMap,
 };
 const capabilities = {
@@ -173,10 +175,7 @@ const JS_LIKE_EXTS = new Set(['.js', '.jsx', '.mjs', '.cjs']);
  * extension, then `<candidate>/index.<ext>`. Return the FIRST that is an indexed
  * file. Bare/external specifiers (`react`, `@scope/x`) → no resolution (no edge).
  */
-function resolveTsImport(spec, fromPath, ctx) {
-    if (!spec.startsWith('./') && !spec.startsWith('../'))
-        return null; // external/bare → no edge
-    const base = path.posix.join(path.posix.dirname(fromPath), spec); // normalized project-relative
+function resolveTsCandidate(base, ctx) {
     const ext = path.posix.extname(base);
     const candidates = [];
     if (ext) {
@@ -198,6 +197,24 @@ function resolveTsImport(spec, fromPath, ctx) {
     }
     return null;
 }
+function resolveTsImport(spec, fromPath, ctx) {
+    if (spec.startsWith('./') || spec.startsWith('../')) {
+        return resolveTsCandidate(path.posix.join(path.posix.dirname(fromPath), spec), ctx);
+    }
+    const config = isTypeScriptResolutionConfig(ctx.resolverConfig) ? ctx.resolverConfig : undefined;
+    const candidates = typeScriptSpecifierBases(spec, config);
+    if (candidates.length === 0)
+        return null; // external, invalid, or ambiguous config
+    const resolved = new Set();
+    for (const candidate of candidates) {
+        const target = resolveTsCandidate(candidate, ctx);
+        if (target)
+            resolved.add(target);
+    }
+    // Do not adopt TypeScript's fallback preference when config candidates produce
+    // different indexed files: Code Map is deliberately soundness-first.
+    return resolved.size === 1 ? [...resolved][0] : null;
+}
 function isDefSourceNode(v) {
     return (typeof v === 'object' &&
         v !== null &&
@@ -289,7 +306,8 @@ export class TypeScriptProvider {
             }
             return d;
         });
-        return { ...draft, definitions };
+        const tree = draft.attributes?.__tree;
+        return { ...draft, definitions, usages: extractLexicalUsages(tree?.rootNode, definitions, 'js-ts') };
     }
     /**
      * P1c file-level import resolution (intra-project, relative specifiers). Returns

package/dist/core/code-map/lang/usages.js

@@ -0,0 +1,333 @@
+const FUNCTION_SUBTYPES = new Set(['function', 'component', 'hook']);
+const LOW_CONFIDENCE_TEXTUAL_MATCH = 0.2;
+function sourceOf(definition) {
+    const value = definition.sourceNode;
+    if (!value || typeof value !== 'object' || !('node' in value) || !('nameNode' in value))
+        return null;
+    const candidate = value;
+    return candidate.node && candidate.nameNode ? candidate : null;
+}
+function spanOf(node) {
+    return {
+        start_line: node.startPosition.row + 1,
+        start_col: node.startPosition.column + 1,
+        end_line: node.endPosition.row + 1,
+        end_col: node.endPosition.column + 1,
+    };
+}
+function nodeKey(node) {
+    return `${node.type}:${node.startIndex}:${node.endIndex}`;
+}
+function sameNode(a, b) {
+    return !!a && a.type === b.type && a.startIndex === b.startIndex && a.endIndex === b.endIndex;
+}
+function field(node, name) {
+    try {
+        return node.childForFieldName(name);
+    }
+    catch {
+        return null;
+    }
+}
+function walk(node, visit) {
+    visit(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            walk(child, visit);
+    }
+}
+function walkScope(node, rootScope, language, visit) {
+    visit(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        // Bindings in a nested function/class/lambda cannot shadow a use in this
+        // scope. Skipping them avoids false abstention between sibling functions.
+        if (child !== rootScope && isScope(child, language))
+            continue;
+        walkScope(child, rootScope, language, visit);
+    }
+}
+function hasAncestor(node, types) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (types.has(parent.type))
+            return true;
+    }
+    return false;
+}
+function isTopLevelPythonFunction(definition) {
+    const source = sourceOf(definition);
+    if (!source)
+        return false;
+    let parent = source.node.parent;
+    if (parent?.type === 'decorated_definition')
+        parent = parent.parent;
+    return parent?.type === 'module';
+}
+function isLocalFunctionTarget(definition, language) {
+    if (!FUNCTION_SUBTYPES.has(definition.subtype))
+        return false;
+    // JS/TS tags are already program-anchored. Python captures nested functions too,
+    // so retain only module bindings: nested/method names need a real scope engine.
+    return language === 'js-ts' || isTopLevelPythonFunction(definition);
+}
+function isCallerDefinition(definition) {
+    return FUNCTION_SUBTYPES.has(definition.subtype);
+}
+function definitionRange(definition) {
+    const source = sourceOf(definition);
+    if (!source)
+        return null;
+    // A lexical declaration can carry several declarators. The declarator, not the
+    // shared statement span, is the smallest safe caller container for an arrow.
+    return source.nameNode.parent ?? source.node;
+}
+function contains(container, node) {
+    return container.startIndex <= node.startIndex && container.endIndex >= node.endIndex;
+}
+function callerFor(node, definitions) {
+    let winner;
+    for (const definition of definitions) {
+        if (!isCallerDefinition(definition))
+            continue;
+        const range = definitionRange(definition);
+        if (!range || !contains(range, node))
+            continue;
+        const width = range.endIndex - range.startIndex;
+        if (!winner || width < winner.width || (width === winner.width && definition.ordinal > winner.ordinal)) {
+            winner = { ordinal: definition.ordinal, width };
+        }
+    }
+    return winner?.ordinal;
+}
+function isScope(node, language) {
+    if (language === 'python')
+        return ['module', 'function_definition', 'lambda', 'class_definition'].includes(node.type);
+    return ['program', 'function_declaration', 'function_expression', 'arrow_function', 'method_definition'].includes(node.type);
+}
+function isParameterIdentifier(node, language) {
+    const parameterTypes = language === 'python'
+        ? new Set(['parameters', 'lambda_parameters'])
+        : new Set(['formal_parameters', 'required_parameter', 'optional_parameter', 'rest_pattern']);
+    return hasAncestor(node, parameterTypes);
+}
+function isBindingIdentifier(node, language) {
+    if (node.type !== 'identifier')
+        return false;
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (sameNode(field(parent, 'name'), node) && [
+        'variable_declarator', 'function_declaration', 'generator_function_declaration',
+        'function_definition', 'class_declaration', 'class_definition', 'aliased_import',
+    ].includes(parent.type))
+        return true;
+    if (sameNode(field(parent, 'left'), node) && [
+        'assignment', 'augmented_assignment', 'for_statement', 'with_item',
+    ].includes(parent.type))
+        return true;
+    return isParameterIdentifier(node, language);
+}
+function scopeBinds(scope, name, language, allowed) {
+    let found = false;
+    walkScope(scope, scope, language, (candidate) => {
+        if (found || candidate.text !== name || !isBindingIdentifier(candidate, language))
+            return;
+        if (!allowed.has(nodeKey(candidate)))
+            found = true;
+    });
+    return found;
+}
+function isShadowed(node, name, language, allowed) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (isScope(parent, language) && scopeBinds(parent, name, language, allowed))
+            return true;
+    }
+    return false;
+}
+function propertyOf(node) {
+    return field(node, 'property') ?? field(node, 'attribute');
+}
+function isProperty(node) {
+    const parent = node.parent;
+    return !!parent && sameNode(propertyOf(parent), node)
+        && ['member_expression', 'optional_member_expression', 'attribute'].includes(parent.type);
+}
+function isValueReference(node, language) {
+    if (node.type !== 'identifier' || isBindingIdentifier(node, language))
+        return false;
+    const parent = node.parent;
+    if (!parent || isProperty(node))
+        return false;
+    if (hasAncestor(node, new Set(['import_statement', 'import_from_statement'])))
+        return false;
+    if (sameNode(field(parent, 'key'), node) || ['export_specifier', 'export_clause'].includes(parent.type))
+        return false;
+    // Type positions have distinct namespaces in TS and do not prove a value-level use.
+    if (hasAncestor(node, new Set(['type_annotation', 'type_alias_declaration', 'interface_declaration', 'type_identifier'])))
+        return false;
+    return true;
+}
+function addBinding(bindings, localName, binding) {
+    const previous = bindings.get(localName);
+    bindings.set(localName, previous === undefined ? binding : null);
+}
+function stripQuotes(text) {
+    return text.replace(/^['"`]|['"`]$/g, '');
+}
+function jsTsBindings(root) {
+    const bindings = new Map();
+    walk(root, (statement) => {
+        if (statement.type !== 'import_statement')
+            return;
+        const source = field(statement, 'source');
+        if (!source)
+            return;
+        const module = stripQuotes(source.text);
+        let clause = null;
+        for (let i = 0; i < statement.namedChildCount; i++) {
+            const child = statement.namedChild(i);
+            if (child?.type === 'import_clause') {
+                clause = child;
+                break;
+            }
+        }
+        if (!clause)
+            return;
+        walk(clause, (candidate) => {
+            if (candidate.type !== 'import_specifier')
+                return;
+            const imported = field(candidate, 'name');
+            if (!imported || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(imported.text))
+                return;
+            const alias = field(candidate, 'alias');
+            addBinding(bindings, (alias ?? imported).text, {
+                module,
+                importedName: imported.text,
+                bindingNode: alias ?? imported,
+            });
+        });
+    });
+    return bindings;
+}
+function pythonBindings(root) {
+    const bindings = new Map();
+    walk(root, (statement) => {
+        if (statement.type !== 'import_from_statement')
+            return;
+        const source = field(statement, 'module_name');
+        if (!source)
+            return;
+        const module = source.text;
+        for (let i = 0; i < statement.namedChildCount; i++) {
+            const child = statement.namedChild(i);
+            if (!child || sameNode(child, source))
+                continue;
+            if (child.type === 'dotted_name' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(child.text)) {
+                addBinding(bindings, child.text, { module, importedName: child.text, bindingNode: child });
+            }
+            else if (child.type === 'aliased_import') {
+                const imported = field(child, 'name');
+                const alias = field(child, 'alias');
+                if (imported && alias && /^[A-Za-z_][A-Za-z0-9_]*$/.test(imported.text)) {
+                    addBinding(bindings, alias.text, { module, importedName: imported.text, bindingNode: alias });
+                }
+            }
+        }
+    });
+    return bindings;
+}
+/** Extract provider-local, soundness-first usage drafts from an already parsed tree. */
+export function extractLexicalUsages(root, definitions, language) {
+    if (!root)
+        return [];
+    const localTargets = new Map();
+    const allowedBindings = new Set();
+    for (const definition of definitions) {
+        if (!isLocalFunctionTarget(definition, language))
+            continue;
+        const previous = localTargets.get(definition.name);
+        localTargets.set(definition.name, previous === undefined ? definition : null);
+        const source = sourceOf(definition);
+        if (source)
+            allowedBindings.add(nodeKey(source.nameNode));
+    }
+    const bindings = language === 'js-ts' ? jsTsBindings(root) : pythonBindings(root);
+    for (const binding of bindings.values())
+        if (binding)
+            allowedBindings.add(nodeKey(binding.bindingNode));
+    const usages = [];
+    const seen = new Set();
+    const handledCallIdentifiers = new Set();
+    const handledProperties = new Set();
+    const add = (node, kind, target) => {
+        const caller = callerFor(node, definitions);
+        const targetKey = target.kind === 'local'
+            ? `local:${target.definitionOrdinal}`
+            : `import:${target.module}:${target.importedName}`;
+        const key = `${nodeKey(node)}:${kind}:${caller ?? 'file'}:${targetKey}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        usages.push({
+            kind,
+            ...(caller === undefined ? {} : { fromDefinitionOrdinal: caller }),
+            target,
+            span: spanOf(node),
+            confidence: kind === 'possible_textual_match' ? LOW_CONFIDENCE_TEXTUAL_MATCH : 1.0,
+        });
+    };
+    const directUse = (node, kind) => {
+        const name = node.text;
+        const local = localTargets.get(name);
+        const imported = bindings.get(name);
+        if ((local === undefined || local === null) && (!imported || imported === null))
+            return;
+        if (isShadowed(node, name, language, allowedBindings))
+            return;
+        if (local && local !== null) {
+            add(node, kind, { kind: 'local', definitionOrdinal: local.ordinal });
+        }
+        else if (imported) {
+            add(node, kind, { kind: 'import', module: imported.module, importedName: imported.importedName });
+        }
+    };
+    walk(root, (node) => {
+        if (node.type !== 'call_expression' && node.type !== 'call')
+            return;
+        const callee = field(node, 'function');
+        if (callee?.type === 'identifier') {
+            handledCallIdentifiers.add(nodeKey(callee));
+            directUse(callee, 'calls');
+            return;
+        }
+        if (!callee)
+            return;
+        const property = propertyOf(callee);
+        const local = property ? localTargets.get(property.text) : undefined;
+        if (property && local && local !== null) {
+            handledProperties.add(nodeKey(property));
+            add(property, 'possible_textual_match', { kind: 'local', definitionOrdinal: local.ordinal });
+        }
+    });
+    walk(root, (node) => {
+        if (node.type !== 'identifier')
+            return;
+        if (handledCallIdentifiers.has(nodeKey(node)) || handledProperties.has(nodeKey(node)))
+            return;
+        if (isProperty(node)) {
+            const local = localTargets.get(node.text);
+            if (local && local !== null)
+                add(node, 'possible_textual_match', { kind: 'local', definitionOrdinal: local.ordinal });
+            return;
+        }
+        if (isValueReference(node, language))
+            directUse(node, 'references');
+    });
+    return usages.sort((a, b) => a.span.start_line - b.span.start_line
+        || a.span.start_col - b.span.start_col
+        || a.kind.localeCompare(b.kind));
+}
+//# sourceMappingURL=usages.js.map