@goodbones/typescript 0.1.0-beta.1 → 0.1.0-beta.10

package/build/esm/extractor.js

@@ -1,263 +1,396 @@
-import ts from "typescript";
-// The facts, read out of TypeScript's syntax tree. The plugin reads the same
-// facts out of oxlint's; `src/adapters/parity.test.ts` holds the two to one
-// answer, so a form added here without the matching visitor there fails a test
-// rather than a user.
-const scriptKindOf = (file) => file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+import { parseSync, rawTransferSupported, Visitor, } from "oxc-parser";
+// The whole module, as one binding. `export * from "m"`, `export * as ns from
+// "m"`, `import x = require("m")`, `import("m")` and `require("m")` all carry
+// every export of `m` at once, exactly as `import * as ns` does — and are the
+// same way around a rule about a name. A side-effect import carries nothing.
+const wholeModule = (node, local) => [
+    { symbol: "*", kind: "namespace", node, local },
+];
+// The name written at a key or a module export name: an identifier, or a
+// string literal (`import { "a-b" as ab }`, `"c-d": number`). A numeric key,
+// a private `#name` and a computed expression are not names a rule can speak
+// about.
 const nameOf = (node) => {
-    if (node === undefined)
+    if (node === null)
         return null;
-    if (ts.isIdentifier(node))
-        return node.text;
-    if (ts.isStringLiteral(node))
-        return node.text;
+    if (node.type === "Identifier")
+        return node.name;
+    if (node.type === "Literal" && typeof node.value === "string")
+        return node.value;
     return null;
 };
