vibecodedshit 0.0.0-stage → 0.3.0

package/dist/measure/registry.js

@@ -0,0 +1,31 @@
+import { p11 } from './p1-1.js';
+import { p12 } from './p1-2.js';
+import { p13 } from './p1-3.js';
+import { p14 } from './p1-4.js';
+import { p15 } from './p1-5.js';
+import { p21 } from './p2-1.js';
+import { p22 } from './p2-2.js';
+import { p23 } from './p2-3.js';
+import { p24 } from './p2-4.js';
+import { p25 } from './p2-5.js';
+import { p31 } from './p3-1.js';
+import { p32 } from './p3-2.js';
+import { p33 } from './p3-3.js';
+import { p34 } from './p3-4.js';
+import { p35 } from './p3-5.js';
+import { p41 } from './p4-1.js';
+import { p42 } from './p4-2.js';
+import { p43 } from './p4-3.js';
+import { p44 } from './p4-4.js';
+import { p51 } from './p5-1.js';
+import { p52 } from './p5-2.js';
+import { p53 } from './p5-3.js';
+import { p54 } from './p5-4.js';
+import { p55 } from './p5-5.js';
+import { p61 } from './p6-1.js';
+import { p62 } from './p6-2.js';
+import { p63 } from './p6-3.js';
+import { p64 } from './p6-4.js';
+import { p65 } from './p6-5.js';
+import { p66 } from './p6-6.js';
+export const measurers = [p11, p12, p13, p14, p15, p21, p22, p23, p24, p25, p31, p32, p33, p34, p35, p41, p42, p43, p44, p51, p52, p53, p54, p55, p61, p62, p63, p64, p65, p66];

package/dist/measure/safety/py-tests.js

