@crouton-kit/tsym 0.1.0

package/dist/index/classify.d.ts

@@ -0,0 +1,20 @@
+import type { Symbol as TsSymbol } from 'typescript/unstable/sync';
+import type { KeyedDeclaration } from './descriptor.js';
+import type { ExternalNode } from './graph.js';
+export type Target = {
+    key: string;
+    external: false;
+} | {
+    key: string;
+    external: true;
+    node: ExternalNode;
+} | null;
+export interface DeclarationLookup {
+    root: string;
+    indexedByStart: ReadonlyMap<string, ReadonlyMap<number, KeyedDeclaration>>;
+    modulesByFile: ReadonlyMap<string, string>;
+}
+export declare function declarationTarget(symbol: TsSymbol, lookup: DeclarationLookup, resolveAlias: (symbol: TsSymbol) => TsSymbol, externalIdentity?: string): Target;
+export declare function moduleTarget(symbol: TsSymbol | undefined, lookup: DeclarationLookup, resolveAlias: (symbol: TsSymbol) => TsSymbol, specifier: string): Target;
+export declare function relative(root: string, file: string): string;
+export declare function packageName(specifier: string): string;

package/dist/index/classify.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+export function declarationTarget(symbol, lookup, resolveAlias, externalIdentity) {
+    const resolved = resolveAlias(symbol);
+    const declarations = resolved.declarations;
+    for (const handle of declarations) {
+        const declaration = handle.resolve();
+        if (!declaration)
+            continue;
+        const file = relative(lookup.root, declaration.getSourceFile().fileName);
+        const descriptor = lookup.indexedByStart.get(file)?.get(declaration.getStart(declaration.getSourceFile()));
+        if (descriptor)
+            return { key: descriptor.key, external: false };
+    }
+    if (declarations.some((handle) => {
+        const declaration = handle.resolve();
+        return declaration && lookup.modulesByFile.has(relative(lookup.root, declaration.getSourceFile().fileName));
+    }))
+        return null;
+    const declaration = declarations.map((handle) => handle.resolve()).find((node) => !!node);
+    const module = externalModule(declaration?.getSourceFile().fileName, externalIdentity ?? resolved.name);
+    const name = resolved.name;
+    const node = { key: `${module}#${name}`, module, name };
+    return { key: node.key, external: true, node };
+}
+export function moduleTarget(symbol, lookup, resolveAlias, specifier) {
+    if (symbol) {
+        const declarations = resolveAlias(symbol).declarations;
+        for (const handle of declarations) {
+            const declaration = handle.resolve();
+            if (!declaration)
+                continue;
+            const key = lookup.modulesByFile.get(relative(lookup.root, declaration.getSourceFile().fileName));
+            if (key)
+                return { key, external: false };
+        }
+    }
+    const module = packageName(specifier);
+    const node = { key: `${module}#<module>`, module, name: '<module>' };
+    return { key: node.key, external: true, node };
+}
+export function relative(root, file) {
+    return path.relative(root, file).split(path.sep).join('/');
+}
+export function packageName(specifier) {
+    const segments = specifier.split('/');
+    if (specifier.startsWith('@'))
+        return segments[1]?.endsWith('.js') ? segments[0] : segments.slice(0, 2).join('/');
+    return segments[0] || specifier;
+}
+function externalModule(file, fallback) {
+    if (!file)
+        return fallback;
+    const normalized = file.split(path.sep).join('/');
+    if (/\/lib\.[^.]+\.d\.ts$/.test(normalized))
+        return 'lib';
+    const nodeModules = normalized.lastIndexOf('/node_modules/');
+    if (nodeModules >= 0)
+        return packageName(normalized.slice(nodeModules + '/node_modules/'.length));
+    return fallback;
+}

package/dist/index/commits.d.ts