-const bindingsOfImportClause = (clause) => {
-    if (clause === undefined)
-        return [];
-    const found = [];
-    if (clause.name !== undefined)
-        found.push({ symbol: "default", kind: "default" });
-    const bindings = clause.namedBindings;
-    if (bindings !== undefined) {
-        if (ts.isNamespaceImport(bindings))
-            found.push({ symbol: "*", kind: "namespace" });
-        else {
-            for (const element of bindings.elements) {
-                const symbol = nameOf(element.propertyName ?? element.name);
-                if (symbol !== null)
-                    found.push({ symbol, kind: "named" });
-            }
+const bindingOf = (specifier) => {
+    const local = specifier.local.name;
+    switch (specifier.type) {
+        case "ImportSpecifier": {
+            const symbol = nameOf(specifier.imported);
+            return symbol === null ? null : { symbol, kind: "named", node: specifier, local };
         }
+        case "ImportDefaultSpecifier":
+            return { symbol: "default", kind: "default", node: specifier, local };
+        case "ImportNamespaceSpecifier":
+            return { symbol: "*", kind: "namespace", node: specifier, local };
     }
-    return found;
 };
-// The whole module, as one binding. `export * from "m"`, `export * as ns from
-// "m"`, `import x = require("m")`, `import("m")` and `require("m")` all carry
-// every export of `m` at once, exactly as `import * as ns` does — and are the
-// same way around a rule about a name. A side-effect import carries nothing.
-const WHOLE_MODULE = [{ symbol: "*", kind: "namespace" }];
-// `export { a } from "m"` — `propertyName` is the name in the source module when
-// the export is renamed, so it is the one the policy is about.
-const bindingsOfExportClause = (clause) => {
-    if (clause === undefined || ts.isNamespaceExport(clause))
-        return WHOLE_MODULE;
+// `export { a as b } from "m"` — `local` is the name in the source module, so
+// it is the one the policy is about.
+const reexportedBindings = (node) => {
     const found = [];
-    for (const element of clause.elements) {
-        const symbol = nameOf(element.propertyName ?? element.name);
+    for (const specifier of node.specifiers) {
+        const symbol = nameOf(specifier.local);
         if (symbol !== null)
-            found.push({ symbol, kind: "named" });
+            found.push({ symbol, kind: "named", node: specifier, local: symbol });
     }
     return found;
 };
-// The type literals written in a type, through intersections, unions and
-// parentheses: `type Port = Base & ({ a(): void } | { b(): void })` declares `a`
-// and `b`. A reference is not followed — `Base`'s members are declared where
-// `Base` is, and are reported there under its own name.
+// The type literals written in a type, through intersections and unions:
+// `type Port = Base & ({ a(): void } | { b(): void })` declares `a` and `b`. A
+// reference is not followed — `Base`'s members are declared where `Base` is,
+// and are reported there under its own name. The parenthesised form is read
+// too, for a tree parsed with `preserveParens`; oxlint's and `factsOfText`'s
+// carry none.
 const literalsOf = (node) => {
-    if (ts.isTypeLiteralNode(node))
-        return [node];
-    if (ts.isIntersectionTypeNode(node) || ts.isUnionTypeNode(node)) {
-        return node.types.flatMap(literalsOf);
+    switch (node.type) {
+        case "TSTypeLiteral":
+            return [node];
+        case "TSIntersectionType":
+        case "TSUnionType":
+            return node.types.flatMap(literalsOf);
+        case "TSParenthesizedType":
+            return literalsOf(node.typeAnnotation);
+        default:
+            return [];
     }
-    if (ts.isParenthesizedTypeNode(node))
-        return literalsOf(node.type);
-    return [];
 };
-// The member shapes that carry a name a vocabulary rule can speak about: a
-// property or method signature in a type, a property, method or accessor in a
-// class. Mirrors the plugin's `DECLARED_MEMBER_TYPES`.
-const isNamedMember = (member) => ts.isPropertySignature(member) ||
-    ts.isMethodSignature(member) ||
-    ts.isPropertyDeclaration(member) ||
-    ts.isMethodDeclaration(member) ||
-    ts.isGetAccessorDeclaration(member) ||
-    ts.isSetAccessorDeclaration(member);
-const calleeNameOf = (expression) => {
-    if (ts.isIdentifier(expression))
-        return expression.text;
-    if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name)) {
-        return expression.name.text;
+// The key of a member shape that carries a name a vocabulary rule can speak
+// about: a property or method signature in a type; a property, method,
+// accessor or auto-accessor in a class. A computed key is no name, and neither
+// is an index, call or construct signature, a static block, or a constructor.
+const keyOf = (member) => {
+    switch (member.type) {
+        case "TSPropertySignature":
+        case "TSMethodSignature":
+        case "PropertyDefinition":
+        case "TSAbstractPropertyDefinition":
+        case "AccessorProperty":
+        case "TSAbstractAccessorProperty":
+            return member.computed ? null : member.key;
+        case "MethodDefinition":
+        case "TSAbstractMethodDefinition":
+            return member.computed || member.kind === "constructor" ? null : member.key;
+        default:
+            return null;
     }
+};
+// The name a call is made by: `f()` and `x.f()` are both `f`. `x[f]()` and
+// `x["f"]()` are not — a computed property is not a name a vocabulary rule can
+// speak about — and neither is a private `x.#f()`.
+const calleeNameOf = (callee) => {
+    if (callee.type === "Identifier")
+        return callee.name;
+    if (callee.type === "MemberExpression" && !callee.computed)
+        return nameOf(callee.property);
     return null;
 };
-// The parse alone, for a source that need not be on disk — the CLI reads
-// every file through it, a source probe is checked through it at load, and the
-// parity suite feeds both adapters the same snippet through it.
-export const factsOfText = (file, text) => {
-    const parsed = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKindOf(file));
-    const specifiers = [];
-    const bindings = new Map();
-    const memberSites = [];
-    const record = (specifier, found) => {
-        if (!bindings.has(specifier)) {
-            specifiers.push(specifier);
-            bindings.set(specifier, []);
-        }
-        const existing = bindings.get(specifier);
-        if (existing !== undefined)
-            for (const binding of found)
-                existing.push(binding);
-    };
-    // The members written in a declaration, under that declaration's name and
-    // kind. A computed key is not a name a vocabulary rule can speak about;
-    // neither is a private `#name`, an index, call or construct signature, or a
-    // constructor.
-    const declared = (declaration, declares, members) => {
-        for (const member of members) {
-            if (!isNamedMember(member))
-                continue;
-            if (ts.isComputedPropertyName(member.name) || ts.isPrivateIdentifier(member.name))
-                continue;
-            const name = nameOf(member.name);
-            if (name !== null) {
-                memberSites.push({ file, subject: "members", name, in: declaration, declares });
-            }
-        }
-    };
-    const visit = (node) => {
-        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-            // A side-effect import carries no bindings but is still an edge — the
-            // `import "server-only"` form a regex cannot see.
-            record(node.moduleSpecifier.text, bindingsOfImportClause(node.importClause));
-        }
-        else if (ts.isExportDeclaration(node) &&
-            node.moduleSpecifier !== undefined &&
-            ts.isStringLiteral(node.moduleSpecifier)) {
-            record(node.moduleSpecifier.text, bindingsOfExportClause(node.exportClause));
-        }
-        else if (ts.isImportEqualsDeclaration(node) &&
-            ts.isExternalModuleReference(node.moduleReference) &&
-            ts.isStringLiteral(node.moduleReference.expression)) {
-            record(node.moduleReference.expression.text, WHOLE_MODULE);
-        }
-        else if (ts.isCallExpression(node)) {
-            const [first] = node.arguments;
-            const isModuleCall = node.expression.kind === ts.SyntaxKind.ImportKeyword ||
-                (ts.isIdentifier(node.expression) && node.expression.text === "require");
-            if (isModuleCall && first !== undefined && ts.isStringLiteral(first)) {
-                record(first.text, WHOLE_MODULE);
-            }
-            const callee = calleeNameOf(node.expression);
-            if (callee !== null)
-                memberSites.push({ file, subject: "calls", name: callee });
-        }
-        else if (ts.isTypeAliasDeclaration(node)) {
-            declared(node.name.text, "type", literalsOf(node.type).flatMap((literal) => literal.members));
-        }
-        else if (ts.isInterfaceDeclaration(node)) {
-            declared(node.name.text, "interface", node.members);
-        }
-        else if (ts.isClassDeclaration(node) && node.name !== undefined) {
-            // A class body is a declaration with members like any other. An anonymous
-            // class (`export default class {}`) has no name for `in` and is not read;
-            // neither is a class expression, which is a value.
-            declared(node.name.text, "class", node.members);
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(parsed);
-    return { specifiers, bindings, memberSites, exportSites: exportSitesOf(file, parsed) };
+const requireSpecifierOf = (node) => {
+    if (node.callee.type !== "Identifier" || node.callee.name !== "require")
+        return null;
+    const [first] = node.arguments;
+    return first?.type === "Literal" && typeof first.value === "string" ? first.value : null;
+};
+// The identifiers a binding pattern introduces.
+const patternNames = (pattern) => {
+    switch (pattern.type) {
+        case "Identifier":
+            return [pattern.name];
+        case "ObjectPattern":
+            return pattern.properties.flatMap((property) => patternNames(property.type === "Property" ? property.value : property.argument));
+        case "ArrayPattern":
+            return pattern.elements.flatMap((element) => (element === null ? [] : patternNames(element)));
+        case "AssignmentPattern":
+            return patternNames(pattern.left);
+        case "RestElement":
+            return patternNames(pattern.argument);
+    }
+};
+// `namespace A.B {}` declares `A`; `declare module "m" {}` declares no name a
+// module's surface can carry.
+const moduleNameOf = (node) => {
+    const id = node.id;
+    if (id.type !== "TSQualifiedName")
+        return nameOf(id);
+    let left = id.left;
+    while (left.type === "TSQualifiedName")
+        left = left.left;
+    return left.type === "Identifier" ? left.name : null;
 };
-const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((one) => one.kind === kind);
 // The names a declaration statement introduces, with what it declares them as.
 // A destructuring pattern introduces names too, but not ones a surface rule
 // judges by declaration kind; they read as `variable` like the rest.
-const declaredNamesOf = (statement) => {
-    if (ts.isFunctionDeclaration(statement)) {
-        return statement.name === undefined ? [] : [[statement.name.text, "function"]];
+const declaredNamesOf = (declaration) => {
+    const named = (name, declares) => (name === null ? [] : [[name, declares]]);
+    switch (declaration.type) {
+        case "VariableDeclaration":
+            return declaration.declarations.flatMap((one) => patternNames(one.id).map((name) => [name, "variable"]));
+        case "FunctionDeclaration":
+        case "TSDeclareFunction":
+            return named(declaration.id?.name ?? null, "function");
+        case "ClassDeclaration":
+            return named(declaration.id?.name ?? null, "class");
+        case "TSTypeAliasDeclaration":
+            return named(declaration.id.name, "type");
+        case "TSInterfaceDeclaration":
+            return named(declaration.id.name, "interface");
+        case "TSEnumDeclaration":
+            return named(declaration.id.name, "enum");
+        case "TSModuleDeclaration":
+            return named(declaration.global ? declaration.id.name : moduleNameOf(declaration), "other");
+        default:
+            return [];
     }
-    if (ts.isClassDeclaration(statement)) {
-        return statement.name === undefined ? [] : [[statement.name.text, "class"]];
-    }
-    if (ts.isVariableStatement(statement)) {
-        const names = [];
-        const collect = (binding) => {
-            if (ts.isIdentifier(binding))
-                names.push([binding.text, "variable"]);
-            else {
-                for (const element of binding.elements) {
-                    if (ts.isBindingElement(element))
-                        collect(element.name);
-                }
-            }
-        };
-        for (const declaration of statement.declarationList.declarations)
-            collect(declaration.name);
-        return names;
+};
+// The declaration an `export default …` carries, when it is one — a function,
+// class or interface, named or not — rather than an expression.
+const defaultDeclaration = (node) => {
+    const declaration = node.declaration;
+    switch (declaration.type) {
+        case "FunctionDeclaration":
+        case "TSDeclareFunction":
+        case "ClassDeclaration":
+        case "TSInterfaceDeclaration":
+            return declaration;
+        default:
+            return null;
     }
-    if (ts.isTypeAliasDeclaration(statement))
-        return [[statement.name.text, "type"]];
-    if (ts.isInterfaceDeclaration(statement))
-        return [[statement.name.text, "interface"]];
-    if (ts.isEnumDeclaration(statement))
-        return [[statement.name.text, "enum"]];
-    if (ts.isModuleDeclaration(statement) && ts.isIdentifier(statement.name)) {
-        return [[statement.name.text, "other"]];
+};
+// What `export default …` declares: a function, class or interface by its
+// shape, named or not; an identifier by the declaration it names in this
+// file; any other expression as one.
+const defaultDeclares = (node, locals) => {
+    const declaration = node.declaration;
+    switch (declaration.type) {
+        case "FunctionDeclaration":
+        case "TSDeclareFunction":
+            return "function";
+        case "ClassDeclaration":
+            return "class";
+        case "TSInterfaceDeclaration":
+            return "interface";
+        case "Identifier":
+            return locals.get(declaration.name) ?? "expression";
+        default:
+            return "expression";
     }
-    return [];
 };
-// A file's surface: what its top-level statements export, in source order. An
-// `export` inside a namespace body is that namespace's, not the module's.
-const exportSitesOf = (file, parsed) => {
+// A file's surface: what its top-level statements export, in source order,
+// read off the program body rather than by visiting export nodes — an `export`
+// inside a namespace body is that namespace's, not the module's, and reading
+// the top level directly is what says so without a parent pointer. `export =`
+// is a CommonJS surface, not a module's, and is stepped over.
+const exportSitesOf = (file, body) => {
     const locals = new Map();
-    for (const statement of parsed.statements) {
-        for (const [name, declares] of declaredNamesOf(statement))
+    for (const statement of body) {
+        const declaration = statement.type === "ExportNamedDeclaration"
+            ? statement.declaration
+            : statement.type === "ExportDefaultDeclaration"
+                ? defaultDeclaration(statement)
+                : statement;
+        if (declaration === null)
+            continue;
+        for (const [name, declares] of declaredNamesOf(declaration))
             locals.set(name, declares);
     }
     const sites = [];
-    const site = (name, kind, declares, reexport) => {
-        sites.push({ file, name, kind, declares, reexport });
+    const site = (node, name, kind, declares, reexport) => {
+        sites.push({ file, name, kind, declares, reexport, node });
     };
-    for (const statement of parsed.statements) {
-        if (ts.isExportDeclaration(statement)) {
-            const reexport = statement.moduleSpecifier !== undefined;
-            const clause = statement.exportClause;
-            if (clause === undefined)
-                site("*", "namespace", "other", true);
-            else if (ts.isNamespaceExport(clause))
-                site(clause.name.text, "namespace", "other", true);
-            else {
-                for (const element of clause.elements) {
-                    const name = nameOf(element.name);
+    for (const statement of body) {
+        switch (statement.type) {
+            case "ExportNamedDeclaration": {
+                const declaration = statement.declaration;
+                if (declaration !== null) {
+                    for (const [name, declares] of declaredNamesOf(declaration)) {
+                        site(declaration, name, "named", declares, false);
+                    }
+                    break;
+                }
+                const reexport = statement.source !== null;
+                for (const specifier of statement.specifiers) {
+                    const name = nameOf(specifier.exported);
                     if (name === null)
                         continue;
-                    const local = nameOf(element.propertyName ?? element.name) ?? name;
+                    const local = nameOf(specifier.local) ?? name;
                     const declares = reexport ? "other" : (locals.get(local) ?? "other");
-                    site(name, name === "default" ? "default" : "named", declares, reexport);
+                    site(specifier, name, name === "default" ? "default" : "named", declares, reexport);
                 }
+                break;
             }
+            case "ExportDefaultDeclaration":
+                site(statement, "default", "default", defaultDeclares(statement, locals), false);
+                break;
+            case "ExportAllDeclaration":
+                site(statement, nameOf(statement.exported) ?? "*", "namespace", "other", true);
+                break;
+            default:
+                break;
         }
-        else if (ts.isExportAssignment(statement)) {
-            // `export = x` is a CommonJS surface, not a module's.
-            if (statement.isExportEquals === true)
-                continue;
-            const declares = ts.isIdentifier(statement.expression)
-                ? (locals.get(statement.expression.text) ?? "expression")
-                : "expression";
-            site("default", "default", declares, false);
+    }
+    return sites;
+};
+const IDLE = { file: "", edges: [], memberSites: [] };
+let reading = IDLE;
+const edge = (node, specifier, form, bindings) => {
+    reading.edges.push({ specifier, form, node, bindings });
+};
+// The members written in a declaration, under that declaration's name and
+// kind, each at its key.
+const declared = (declaration, declares, members) => {
+    for (const member of members) {
+        const key = keyOf(member);
+        if (key === null)
+            continue;
+        const name = nameOf(key);
+        if (name !== null) {
+            reading.memberSites.push({
+                file: reading.file,
+                subject: "members",
+                name,
+                in: declaration,
+                declares,
+                node: key,
+            });
         }
-        else if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
-            const isDefault = hasModifier(statement, ts.SyntaxKind.DefaultKeyword);
-            const declared = declaredNamesOf(statement);
-            if (isDefault) {
-                // `export default function () {}` has no name to look up.
-                const declares = declared[0]?.[1] ??
-                    (ts.isFunctionDeclaration(statement)
-                        ? "function"
-                        : ts.isClassDeclaration(statement)
-                            ? "class"
-                            : "other");
-                site("default", "default", declares, false);
-            }
-            else {
-                for (const [name, declares] of declared)
-                    site(name, "named", declares, false);
-            }
+    }
+};
+// Every form that names a module is an edge, in source order. A computed
+// `import(expr)` or `require(expr)` is not a fact a static policy can speak
+// about.
+const walker = new Visitor({
+    ImportDeclaration(node) {
+        // A side-effect import carries no bindings but is still an edge — the
+        // `import "server-only"` form a regex cannot see.
+        const bindings = node.specifiers.flatMap((specifier) => {
+            const found = bindingOf(specifier);
+            return found === null ? [] : [found];
+        });
+        edge(node, node.source.value, "import", bindings);
+    },
+    ExportNamedDeclaration(node) {
+        if (node.source !== null)
+            edge(node, node.source.value, "export", reexportedBindings(node));
+    },
+    ExportAllDeclaration(node) {
+        edge(node, node.source.value, "export", wholeModule(node, nameOf(node.exported) ?? ""));
+    },
+    TSImportEqualsDeclaration(node) {
+        const reference = node.moduleReference;
+        if (reference.type === "TSExternalModuleReference") {
+            edge(node, reference.expression.value, "import-equals", wholeModule(node, node.id.name));
+        }
+    },
+    ImportExpression(node) {
+        if (node.source.type === "Literal" && typeof node.source.value === "string") {
+            edge(node, node.source.value, "import-expression", wholeModule(node, ""));
+        }
+    },
+    CallExpression(node) {
+        const required = requireSpecifierOf(node);
+        if (required !== null)
+            edge(node, required, "require", wholeModule(node, ""));
+        const callee = calleeNameOf(node.callee);
+        if (callee !== null) {
+            reading.memberSites.push({ file: reading.file, subject: "calls", name: callee, node });
+        }
+    },
+    TSTypeAliasDeclaration(node) {
+        declared(node.id.name, "type", literalsOf(node.typeAnnotation).flatMap((literal) => literal.members));
+    },
+    TSInterfaceDeclaration(node) {
+        declared(node.id.name, "interface", node.body.body);
+    },
+    // A named class only: an anonymous default class has no name for `in`, and
+    // a class expression is a value. `ClassDeclaration` is the visitor key, so a
+    // class expression is never handed in.
+    ClassDeclaration(node) {
+        if (node.id !== null)
+            declared(node.id.name, "class", node.body.body);
+    },
+});
+// Reads every fact out of one program, with the node each came from. Pure over
+// the tree: oxlint's plugin calls it on the tree oxlint parsed, and
+// `factsOfText` on the one oxc-parser did.
+export const readProgram = (file, program) => {
+    const read = { file, edges: [], memberSites: [] };
+    reading = read;
+    // The walk starts at a root of this shape and reads only its `body`.
+    walker.visit({
+        type: "Program",
+        body: program.body,
+        sourceType: "module",
+        hashbang: null,
+        start: 0,
+        end: 0,
+    });
+    reading = IDLE;
+    return {
+        edges: read.edges,
+        memberSites: read.memberSites,
+        exportSites: exportSitesOf(file, program.body),
+    };
+};
+const langOf = (file) => (file.endsWith(".tsx") ? "tsx" : "ts");
+// Raw transfer hands the tree over as bytes and builds the nodes here, rather
+// than serialising it to JSON in Rust and parsing that back — about three
+// times the throughput of the JSON path on a source tree of ordinary files,
+// and the difference between this parser and the compiler API being faster
+// or slower. The buffer it reads from is reused across parses and returned
+// before the tree is, so nothing here outlives a parse. The option is not in
+// the parser's declared type yet; it is read all the same. Where the platform
+// cannot do it (32-bit, big-endian, a Node before 22), the JSON path is what
+// runs, at the same answer.
+const RAW_TRANSFER = {
+    experimentalRawTransfer: rawTransferSupported(),
+    preserveParens: false,
+};
+const stripNode = (carrying) => {
+    const { node: _node, ...fact } = carrying;
+    return fact;
+};
+// The facts with the nodes stripped: one entry per specifier, in the order
+// first written, carrying every binding pulled across it.
+export const sourceFactsOf = (read) => {
+    const specifiers = [];
+    const bindings = new Map();
+    for (const edge of read.edges) {
+        let found = bindings.get(edge.specifier);
+        if (found === undefined) {
+            found = [];
+            bindings.set(edge.specifier, found);
+            specifiers.push(edge.specifier);
+        }
+        // The local name goes with the binding: it is how a campaign's `syntax`
+        // term traces an identifier back to its import. A form that binds no name
+        // (`import("m")`, `require("m")`) carries none.
+        for (const { kind, local, symbol } of edge.bindings) {
+            found.push(local === "" ? { symbol, kind } : { symbol, kind, local });
         }
     }
-    return sites;
+    return {
+        specifiers,
+        bindings,
+        memberSites: read.memberSites.map(stripNode),
+        exportSites: read.exportSites.map(stripNode),
+    };
+};
+// The parse alone, for a source that need not be on disk — the CLI reads
+// every file through it, a source probe is checked through it at load, and the
+// parity suite feeds both hosts the same snippet through it. Parentheses are
+// not kept as nodes, which is the tree oxlint hands a plugin. A syntax error
+// does not throw: oxc reports it and returns an empty program, so a file that
+// does not parse contributes no facts — the same file no linter would visit.
+export const factsOfText = (file, text) => {
+    const { program } = parseSync(file, text, { ...RAW_TRANSFER, lang: langOf(file) });
+    return sourceFactsOf(readProgram(file, program));
 };
 export const makeFactExtractorLive = () => ({ factsOf: factsOfText });
 //# sourceMappingURL=extractor.js.map