@@ -0,0 +1,124 @@
+import path from 'node:path';
+import { pythonTestFacts } from '../../python/tests.js';
+import { trackedPaths } from '../../scope/tracked.js';
+/** Resolution of Python imports to tracked files, for 1.4. Third-party and stdlib imports resolve to nothing. */
+export class PyImportGraph {
+    tracked;
+    facts;
+    packageOf = new Map();
+    constructor(repoPath, files) {
+        this.tracked = new Set(trackedPaths(repoPath));
+        this.facts = pythonTestFacts(repoPath);
+        for (const file of files)
+            this.packageOf.set(file.path, file.package);
+    }
+    factsOf(file) {
+        return this.facts[file];
+    }
+    /** The directories an absolute import is tried from, in order: the importer's own directory, `<P>/src`, `<P>`, `src`, `.`. */
+    roots(from) {
+        const pkg = this.packageOf.get(from) ?? '.';
+        const candidates = [path.posix.dirname(from), pkg === '.' ? 'src' : `${pkg}/src`, pkg, 'src', '.'];
+        return [...new Set(candidates)];
+    }
+    moduleIn(dir, parts) {
+        const base = parts.length === 0 ? dir : path.posix.join(dir, ...parts);
+        for (const candidate of parts.length === 0 ? [path.posix.join(base, '__init__.py')] : [`${base}.py`, path.posix.join(base, '__init__.py')]) {
+            if (this.tracked.has(path.posix.normalize(candidate)))
+                return path.posix.normalize(candidate);
+        }
+        return undefined;
+    }
+    /** The file of `module` as imported from `from` (a relative import uses its `level`; an absolute one tries each root, first hit wins). */
+    moduleFile(from, level, module) {
+        const parts = module === null ? [] : module.split('.');
+        if (level > 0) {
+            let dir = path.posix.dirname(from);
+            for (let i = 1; i < level; i += 1)
+                dir = path.posix.dirname(dir);
+            return this.moduleIn(dir, parts);
+        }
+        if (parts.length === 0)
+            return undefined;
+        for (const root of this.roots(from)) {
+            const found = this.moduleIn(root, parts);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    lookupIn(file, name, seen) {
+        const key = `${file}\0${name}`;
+        if (seen.has(key))
+            return undefined;
+        seen.add(key);
+        const facts = this.facts[file];
+        if (!facts?.ok)
+            return undefined;
+        if (facts.defined.includes(name))
+            return file;
+        const binding = facts.reexports.find((r) => r.name === name);
+        return binding ? this.fromImport(file, binding.level, binding.module, binding.orig, seen) : undefined;
+    }
+    /** The file that defines `name` imported by `from <module> import name` in `from`, following `__init__.py` re-exports; a submodule is credited itself. */
+    fromImport(from, level, module, name, seen = new Set()) {
+        const target = this.moduleFile(from, level, module);
+        if (target) {
+            const found = this.lookupIn(target, name, seen);
+            if (found)
+                return found;
+        }
+        const dir = target === undefined ? (module === null && level > 0 ? this.levelDir(from, level) : undefined) : target.endsWith('/__init__.py') || target === '__init__.py' ? path.posix.dirname(target) : undefined;
+        if (dir !== undefined) {
+            const sub = this.moduleIn(dir, [name]);
+            if (sub)
+                return sub;
+        }
+        return target;
+    }
+    levelDir(from, level) {
+        let dir = path.posix.dirname(from);
+        for (let i = 1; i < level; i += 1)
+            dir = path.posix.dirname(dir);
+        return dir;
+    }
+    /** Every file a star import of `file` reaches: the module itself and the targets of all its re-export bindings. */
+    starTargets(file) {
+        const facts = this.facts[file];
+        const out = [file];
+        if (facts?.ok) {
+            for (const binding of facts.reexports) {
+                const found = this.fromImport(file, binding.level, binding.module, binding.orig);
+                if (found !== undefined)
+                    out.push(found);
+            }
+        }
+        return out;
+    }
+    /** The files a test file credits through its imports. */
+    credits(test) {
+        const facts = this.facts[test];
+        if (!facts?.ok)
+            return [];
+        const out = [];
+        for (const imp of facts.imports) {
+            if (imp.names.length === 0 && !imp.star) {
+                const file = this.moduleFile(test, imp.level, imp.module);
+                if (file !== undefined)
+                    out.push(file);
+                continue;
+            }
+            for (const { name } of imp.names) {
+                const found = this.fromImport(test, imp.level, imp.module, name);
+                if (found !== undefined)
+                    out.push(found);
+            }
+            if (imp.star) {
+                const file = this.moduleFile(test, imp.level, imp.module);
+                if (file !== undefined)
+                    out.push(...this.starTargets(file));
+            }
+        }
+        return out;
+    }
+}

package/dist/measure/safety/ts-barrels.js

@@ -0,0 +1,68 @@
+import ts from 'typescript';
+const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
+function bindingNames(name, out) {
+    if (ts.isIdentifier(name))
+        out.push(name.text);
+    else
+        for (const el of name.elements)
+            if (ts.isBindingElement(el))
+                bindingNames(el.name, out);
+}
+export function summarize(sf) {
+    const summary = { defined: new Set(), named: new Map(), stars: [], namespaces: new Map() };
+    const imports = new Map();
+    for (const stmt of sf.statements) {
+        if (ts.isImportDeclaration(stmt) && ts.isStringLiteralLike(stmt.moduleSpecifier) && stmt.importClause) {
+            const specifier = stmt.moduleSpecifier.text;
+            const clause = stmt.importClause;
+            if (clause.name)
+                imports.set(clause.name.text, { specifier, orig: 'default' });
+            if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (const el of clause.namedBindings.elements)
+                    imports.set(el.name.text, { specifier, orig: (el.propertyName ?? el.name).text });
+            }
+        }
+    }
+    for (const stmt of sf.statements) {
+        if (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isEnumDeclaration(stmt) || ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) {
+            if (stmt.name)
+                summary.defined.add(stmt.name.text);
+            if (hasModifier(stmt, ts.SyntaxKind.DefaultKeyword))
+                summary.defined.add('default');
+        }
+        else if (ts.isVariableStatement(stmt)) {
+            const names = [];
+            for (const decl of stmt.declarationList.declarations)
+                bindingNames(decl.name, names);
+            for (const name of names)
+                summary.defined.add(name);
+        }
+        else if (ts.isExportAssignment(stmt)) {
+            summary.defined.add('default');
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            const from = stmt.moduleSpecifier && ts.isStringLiteralLike(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : undefined;
+            const clause = stmt.exportClause;
+            if (from !== undefined) {
+                if (!clause)
+                    summary.stars.push(from);
+                else if (ts.isNamespaceExport(clause))
+                    summary.namespaces.set(clause.name.text, from);
+                else
+                    for (const el of clause.elements)
+                        summary.named.set(el.name.text, { specifier: from, orig: (el.propertyName ?? el.name).text });
+            }
+            else if (clause && ts.isNamedExports(clause)) {
+                for (const el of clause.elements) {
+                    const local = (el.propertyName ?? el.name).text;
+                    const imported = imports.get(local);
+                    if (imported)
+                        summary.named.set(el.name.text, imported);
+                    else
+                        summary.defined.add(el.name.text);
+                }
+            }
+        }
+    }
+    return summary;
+}

package/dist/measure/safety/ts-cases.js

@@ -0,0 +1,111 @@
+import ts from 'typescript';
+const CASE_ROOTS = new Set(['it', 'test']);
+const CASE_MODIFIERS = new Set(['only', 'concurrent']);
+const EACH_MODIFIERS = new Set(['only', 'concurrent', 'each']);
+/** `it`, `test` or `it.only.each` as a root identifier and the property names after it, or undefined for anything else. */
+function chainOf(expr) {
+    const mods = [];
+    let current = expr;
+    while (ts.isPropertyAccessExpression(current)) {
+        mods.unshift(current.name.text);
+        current = current.expression;
+    }
+    return ts.isIdentifier(current) ? { root: current.text, mods } : undefined;
+}
+/**
+ * A test case is a call to `it` or `test`, or to `it`/`test` followed by a chain of `.only` and `.concurrent`, or `.each(...)` (call or
+ * tagged template) and then the call itself. `.skip`, `.todo`, `.fails`, `.skipIf` and `.runIf` are not counted; `describe` is not a case.
+ */
+function isCaseCall(call) {
+    const callee = call.expression;
+    const direct = chainOf(callee);
+    if (direct)
+        return CASE_ROOTS.has(direct.root) && direct.mods.every((m) => CASE_MODIFIERS.has(m));
+    const each = ts.isCallExpression(callee) ? callee.expression : ts.isTaggedTemplateExpression(callee) ? callee.tag : undefined;
+    const chain = each ? chainOf(each) : undefined;
+    return chain !== undefined && CASE_ROOTS.has(chain.root) && chain.mods.at(-1) === 'each' && chain.mods.every((m) => EACH_MODIFIERS.has(m));
+}
+const isFunctionLike = (node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+function isAssertionCall(call, testParam) {
+    const callee = call.expression;
+    if (ts.isIdentifier(callee))
+        return ['expect', 'assert', 'expectTypeOf'].includes(callee.text);
+    if (!ts.isPropertyAccessExpression(callee))
+        return false;
+    const props = [];
+    let root = callee;
+    while (ts.isPropertyAccessExpression(root)) {
+        props.unshift(root.name.text);
+        root = root.expression;
+    }
+    if (!ts.isIdentifier(root))
+        return false;
+    if (root.text === 'expect')
+        return props.length === 1 && (props[0] === 'soft' || props[0] === 'poll');
+    if (root.text === 'assert')
+        return true;
+    if (testParam !== undefined && root.text === testParam) {
+        const [first] = props;
+        return first !== undefined && (first.startsWith('assert') || (props.length === 1 && (first === 'is' || first === 'deepEqual')));
+    }
+    return false;
+}
+function containsAssertion(node, testParam, calls) {
+    let found = false;
+    const visit = (child) => {
+        if (found && calls === undefined)
+            return;
+        if (ts.isCallExpression(child)) {
+            if (isAssertionCall(child, testParam))
+                found = true;
+            calls?.push(child);
+        }
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}
+/** Functions declared in the file by name: function declarations and `const x = <arrow or function expression>`. */
+function helpersOf(sf) {
+    const helpers = new Map();
+    const visit = (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name && node.body)
+            helpers.set(node.name.text, node.body);
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isFunctionLike(node.initializer))
+            helpers.set(node.name.text, node.initializer.body);
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return helpers;
+}
+/**
+ * The test cases of a file. Assertions: `expect(...)`, `expect.soft`, `expect.poll`, `assert(...)`, `assert.*`, `expectTypeOf(...)` and
+ * `t.assert*`, `t.is`, `t.deepEqual` where `t` is the callback's first parameter, searched in the whole body. A call to a helper declared in
+ * the same file counts when the helper's body directly contains an assertion (one level). A case with no function argument has no assertion.
+ */
+export function testCases(sf) {
+    const helpers = helpersOf(sf);
+    const cases = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && isCaseCall(node)) {
+            const callback = [...node.arguments].reverse().find(isFunctionLike);
+            let asserts = false;
+            if (callback) {
+                const first = callback.parameters[0];
+                const testParam = first && ts.isIdentifier(first.name) ? first.name.text : undefined;
+                const calls = [];
+                asserts = containsAssertion(callback.body, testParam, calls);
+                if (!asserts) {
+                    asserts = calls.some((call) => {
+                        const helper = ts.isIdentifier(call.expression) ? helpers.get(call.expression.text) : undefined;
+                        return helper !== undefined && containsAssertion(helper, undefined);
+                    });
+                }
+            }
+            cases.push({ line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1, asserts });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return cases;
+}

package/dist/measure/safety/ts-credits.js

@@ -0,0 +1,101 @@
+import { readTracked } from '../../scope/tracked.js';
+import { parseTsFile } from '../../scope/ts-lines.js';
+import { summarize } from './ts-barrels.js';
+import { importFacts, namespaceAccesses } from './ts-imports.js';
+/** Logic files of the TS/JS group credited by the imports of one test file, with barrels followed to the defining file. */
+export class TsCredits {
+    repoPath;
+    scope;
+    resolver;
+    summaries = new Map();
+    parsed = new Map();
+    constructor(repoPath, scope, resolver) {
+        this.repoPath = repoPath;
+        this.scope = scope;
+        this.resolver = resolver;
+    }
+    /** A scoped file from the scope's cache; a barrel or other out-of-scope tracked file is parsed from its text. */
+    source(file) {
+        const cached = this.parsed.get(file);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        let sf = null;
+        try {
+            sf = this.scope.getTsSourceFile(file);
+        }
+        catch {
+            const text = readTracked(this.repoPath, file);
+            sf = text === null ? null : parseTsFile(file, text);
+        }
+        this.parsed.set(file, sf);
+        return sf ?? undefined;
+    }
+    summary(file) {
+        const cached = this.summaries.get(file);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        const sf = this.source(file);
+        const summary = sf ? summarize(sf) : null;
+        this.summaries.set(file, summary);
+        return summary ?? undefined;
+    }
+    /** The file defining `name` as exported by `start`: breadth first through `export *` sources, first definition wins. */
+    define(start, name, seen) {
+        const queue = [start];
+        while (queue.length > 0) {
+            const file = queue.shift();
+            const key = `${file}\0${name}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const summary = this.summary(file);
+            if (!summary)
+                continue;
+            if (summary.defined.has(name))
+                return file;
+            const named = summary.named.get(name);
+            if (named) {
+                const target = this.resolver.resolve(named.specifier, file);
+                if (target !== undefined)
+                    return this.define(target, named.orig, seen) ?? target;
+            }
+            const namespace = summary.namespaces.get(name);
+            if (namespace !== undefined) {
+                const target = this.resolver.resolve(namespace, file);
+                if (target !== undefined)
+                    return target;
+            }
+            for (const star of summary.stars) {
+                const target = this.resolver.resolve(star, file);
+                if (target !== undefined)
+                    queue.push(target);
+            }
+        }
+        return undefined;
+    }
+    /** Every file the test file credits (callers keep only logic-role files). */
+    credits(test) {
+        const out = new Set();
+        const sf = this.source(test);
+        if (!sf)
+            return out;
+        const facts = importFacts(sf);
+        const namespaces = namespaceAccesses(sf, new Set(facts.flatMap((f) => (f.local === undefined ? [] : [f.local]))));
+        for (const fact of facts) {
+            const target = this.resolver.resolve(fact.specifier, test);
+            if (target === undefined)
+                continue;
+            if (fact.name === undefined || fact.name === '*') {
+                out.add(target);
+                for (const name of fact.local === undefined ? [] : [...(namespaces.get(fact.local) ?? [])]) {
+                    const defining = this.define(target, name, new Set());
+                    if (defining !== undefined)
+                        out.add(defining);
+                }
+            }
+            else
+                out.add(this.define(target, fact.name, new Set()) ?? target);
+        }
+        return out;
+    }
+}

package/dist/measure/safety/ts-imports.js

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+const isStringLiteral = (node) => node !== undefined && ts.isStringLiteralLike(node);
+/**
+ * What a test file imports: static `import` declarations of every form (`import type` and `import { type X }` included), `export ... from`,
+ * `require("<literal>")` and dynamic `import("<literal>")`. `vi.mock`, `jest.mock`, `require.resolve` and non-literal paths do not count.
+ */
+export function importFacts(sf) {
+    const facts = [];
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const clause = node.importClause;
+            if (!clause)
+                facts.push({ specifier });
+            else {
+                if (clause.name)
+                    facts.push({ specifier, name: 'default' });
+                const bindings = clause.namedBindings;
+                if (bindings && ts.isNamespaceImport(bindings))
+                    facts.push({ specifier, name: '*', local: bindings.name.text });
+                else if (bindings)
+                    for (const el of bindings.elements)
+                        facts.push({ specifier, name: (el.propertyName ?? el.name).text });
+                if (!clause.name && !bindings)
+                    facts.push({ specifier });
+            }
+        }
+        else if (ts.isExportDeclaration(node) && isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const clause = node.exportClause;
+            if (clause && ts.isNamedExports(clause))
+                for (const el of clause.elements)
+                    facts.push({ specifier, name: (el.propertyName ?? el.name).text });
+            else
+                facts.push({ specifier });
+        }
+        else if (ts.isCallExpression(node) && isStringLiteral(node.arguments[0])) {
+            const callee = node.expression;
+            if ((ts.isIdentifier(callee) && callee.text === 'require') || callee.kind === ts.SyntaxKind.ImportKeyword) {
+                facts.push({ specifier: node.arguments[0].text });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return facts;
+}
+/** Names accessed as `m.x` for each namespace-import binding `m` of a file. */
+export function namespaceAccesses(sf, locals) {
+    const out = new Map();
+    if (locals.size === 0)
+        return out;
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && locals.has(node.expression.text)) {
+            const set = out.get(node.expression.text) ?? new Set();
+            set.add(node.name.text);
+            out.set(node.expression.text, set);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return out;
+}

package/dist/measure/safety/ts-resolve.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { trackedPaths } from '../../scope/tracked.js';
+import { compilerOptionsFor } from '../ts/tsconfig.js';
+const posix = (p) => p.split(path.sep).join('/');
+/**
+ * `ts.resolveModuleName` with the options of the nearest tsconfig and a host backed by the tracked files, so `node_modules`
+ * is never read and a package import resolves to nothing. NodeNext `.js` specifiers that map to `.ts` files resolve through the compiler.
+ */
+export function createTsResolver(repoPath) {
+    const root = posix(path.resolve(repoPath));
+    const files = new Set(trackedPaths(repoPath));
+    const dirs = new Set(['']);
+    for (const file of files)
+        for (let d = path.posix.dirname(file); d !== '.' && !dirs.has(d); d = path.posix.dirname(d))
+            dirs.add(d);
+    const rel = (abs) => path.posix.relative(root, posix(abs));
+    const host = {
+        fileExists: (abs) => files.has(rel(abs)),
+        readFile: (abs) => (files.has(rel(abs)) ? ts.sys.readFile(abs) : undefined),
+        directoryExists: (abs) => dirs.has(rel(abs) === '.' ? '' : rel(abs)),
+        realpath: (abs) => abs,
+        getCurrentDirectory: () => root,
+        useCaseSensitiveFileNames: true,
+    };
+    const optionsByDir = new Map();
+    return {
+        resolve(specifier, fromFile) {
+            const dir = path.posix.dirname(fromFile);
+            let options = optionsByDir.get(dir);
+            if (!options) {
+                options = compilerOptionsFor(repoPath, dir);
+                optionsByDir.set(dir, options);
+            }
+            const containing = path.posix.join(root, fromFile);
+            const result = ts.resolveModuleName(specifier, containing, options, host).resolvedModule;
+            if (!result)
+                return undefined;
+            const found = rel(result.resolvedFileName);
+            return found.startsWith('..') || !files.has(found) ? undefined : found;
+        },
+    };
+}

package/dist/measure/ts/directives.js

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+/** True when the file's leading comments hold `@<name>` at the start of a comment (after `//`, `///` or `/*`). */
+export function hasLeadingDirective(sourceFile, name) {
+    const text = sourceFile.text;
+    const pattern = new RegExp(`^(?:\\/\\/\\/?|\\/\\*+)\\s*@${name}\\b`);
+    return (ts.getLeadingCommentRanges(text, 0) ?? []).some((range) => pattern.test(text.slice(range.pos, range.end)));
+}
+const LINE_DIRECTIVE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/;
+const BLOCK_DIRECTIVE = /^(?:\/|\*)*\s*@(?:ts-expect-error|ts-ignore)/;
+/** Number of `@ts-ignore` and `@ts-expect-error` comments, found through the AST so strings, templates, regexes and JSX text never count. */
+export function countSuppressionComments(sourceFile) {
+    const text = sourceFile.text;
+    const seen = new Set();
+    let count = 0;
+    const check = (ranges) => {
+        for (const range of ranges ?? []) {
+            if (seen.has(range.pos))
+                continue;
+            seen.add(range.pos);
+            const comment = text.slice(range.pos, range.end);
+            const matches = range.kind === ts.SyntaxKind.SingleLineCommentTrivia
+                ? LINE_DIRECTIVE.test(comment)
+                : BLOCK_DIRECTIVE.test(comment.slice(comment.lastIndexOf('\n') + 1));
+            if (matches)
+                count += 1;
+        }
+    };
+    const visit = (node) => {
+        if (node.kind !== ts.SyntaxKind.JsxText) {
+            check(ts.getLeadingCommentRanges(text, node.pos));
+            check(ts.getTrailingCommentRanges(text, node.end));
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return count;
+}

package/dist/measure/ts/exports.js

@@ -0,0 +1,60 @@
+import ts from 'typescript';
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+}
+function bindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.add(name.text);
+        return;
+    }
+    for (const element of name.elements) {
+        if (ts.isBindingElement(element))
+            bindingNames(element.name, out);
+    }
+}
+/**
+ * Exported symbols of one file, the denominator of 4.4:
+ * each exported declaration by name (overloads and merged declarations once, each binding of a
+ * destructured `const` once), each specifier of `export { a, b as c }` and `export { x } from`,
+ * `export default` once, `export =` once, `export * as ns from` once, `export * from` zero.
+ */
+export function countExportedSymbols(sourceFile) {
+    const names = new Set();
+    let extra = 0;
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportAssignment(statement)) {
+            extra += 1; // `export default expr` and `export = expr`
+            continue;
+        }
+        if (ts.isExportDeclaration(statement)) {
+            const clause = statement.exportClause;
+            if (!clause)
+                continue; // export * from '...'
+            if (ts.isNamespaceExport(clause))
+                extra += 1;
+            else
+                extra += clause.elements.length;
+            continue;
+        }
+        if (!hasModifier(statement, ts.SyntaxKind.ExportKeyword))
+            continue;
+        if (hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+            extra += 1;
+            continue;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations)
+                bindingNames(declaration.name, names);
+        }
+        else if (ts.isFunctionDeclaration(statement) ||
+            ts.isClassDeclaration(statement) ||
+            ts.isInterfaceDeclaration(statement) ||
+            ts.isTypeAliasDeclaration(statement) ||
+            ts.isEnumDeclaration(statement) ||
+            ts.isModuleDeclaration(statement)) {
+            if (statement.name)
+                names.add(statement.name.getText(sourceFile));
+        }
+    }
+    return names.size + extra;
+}