@@ -0,0 +1,15 @@
+import type { RelationshipRow } from '../store/load.js';
+import { Store } from '../store/store.js';
+export interface RenameCandidate {
+    from: string;
+    oldKey: string;
+    basis: 'text-identical' | 'container-renamed' | 'file-moved';
+    commit: string;
+}
+export interface CommitIngestion {
+    commits: readonly string[];
+    changed: readonly RelationshipRow[];
+    renamed: readonly RenameCandidate[];
+}
+/** Ingests missing commits against working-tree identities. Committed blobs are parsed only by the TS5 descriptor. */
+export declare function ingestCommits(root: string, store: Store, hashes: readonly string[]): CommitIngestion;

package/dist/index/commits.js

@@ -0,0 +1,201 @@
+import { execFileSync } from 'node:child_process';
+import { describeSourceFile, parseDescriptorSource } from './descriptor.js';
+/** Ingests missing commits against working-tree identities. Committed blobs are parsed only by the TS5 descriptor. */
+export function ingestCommits(root, store, hashes) {
+    const current = currentDeclarations(store);
+    const commits = [];
+    const changed = [];
+    const renamed = [];
+    for (const hash of hashes) {
+        if (commitExists(store, hash))
+            continue;
+        const ingestion = ingestCommit(root, hash, current);
+        store.transaction(() => {
+            store.execute('CREATE (:Commit {hash: $hash, ts: $ts, author: $author, subject: $subject})', commitDetails(root, hash));
+            for (const relationship of ingestion.changed) {
+                store.execute('MATCH (c:Commit), (d:Declaration) WHERE c.hash = $commit AND d.key = $key CREATE (c)-[:CHANGED {added: $added, removed: $removed}]->(d)', {
+                    commit: hash,
+                    key: relationship.to,
+                    added: relationship.added ?? 0,
+                    removed: relationship.removed ?? 0,
+                });
+            }
+            for (const candidate of ingestion.renamed) {
+                store.execute('MATCH (d:Declaration), (c:Commit) WHERE d.key = $from AND c.hash = $commit CREATE (d)-[:RENAMED_FROM {oldKey: $oldKey, basis: $basis}]->(c)', {
+                    from: candidate.from,
+                    commit: candidate.commit,
+                    oldKey: candidate.oldKey,
+                    basis: candidate.basis,
+                });
+            }
+        });
+        commits.push(hash);
+        changed.push(...ingestion.changed);
+        renamed.push(...ingestion.renamed);
+    }
+    return { commits, changed, renamed };
+}
+function ingestCommit(root, hash, current) {
+    const parent = parentOf(root, hash);
+    const changed = new Map();
+    const beforeForRename = [];
+    const afterForRename = [];
+    for (const file of touchedFiles(root, parent, hash)) {
+        if (!isSourceFile(file))
+            continue;
+        const committed = descriptorsAt(root, hash, file);
+        const after = cleanAtCommit(root, hash, file) ? currentSpans(current, file) : committed;
+        const before = parent === undefined ? [] : descriptorsAt(root, parent, file);
+        beforeForRename.push(...before);
+        afterForRename.push(...committed);
+        const afterIndexed = after.filter((declaration) => current.has(declaration.key));
+        const beforeByKey = new Map(before.map((declaration) => [declaration.key, declaration]));
+        for (const hunk of hunksFor(root, parent, hash, file)) {
+            if (hunk.newLines === 0) {
+                const target = deletionTarget(afterIndexed, hunk.newStart);
+                if (target)
+                    add(changed, target.key, 0, hunk.oldLines);
+                continue;
+            }
+            const affected = afterIndexed.filter((declaration) => declaration.name !== '<module>' && intersects(declaration.startLine, declaration.endLine, hunk.newStart, hunk.newStart + hunk.newLines - 1));
+            const targets = affected.length === 0 ? (moduleFor(afterIndexed) === undefined ? [] : [moduleFor(afterIndexed)]) : affected;
+            for (const target of targets) {
+                const previous = beforeByKey.get(target.key);
+                const removed = previous && hunk.oldLines > 0
+                    ? intersection(previous.startLine, previous.endLine, hunk.oldStart, hunk.oldStart + hunk.oldLines - 1)
+                    : 0;
+                add(changed, target.key, intersection(target.startLine, target.endLine, hunk.newStart, hunk.newStart + hunk.newLines - 1), removed);
+            }
+        }
+    }
+    return {
+        changed: [...changed].map(([to, counts]) => ({ type: 'CHANGED', from: hash, to, target: 'Declaration', ...counts })),
+        renamed: renameCandidates(hash, beforeForRename, afterForRename, current),
+    };
+}
+function currentDeclarations(store) {
+    const rows = store.execute('MATCH (d:Declaration) RETURN d.key AS key, d.file AS file, d.endLine AS endLine, d.lines AS lines');
+    return new Map(rows.map((row) => [String(row.key), { key: String(row.key), file: String(row.file), endLine: Number(row.endLine), lines: Number(row.lines) }]));
+}
+function commitExists(store, hash) {
+    return store.execute('MATCH (c:Commit) WHERE c.hash = $hash RETURN c.hash', { hash }).length > 0;
+}
+function commitDetails(root, hash) {
+    const values = git(root, ['show', '-s', '--format=%aI%x00%an%x00%s', hash]).split('\0');
+    if (values.length !== 3)
+        throw new Error(`Git did not return commit metadata for ${hash}.`);
+    return { hash, ts: values[0], author: values[1], subject: values[2].trimEnd() };
+}
+function parentOf(root, hash) {
+    return git(root, ['rev-list', '--parents', '-n', '1', hash]).trim().split(/\s+/)[1];
+}
+function touchedFiles(root, parent, hash) {
+    const args = parent === undefined
+        ? ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', hash]
+        : ['diff', '--no-renames', '--name-only', parent, hash];
+    return git(root, args).split('\n').filter(Boolean);
+}
+function hunksFor(root, parent, hash, file) {
+    const args = parent === undefined
+        ? ['diff-tree', '--root', '--no-commit-id', '--unified=0', '-r', hash, '--', file]
+        : ['diff', '--unified=0', parent, hash, '--', file];
+    return git(root, args).split('\n').flatMap((line) => {
+        const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+        return match ? [{ oldStart: Number(match[1]), oldLines: Number(match[2] ?? 1), newStart: Number(match[3]), newLines: Number(match[4] ?? 1) }] : [];
+    });
+}
+function descriptorsAt(root, commit, file) {
+    let text;
+    try {
+        text = git(root, ['show', `${commit}:${file}`]);
+    }
+    catch (error) {
+        if (/does not exist in|exists on disk, but not in/.test(String(error)))
+            return [];
+        throw error;
+    }
+    const source = parseDescriptorSource(file, text);
+    return describeSourceFile(source, file).map((declaration) => ({
+        ...declaration,
+        startLine: source.getLineAndCharacterOfPosition(declaration.start).line + 1,
+        endLine: source.getLineAndCharacterOfPosition(Math.max(declaration.start, declaration.end - 1)).line + 1,
+        text: text.slice(declaration.start, declaration.end).replace(/\s+/g, ' ').trim(),
+    }));
+}
+function currentSpans(current, file) {
+    return [...current.values()].filter((declaration) => declaration.file === file).map((declaration) => ({
+        key: declaration.key,
+        name: declaration.key.endsWith('#<module>') ? '<module>' : declaration.key.slice(declaration.key.lastIndexOf('.') + 1),
+        startLine: declaration.endLine - declaration.lines + 1,
+        endLine: declaration.endLine,
+    }));
+}
+function cleanAtCommit(root, hash, file) {
+    try {
+        execFileSync('git', ['diff', '--quiet', hash, '--', file], { cwd: root });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function deletionTarget(declarations, line) {
+    const nonModules = declarations.filter((declaration) => declaration.name !== '<module>');
+    const preceding = nonModules.filter((declaration) => declaration.endLine === line - 1);
+    if (preceding.length > 0)
+        return innermost(preceding);
+    const containing = nonModules.filter((declaration) => declaration.startLine <= line && line <= declaration.endLine);
+    return containing.length > 0 ? innermost(containing) : moduleFor(declarations);
+}
+function moduleFor(declarations) {
+    return declarations.find((declaration) => declaration.name === '<module>');
+}
+function innermost(declarations) {
+    return [...declarations].sort((left, right) => (left.endLine - left.startLine) - (right.endLine - right.startLine) || left.key.localeCompare(right.key))[0];
+}
+function renameCandidates(commit, before, after, current) {
+    const oldByText = new Map();
+    for (const declaration of before) {
+        if (declaration.name === '<module>' || current.has(declaration.key))
+            continue;
+        const candidates = oldByText.get(declaration.text) ?? [];
+        candidates.push(declaration);
+        oldByText.set(declaration.text, candidates);
+    }
+    const candidates = [];
+    for (const declaration of after) {
+        if (declaration.name === '<module>' || !current.has(declaration.key))
+            continue;
+        const matches = oldByText.get(declaration.text) ?? [];
+        if (matches.length !== 1)
+            continue;
+        const old = matches[0];
+        if (old.key === declaration.key)
+            continue;
+        candidates.push({
+            from: declaration.key,
+            oldKey: old.key,
+            basis: old.file !== declaration.file ? 'file-moved' : old.containerPath !== declaration.containerPath ? 'container-renamed' : 'text-identical',
+            commit,
+        });
+    }
+    return candidates;
+}
+function add(target, key, added, removed) {
+    const previous = target.get(key) ?? { added: 0, removed: 0 };
+    previous.added += added;
+    previous.removed += removed;
+    target.set(key, previous);
+}
+function intersects(start, end, otherStart, otherEnd) {
+    return start <= otherEnd && otherStart <= end;
+}
+function intersection(start, end, otherStart, otherEnd) {
+    return Math.max(0, Math.min(end, otherEnd) - Math.max(start, otherStart) + 1);
+}
+function isSourceFile(file) {
+    return /\.[cm]?[jt]sx?$/.test(file);
+}
+function git(root, args) {
+    return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}

package/dist/index/descriptor.d.ts

@@ -0,0 +1,19 @@
+import * as ts from 'ts5';
+export type DescriptorScope = 'module' | 'top-level' | 'named-member' | 'function-local' | 'anonymous-expression' | 'excluded' | 'other';
+export interface KeyedDeclaration {
+    key: string;
+    file: string;
+    name: string;
+    path: string;
+    containerPath: string;
+    kind: string;
+    start: number;
+    end: number;
+    nameStart: number;
+    nameEnd: number;
+    scope: DescriptorScope;
+    ownsCallSite: boolean;
+}
+export declare function parseDescriptorSource(file: string, text: string): ts.SourceFile;
+export declare function describeFile(file: string, text: string): KeyedDeclaration[];
+export declare function describeSourceFile(source: ts.SourceFile, file?: string): KeyedDeclaration[];

package/dist/index/descriptor.js

@@ -0,0 +1,295 @@
+import * as ts from 'ts5';
+const ANON = '<anon:';
+const COMPUTED = '<computed>';
+export function parseDescriptorSource(file, text) {
+    return ts.createSourceFile(file, text, ts.ScriptTarget.ES2022, true, scriptKind(file));
+}
+export function describeFile(file, text) {
+    return describeSourceFile(parseDescriptorSource(file, text), file);
+}
+export function describeSourceFile(source, file = source.fileName) {
+    const descriptors = [{
+            key: `${file}#<module>`,
+            file,
+            name: '<module>',
+            path: '<module>',
+            containerPath: '',
+            kind: 'module',
+            start: 0,
+            end: source.end,
+            nameStart: 0,
+            nameEnd: 0,
+            scope: 'module',
+            ownsCallSite: false,
+        }];
+    const anonymousCounts = new Map();
+    const roleCounts = new Map();
+    const anchorCounts = new Map();
+    const literalRoleCounts = new Map();
+    const nextRole = (container, role) => {
+        const key = `${container.join('.')}|${role}`;
+        const count = (roleCounts.get(key) ?? 0) + 1;
+        roleCounts.set(key, count);
+        return count;
+    };
+    const anchorFor = (node, container) => {
+        const parent = node.parent;
+        if (!parent || !ts.isCallExpression(parent))
+            return undefined;
+        const argument = parent.arguments.indexOf(node);
+        const callee = callName(parent.expression);
+        if (argument < 0 || !callee)
+            return undefined;
+        const first = parent.arguments[0];
+        const base = first && first !== node && ts.isStringLiteralLike(first)
+            ? `<${callee}(${JSON.stringify(first.text)})>`
+            : `<${callee}#arg${argument + 1}:${nextRole(container, `${callee}${argument}`)}>`;
+        const key = `${container.join('.')}|${base}`;
+        const count = (anchorCounts.get(key) ?? 0) + 1;
+        anchorCounts.set(key, count);
+        return count === 1 ? base : `${base.slice(0, -1)}#${count}>`;
+    };
+    const anonymousName = (node, container) => {
+        const anchor = anchorFor(node, container);
+        if (anchor)
+            return anchor;
+        const key = container.join('.');
+        const count = (anonymousCounts.get(key) ?? 0) + 1;
+        anonymousCounts.set(key, count);
+        return `${ANON}${count}>`;
+    };
+    const nextLiteralRole = (path, label, role) => {
+        const key = `${path.join('.')}|${label}|${role}`;
+        const count = (literalRoleCounts.get(key) ?? 0) + 1;
+        literalRoleCounts.set(key, count);
+        return count;
+    };
+    const literalRole = (node, path) => {
+        const parent = node.parent;
+        const label = ts.isArrayLiteralExpression(node) ? 'arr' : ts.isObjectLiteralExpression(node) ? 'obj' : 'type';
+        if (parent && ts.isReturnStatement(parent))
+            return `<${label}:return:${nextLiteralRole(path, label, 'return')}>`;
+        if (parent && ts.isArrayLiteralExpression(parent))
+            return `<${label}:elem${parent.elements.indexOf(node)}>`;
+        return `<${label}:${nextLiteralRole(path, label, 'literal')}>`;
+    };
+    const blockSegment = (node, path) => {
+        const parent = node.parent;
+        if (ts.isBlock(node)) {
+            if (parent && ts.isIfStatement(parent))
+                return parent.thenStatement === node ? `<then:${nextRole(path, 'then')}>` : `<else:${nextRole(path, 'else')}>`;
+            if (parent && ts.isTryStatement(parent) && parent.tryBlock === node)
+                return `<try:${nextRole(path, 'try')}>`;
+            if (parent && ts.isTryStatement(parent) && parent.finallyBlock === node)
+                return `<finally:${nextRole(path, 'finally')}>`;
+            if (parent && (ts.isFunctionLike(parent) || ts.isModuleDeclaration(parent) || ts.isCatchClause(parent) || ts.isIterationStatement(parent, false) || ts.isLabeledStatement(parent)))
+                return undefined;
+            return `<block:${nextRole(path, 'block')}>`;
+        }
+        if (ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node))
+            return `<loop:${nextRole(path, 'loop')}>`;
+        if (ts.isCatchClause(node))
+            return `<catch:${nextRole(path, 'catch')}>`;
+        if (ts.isCaseClause(node) || ts.isDefaultClause(node))
+            return `<case:${nextRole(path, 'case')}>`;
+        return undefined;
+    };
+    const record = (node, segment, path, scope) => {
+        const declarationPath = [...path, segment];
+        const name = declarationNameNode(node) ?? node;
+        descriptors.push({
+            key: `${file}#${declarationPath.join('.')}`,
+            file,
+            name: segment,
+            path: declarationPath.join('.'),
+            containerPath: path.join('.'),
+            kind: ts.SyntaxKind[node.kind],
+            start: node.getStart(source),
+            end: node.getEnd(),
+            nameStart: name.getStart(source),
+            nameEnd: name.getEnd(),
+            scope,
+            ownsCallSite: ownsCallSite(node),
+        });
+        return declarationPath;
+    };
+    const visit = (node, path, parentNamed, nameless) => {
+        let childPath = path;
+        let pushed = false;
+        let scope = 'other';
+        const push = (segment, nextScope, containerPath = path) => {
+            childPath = record(node, segment, containerPath, nextScope);
+            scope = nextScope;
+            pushed = true;
+        };
+        if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) {
+            push(node.name?.text ?? (isDefaultExport(node) ? 'default' : anonymousName(node, path)), topOrFunctionLocal(node));
+        }
+        else if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
+            push(node.name.getText(source), topOrNamedMember(node));
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            push(node.name.text, ts.isCatchClause(node.parent) ? 'excluded' : topOrFunctionLocal(node));
+        }
+        else if (ts.isBindingElement(node) && ts.isIdentifier(node.name)) {
+            push(node.name.text, bindingElementScope(node));
+        }
+        else if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+            if (ts.isParameterPropertyDeclaration(node, node.parent))
+                push(node.name.text, 'named-member', path.slice(0, -1));
+            else
+                push(node.name.text, 'excluded');
+        }
+        else if (ts.isTypeParameterDeclaration(node)) {
+            push(node.name.text, 'excluded');
+        }
+        else if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isEnumMember(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) {
+            const name = propertyName(node.name, source) ?? anonymousName(node, path);
+            const isExcluded = ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || (ts.isPropertySignature(node) && inlineTypeLiteralMember(node));
+            push(name, isExcluded ? 'excluded' : topOrNamedMember(node));
+        }
+        else if (ts.isConstructorDeclaration(node)) {
+            push('constructor', topOrNamedMember(node));
+        }
+        else if (ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isClassExpression(node)) {
+            if (!borrowsParentName(node))
+                push(anonymousName(node, path), 'anonymous-expression');
+        }
+        else if (ts.isExportAssignment(node) && isAnonymousExport(node.expression)) {
+            push('default', 'top-level');
+        }
+        if (!pushed && isNamelessLiteral(node, parentNamed, nameless)) {
+            const parent = node.parent;
+            const arm = parent && (ts.isUnionTypeNode(parent) || ts.isIntersectionTypeNode(parent)) ? `<arm:${parent.types.indexOf(node) + 1}>` : undefined;
+            childPath = [...path, arm ?? anchorFor(node, path) ?? literalRole(node, path)];
+        }
+        if (parentNamed && node.parent && isTypeAnnotation(node.parent, node))
+            childPath = [...childPath, '<type>'];
+        const block = blockSegment(node, childPath);
+        if (block)
+            childPath = [...childPath, block];
+        ts.forEachChild(node, (child) => visit(child, childPath, pushed, nameless || (!parentNamed && (ts.isObjectLiteralExpression(node) || ts.isTypeLiteralNode(node) || ts.isMappedTypeNode(node)))));
+    };
+    ts.forEachChild(source, (node) => visit(node, [], false, false));
+    return descriptors;
+}
+function scriptKind(file) {
+    if (file.endsWith('.tsx'))
+        return ts.ScriptKind.TSX;
+    if (file.endsWith('.jsx'))
+        return ts.ScriptKind.JSX;
+    if (file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.cjs'))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function declarationNameNode(node) {
+    const name = node.name;
+    return name && typeof name !== 'string' ? name : undefined;
+}
+function propertyName(name, source) {
+    if (!name)
+        return undefined;
+    if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    if (ts.isComputedPropertyName(name))
+        return `[computed:${name.expression.getText(source).replace(/\s+/g, ' ').trim()}]`;
+    return undefined;
+}
+function isDefaultExport(node) {
+    const modifiers = ts.getModifiers(node);
+    return !!modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) && !!modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+function callName(expression) {
+    const text = expression.getText().replace(/\s+/g, ' ').trim();
+    return text || undefined;
+}
+function borrowsParentName(node) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node && ts.isIdentifier(parent.name))
+        return true;
+    if (ts.isPropertyAssignment(parent) && parent.initializer === node)
+        return true;
+    if (ts.isPropertyDeclaration(parent) && parent.initializer === node)
+        return true;
+    if (ts.isBindingElement(parent) && parent.initializer === node)
+        return true;
+    if (ts.isParameter(parent) && parent.initializer === node)
+        return true;
+    if (ts.isEnumMember(parent) && parent.initializer === node)
+        return true;
+    if (ts.isExportAssignment(parent))
+        return true;
+    if (ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent) || ts.isSatisfiesExpression(parent) || ts.isTypeAssertionExpression(parent))
+        return borrowsParentName(parent);
+    return false;
+}
+function isAnonymousExport(node) {
+    return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isClassExpression(node) || ts.isObjectLiteralExpression(node);
+}
+function isNamelessLiteral(node, parentNamed, alreadyNameless) {
+    if (parentNamed || alreadyNameless)
+        return false;
+    return ts.isObjectLiteralExpression(node) || ts.isTypeLiteralNode(node) || ts.isMappedTypeNode(node) || ts.isArrayLiteralExpression(node);
+}
+function isTypeAnnotation(parent, node) {
+    return 'type' in parent && parent.type === node && !ts.isTypeAliasDeclaration(parent) && ts.isTypeNode(node);
+}
+function bindingElementScope(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (ts.isVariableDeclaration(current))
+            return ts.isCatchClause(current.parent) ? 'excluded' : topOrFunctionLocal(current);
+        if (ts.isParameter(current) || ts.isCatchClause(current))
+            return 'excluded';
+    }
+    return 'excluded';
+}
+function topOrFunctionLocal(node) {
+    if (isTopLevel(node))
+        return 'top-level';
+    if (namedMemberContainer(node))
+        return 'named-member';
+    return hasFunctionAncestor(node) ? 'function-local' : 'other';
+}
+function topOrNamedMember(node) {
+    if (isTopLevel(node))
+        return 'top-level';
+    return namedMemberContainer(node) ? 'named-member' : 'other';
+}
+function isTopLevel(node) {
+    let current = node.parent;
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isFunctionLike(current) || ts.isClassLike(current) || ts.isInterfaceDeclaration(current) || ts.isEnumDeclaration(current) || ts.isModuleDeclaration(current) || ts.isTypeAliasDeclaration(current) || ts.isModuleBlock(current) || ts.isTypeLiteralNode(current) || ts.isObjectLiteralExpression(current) || ts.isBlock(current))
+            return false;
+        current = current.parent;
+    }
+    return !!current;
+}
+function hasFunctionAncestor(node) {
+    for (let current = node.parent; current && !ts.isSourceFile(current); current = current.parent)
+        if (ts.isFunctionLike(current))
+            return true;
+    return false;
+}
+function namedMemberContainer(node) {
+    for (let current = node.parent; current && !ts.isSourceFile(current); current = current.parent) {
+        if (ts.isClassDeclaration(current) || ts.isInterfaceDeclaration(current) || ts.isEnumDeclaration(current) || ts.isModuleDeclaration(current) || ts.isTypeAliasDeclaration(current))
+            return true;
+        if (ts.isFunctionLike(current) || ts.isObjectLiteralExpression(current) || ts.isClassStaticBlockDeclaration(current) || ts.isBlock(current) || ts.isCaseBlock(current) || ts.isCaseClause(current) || ts.isDefaultClause(current) || ts.isCatchClause(current) || ts.isIterationStatement(current, false))
+            return false;
+    }
+    return false;
+}
+function inlineTypeLiteralMember(node) {
+    return ts.isTypeLiteralNode(node.parent) && !ts.isTypeAliasDeclaration(node.parent.parent);
+}
+function ownsCallSite(node) {
+    let found = false;
+    const visit = (child) => {
+        if (ts.isCallExpression(child))
+            found = true;
+        else
+            ts.forEachChild(child, visit);
+    };
+    ts.forEachChild(node, visit);
+    return found;
+}