rooklang 0.0.0-stage → 0.3.1

package/dist/typescript/convert-base.js

@@ -0,0 +1,135 @@
+import { ANY, BOOL, literal, NEVER, NULL, nullable, NUMBER, BIGINT, STRING, union, VOID, } from "../checker/types.js";
+// The converter is a chain of layers: base (this one: primitives, unions, type parameters) → objects
+// (interfaces, classes, signatures) → TypeConverter (convert.ts: the exports of modules).
+export class ConverterBase {
+    ts;
+    program;
+    checker;
+    types = new Map();
+    /** Types being converted: a function type that refers to itself becomes `any` inside. */
+    converting = new Set();
+    params = new Map();
+    classes = new Map();
+    shared;
+    arrayInterface;
+    constructor(ts, program, shared = new Map()) {
+        this.ts = ts;
+        this.program = program;
+        this.checker = program.getTypeChecker();
+        this.shared = shared;
+    }
+    /** The key of a declaration that does not change between programs, or `null`. */
+    sharedKey(symbol, kind) {
+        const declarations = symbol.declarations ?? [];
+        if (declarations.length === 0)
+            return null;
+        const stable = declarations.every((declaration) => {
+            const file = declaration.getSourceFile();
+            return (this.program.isSourceFileDefaultLibrary(file) ||
+                this.program.isSourceFileFromExternalLibrary(file));
+        });
+        if (!stable)
+            return null;
+        const file = declarations[0].getSourceFile().fileName;
+        return `${kind} ${file} ${this.checker.getFullyQualifiedName(symbol)}`;
+    }
+    convert(type) {
+        const known = this.types.get(type);
+        if (known)
+            return known;
+        if (this.converting.has(type))
+            return ANY;
+        this.converting.add(type);
+        try {
+            const converted = this.convertType(type);
+            this.types.set(type, converted);
+            return converted;
+        }
+        finally {
+            this.converting.delete(type);
+        }
+    }
+    convertType(type) {
+        const { TypeFlags } = this.ts;
+        const { flags } = type;
+        if (flags & (TypeFlags.Any | TypeFlags.Unknown))
+            return ANY;
+        // `boolean` is the union `true | false` in TypeScript.
+        if (flags & TypeFlags.Boolean)
+            return BOOL;
+        if (flags & TypeFlags.String)
+            return STRING;
+        if (flags & TypeFlags.Number)
+            return NUMBER;
+        if (flags & (TypeFlags.BigInt | TypeFlags.BigIntLiteral))
+            return BIGINT;
+        if (flags & TypeFlags.StringLiteral)
+            return literal(type.value);
+        if (flags & TypeFlags.NumberLiteral)
+            return literal(type.value);
+        if (flags & TypeFlags.BooleanLiteral)
+            return literal(this.checker.typeToString(type) === 'true');
+        if (flags & (TypeFlags.TemplateLiteral | TypeFlags.StringMapping))
+            return STRING;
+        if (flags & (TypeFlags.Void | TypeFlags.Undefined))
+            return VOID;
+        if (flags & TypeFlags.Null)
+            return NULL;
+        if (flags & TypeFlags.Never)
+            return NEVER;
+        if (flags & TypeFlags.TypeParameter)
+            return this.typeParamOrThis(type);
+        if (flags & TypeFlags.Union)
+            return this.union(type.types);
+        if (flags & TypeFlags.Intersection)
+            return this.object(type, null);
+        if (flags & TypeFlags.Object)
+            return this.objectType(type);
+        return ANY;
+    }
+    /** `undefined`, `null` and `void` in a union make it nullable: `string | undefined` is `?string`. */
+    union(types) {
+        const { TypeFlags } = this.ts;
+        const empty = (type) => (type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.Void)) !== 0;
+        const rest = types.filter((type) => !empty(type)).map((type) => this.convert(type));
+        if (rest.length === 0)
+            return NULL;
+        const result = union(rest);
+        return types.some(empty) ? nullable(result) : result;
+    }
+    typeParamOrThis(type) {
+        // `this` in an interface or a class is the type itself.
+        if (type.isThisType) {
+            const constraint = type.getConstraint();
+            return constraint ? this.convert(constraint) : ANY;
+        }
+        return this.typeParam(type);
+    }
+    /**
+     * Constraints are not kept: they only matter in the bodies of generic functions, which in a
+     * `.d.ts` are not checked, and many have no counterpart. Defaults are kept: `Buffer` is
+     * `Buffer<ArrayBufferLike>`.
+     */
+    typeParam(type) {
+        let param = this.params.get(type);
+        if (!param) {
+            param = { kind: 'param', name: type.symbol?.name ?? 'T', constraint: null };
+            this.params.set(type, param);
+            const fallback = this.checker.getDefaultFromTypeParameter(type);
+            if (fallback)
+                param.default = this.convert(fallback);
+        }
+        return param;
+    }
+    /** Declared in TypeScript's lib files. */
+    isLibrary(symbol) {
+        return (symbol.declarations ?? []).some((declaration) => this.program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+    }
+}
+/** Members that Rook code can name: not `[Symbol.iterator]` and the like. */
+export function propertyNames(checker, type) {
+    return checker
+        .getPropertiesOfType(type)
+        .map((property) => property.name)
+        .filter((name) => /^[A-Za-z_$][\w$]*$/.test(name));
+}

package/dist/typescript/convert-objects.d.ts

@@ -0,0 +1,28 @@
+import { type ClassInfo, type FunctionType, type Member, type ObjectType, type Type, type TypeParam } from '../checker/types.ts';
+import type * as TS from 'typescript';
+import { ConverterBase } from './convert-base.ts';
+export declare abstract class ObjectConverter extends ConverterBase {
+    protected objectType(type: TS.ObjectType): Type;
+    /**
+     * `Array<T>` as an interface, for the members of arrays that the built-in types do not list.
+     * Elsewhere it is converted to `[]T`.
+     */
+    arrayTemplate(symbol: TS.Symbol): ObjectType;
+    /** A class or an interface; a generic one is the template its instances are made from. */
+    protected declared(type: TS.InterfaceType): Type;
+    /**
+     * An object type with members converted when used. It is registered before its signatures are
+     * converted, since they may refer to it.
+     */
+    protected object(type: TS.Type, name: string | null, typeParams?: TypeParam[]): ObjectType;
+    /**
+     * What `for v in x` gives: the `value` of what `next()` of `[Symbol.iterator]()` returns while
+     * it is not `done`. Found when it is first needed, as most types are never looped over.
+     */
+    private iterates;
+    protected member(type: TS.Type, name: string, owner: ClassInfo | null): Member | undefined;
+    /** The first signature, with the others as its overloads. */
+    protected signatures(list: readonly TS.Signature[]): FunctionType | null;
+    protected signature(signature: TS.Signature): FunctionType;
+    protected classInfo(symbol: TS.Symbol): ClassInfo;
+}

package/dist/typescript/convert-objects.js

@@ -0,0 +1,245 @@
+import { ANY, arrayOf, classInstance, createClass, func, instantiate, LazyMap, union, } from "../checker/types.js";
+import { ConverterBase, propertyNames } from "./convert-base.js";
+// Object types: arrays and tuples, interfaces and their generic templates, classes, functions with their overloads.
+export class ObjectConverter extends ConverterBase {
+    objectType(type) {
+        const { checker } = this;
+        const { ObjectFlags, SymbolFlags, SignatureKind } = this.ts;
+        if (checker.isArrayType(type)) {
+            const [element] = checker.getTypeArguments(type);
+            return arrayOf(element ? this.convert(element) : ANY);
+        }
+        // A tuple is an array of any of its elements: `[string, number]` is `[](string | number)`.
+        if (checker.isTupleType(type)) {
+            const elements = checker.getTypeArguments(type);
+            return arrayOf(elements.length > 0 ? union(elements.map((each) => this.convert(each))) : ANY);
+        }
+        if (type.objectFlags & ObjectFlags.Reference) {
+            const reference = type;
+            const { target } = reference;
+            if (target !== reference) {
+                // `Box<number>`: the generic declaration with type arguments (without the `this` one).
+                const generic = this.declared(target);
+                const count = target.typeParameters?.length ?? 0;
+                const args = checker
+                    .getTypeArguments(reference)
+                    .slice(0, count)
+                    .map((arg) => this.convert(arg));
+                if (generic.kind === 'class')
+                    return classInstance(generic.info, args);
+                if (generic.kind === 'object' && generic.typeParams)
+                    return instantiate(generic, args);
+                return generic;
+            }
+        }
+        if (type.objectFlags & (ObjectFlags.Class | ObjectFlags.Interface)) {
+            return this.declared(type);
+        }
+        // `typeof Foo` of a class: the class itself.
+        const symbol = type.getSymbol();
+        if (symbol && symbol.flags & SymbolFlags.Class && type.objectFlags & ObjectFlags.Anonymous) {
+            return this.classInfo(symbol).value;
+        }
+        // A function: call signatures and nothing else.
+        const calls = checker.getSignaturesOfType(type, SignatureKind.Call);
+        if (calls.length > 0 &&
+            propertyNames(checker, type).length === 0 &&
+            checker.getSignaturesOfType(type, SignatureKind.Construct).length === 0) {
+            return this.signatures(calls);
+        }
+        return this.object(type, null);
+    }
+    /**
+     * `Array<T>` as an interface, for the members of arrays that the built-in types do not list.
+     * Elsewhere it is converted to `[]T`.
+     */
+    arrayTemplate(symbol) {
+        if (!this.arrayInterface) {
+            const { checker } = this;
+            const type = checker.getDeclaredTypeOfSymbol(symbol);
+            this.arrayInterface = {
+                kind: 'object',
+                name: 'Array',
+                members: new LazyMap(() => propertyNames(checker, type), (name) => this.member(type, name, null)),
+                call: null,
+                typeParams: (type.typeParameters ?? []).map((param) => this.typeParam(param)),
+            };
+        }
+        return this.arrayInterface;
+    }
+    /** A class or an interface; a generic one is the template its instances are made from. */
+    declared(type) {
+        const { symbol } = type;
+        // A value of type `Function` can be called with anything, as in TypeScript.
+        if (symbol.name === 'Function' && this.isLibrary(symbol))
+            return ANY;
+        if (symbol.flags & this.ts.SymbolFlags.Class)
+            return this.classInfo(symbol).instance;
+        const key = this.sharedKey(symbol, 'interface');
+        const known = key === null ? undefined : this.shared.get(key);
+        if (known && !('instance' in known)) {
+            this.types.set(type, known);
+            return known;
+        }
+        const params = (type.typeParameters ?? []).map((param) => this.typeParam(param));
+        const object = this.object(type, symbol.name, params);
+        if (key !== null)
+            this.shared.set(key, object);
+        return object;
+    }
+    /**
+     * An object type with members converted when used. It is registered before its signatures are
+     * converted, since they may refer to it.
+     */
+    object(type, name, typeParams = []) {
+        const known = this.types.get(type);
+        if (known?.kind === 'object')
+            return known;
+        const { checker } = this;
+        const { SignatureKind, IndexKind } = this.ts;
+        const object = {
+            kind: 'object',
+            name,
+            members: new LazyMap(() => propertyNames(checker, type), (member) => this.member(type, member, null)),
+            call: null,
+        };
+        if (typeParams.length > 0)
+            object.typeParams = typeParams;
+        this.types.set(type, object);
+        object.call = this.signatures(checker.getSignaturesOfType(type, SignatureKind.Call));
+        const construct = this.signatures(checker.getSignaturesOfType(type, SignatureKind.Construct));
+        if (construct)
+            object.construct = construct;
+        const index = checker.getIndexTypeOfType(type, IndexKind.String);
+        const numberIndex = checker.getIndexTypeOfType(type, IndexKind.Number);
+        if (index)
+            object.index = this.convert(index);
+        if (numberIndex && numberIndex !== index)
+            object.numberIndex = this.convert(numberIndex);
+        this.iterates(object, type);
+        return object;
+    }
+    /**
+     * What `for v in x` gives: the `value` of what `next()` of `[Symbol.iterator]()` returns while
+     * it is not `done`. Found when it is first needed, as most types are never looped over.
+     */
+    iterates(object, type) {
+        const { checker } = this;
+        const iterator = type
+            .getProperties()
+            .find((property) => String(property.escapedName).startsWith('__@iterator@'));
+        if (!iterator)
+            return;
+        let found;
+        let done = false;
+        Object.defineProperty(object, 'iterates', {
+            enumerable: true,
+            get: () => {
+                if (done)
+                    return found;
+                done = true;
+                const next = checker
+                    .getTypeOfSymbol(iterator)
+                    .getCallSignatures()[0]
+                    ?.getReturnType()
+                    .getProperty('next');
+                const result = next && checker.getTypeOfSymbol(next).getCallSignatures()[0]?.getReturnType();
+                const results = result?.isUnion() ? result.types : result ? [result] : [];
+                const yielded = results.find((each) => {
+                    const flag = each.getProperty('done');
+                    return !flag || checker.typeToString(checker.getTypeOfSymbol(flag)) !== 'true';
+                });
+                const value = yielded?.getProperty('value');
+                found = value && this.convert(checker.getTypeOfSymbol(value));
+                return found;
+            },
+        });
+    }
+    member(type, name, owner) {
+        const property = this.checker.getPropertyOfType(type, name);
+        if (!property)
+            return undefined;
+        const { SymbolFlags, ModifierFlags } = this.ts;
+        const modifiers = property.valueDeclaration
+            ? this.ts.getCombinedModifierFlags(property.valueDeclaration)
+            : 0;
+        const visibility = modifiers & ModifierFlags.Private
+            ? 'private'
+            : modifiers & ModifierFlags.Protected
+                ? 'protected'
+                : 'public';
+        return {
+            // An optional property already includes `undefined`: `name?: string` is `?string`.
+            type: this.convert(this.checker.getTypeOfSymbol(property)),
+            method: (property.flags & SymbolFlags.Method) !== 0,
+            visibility,
+            owner,
+        };
+    }
+    /** The first signature, with the others as its overloads. */
+    signatures(list) {
+        const [first, ...rest] = list.map((signature) => this.signature(signature));
+        if (!first)
+            return null;
+        if (rest.length > 0)
+            first.overloads = rest;
+        return first;
+    }
+    signature(signature) {
+        const { ts, checker } = this;
+        const params = [];
+        let required = 0;
+        let rest = null;
+        for (const parameter of signature.getParameters()) {
+            const declaration = parameter.valueDeclaration;
+            const type = checker.getTypeOfSymbol(parameter);
+            const isParameter = declaration !== undefined && ts.isParameter(declaration);
+            if (isParameter && declaration.dotDotDotToken) {
+                const [element] = checker.isArrayType(type)
+                    ? checker.getTypeArguments(type)
+                    : [];
+                rest = element ? this.convert(element) : ANY;
+                break;
+            }
+            params.push(this.convert(type));
+            if (!isParameter || !checker.isOptionalParameter(declaration))
+                required = params.length;
+        }
+        const result = this.convert(checker.getReturnTypeOfSignature(signature));
+        return func(params, result.kind === 'void' ? [] : [result], {
+            required,
+            ...(rest ? { rest } : {}),
+            typeParams: (signature.getTypeParameters() ?? []).map((param) => this.typeParam(param)),
+        });
+    }
+    classInfo(symbol) {
+        const known = this.classes.get(symbol);
+        if (known)
+            return known;
+        const key = this.sharedKey(symbol, 'class');
+        const shared = key === null ? undefined : this.shared.get(key);
+        if (shared && 'instance' in shared) {
+            this.classes.set(symbol, shared);
+            return shared;
+        }
+        const { checker } = this;
+        const { SymbolFlags, SignatureKind } = this.ts;
+        const info = createClass(symbol.name);
+        this.classes.set(symbol, info);
+        if (key !== null)
+            this.shared.set(key, info);
+        const instance = checker.getDeclaredTypeOfSymbol(symbol);
+        info.typeParams = (instance.typeParameters ?? []).map((param) => this.typeParam(param));
+        // TypeScript lists inherited members too, already with the base class's type arguments.
+        info.members = new LazyMap(() => propertyNames(checker, instance), (name) => this.member(instance, name, info));
+        const statics = checker.getTypeOfSymbol(symbol);
+        info.statics = new LazyMap(() => propertyNames(checker, statics).filter((name) => name !== 'prototype'), (name) => this.member(statics, name, info));
+        const base = checker
+            .getBaseTypes(instance)
+            .find((type) => type.symbol && type.symbol.flags & SymbolFlags.Class);
+        if (base)
+            info.superClass = this.classInfo(base.symbol);
+        info.ctor = this.signatures(checker.getSignaturesOfType(statics, SignatureKind.Construct));
+        return info;
+    }
+}

package/dist/typescript/convert.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleExports } from '../checker/checker.ts';
+import { type Type } from '../checker/types.ts';
+import { ObjectConverter } from './convert-objects.ts';
+import type * as TS from 'typescript';
+export type { SharedTypes } from './convert-base.ts';
+/** Converts the types of a TypeScript program; one converter per program. */
+export declare class TypeConverter extends ObjectConverter {
+    /** The values and types a module exports, converted when they are imported. */
+    moduleExports(module: TS.Symbol): ModuleExports;
+    /** The type of a value: a class is the class itself. */
+    valueType(symbol: TS.Symbol): Type;
+    /** The type that a declaration names: an interface, a class instance, an alias. */
+    typeOf(symbol: TS.Symbol): Type;
+}

package/dist/typescript/convert.js

@@ -0,0 +1,67 @@
+import { LazyMap } from "../checker/types.js";
+import { ObjectConverter } from "./convert-objects.js";
+/** Converts the types of a TypeScript program; one converter per program. */
+export class TypeConverter extends ObjectConverter {
+    /** The values and types a module exports, converted when they are imported. */
+    moduleExports(module) {
+        const { checker } = this;
+        const { SymbolFlags } = this.ts;
+        const exported = new Map();
+        for (const symbol of checker.getExportsOfModule(module))
+            exported.set(symbol.name, symbol);
+        // `export = value` (CommonJS packages, `node:path`): the default import is the value itself,
+        // and named imports are its properties.
+        const assigned = module.exports?.get(this.ts.InternalSymbolName.ExportEquals);
+        if (assigned) {
+            if (!exported.has('default'))
+                exported.set('default', assigned);
+            const value = assigned.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(assigned) : assigned;
+            if (value.flags & SymbolFlags.Value) {
+                for (const property of checker.getPropertiesOfType(checker.getTypeOfSymbol(value))) {
+                    if (!exported.has(property.name))
+                        exported.set(property.name, property);
+                }
+            }
+        }
+        const target = (name) => {
+            const symbol = exported.get(name);
+            return symbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+        };
+        return {
+            values: new LazyMap(() => exported.keys(), (name) => {
+                const symbol = target(name);
+                return symbol.flags & SymbolFlags.Value ? this.valueType(symbol) : undefined;
+            }),
+            types: new LazyMap(() => exported.keys(), (name) => {
+                const symbol = target(name);
+                return symbol.flags & SymbolFlags.Type ? this.typeOf(symbol) : undefined;
+            }),
+        };
+    }
+    /** The type of a value: a class is the class itself. */
+    valueType(symbol) {
+        if (symbol.flags & this.ts.SymbolFlags.Class)
+            return this.classInfo(symbol).value;
+        return this.convert(this.checker.getTypeOfSymbol(symbol));
+    }
+    /** The type that a declaration names: an interface, a class instance, an alias. */
+    typeOf(symbol) {
+        const { SymbolFlags } = this.ts;
+        if (symbol.flags & SymbolFlags.Class)
+            return this.classInfo(symbol).instance;
+        const type = this.convert(this.checker.getDeclaredTypeOfSymbol(symbol));
+        // `type Pair<A, B> = { ... }` works like a generic interface: `Pair<number, string>`.
+        if (symbol.flags & SymbolFlags.TypeAlias && type.kind === 'object' && !type.typeParams) {
+            const declaration = symbol.declarations?.find(this.ts.isTypeAliasDeclaration);
+            const params = declaration?.typeParameters ?? [];
+            if (params.length > 0) {
+                return {
+                    ...type,
+                    name: symbol.name,
+                    typeParams: params.map((param) => this.typeParam(this.checker.getTypeAtLocation(param))),
+                };
+            }
+        }
+        return type;
+    }
+}

package/dist/typescript/importer.d.ts

@@ -0,0 +1,37 @@
+import type { ImportResult, Library } from '../checker/checker.ts';
+export declare class DeclarationImporter {
+    private ts;
+    /** Files with declarations that imports resolved to; the program is rebuilt when one is added. */
+    private readonly roots;
+    /** `node_modules/@types` folders above the importing files: `@types/node` gives `node:fs`. */
+    private readonly typeRoots;
+    /** The packages in them; TypeScript 6 does not include them by itself. */
+    private readonly typePackages;
+    private program;
+    private stale;
+    private converter;
+    /** Types of lib files and packages, shared by the converters of every program. */
+    private readonly shared;
+    private libraryTypes;
+    private readonly results;
+    /** The exports of the module `specifier` imported from the file `fromFile`. */
+    import(fromFile: string, specifier: string): ImportResult;
+    /**
+     * The standard library and the DOM for a file: TypeScript's lib files and the `@types` packages
+     * above it. The globals come from the program as it is when they are used.
+     */
+    library(fromFile: string): Library | undefined;
+    private loadTypeScript;
+    private resolve;
+    private addTypeRoots;
+    private options;
+    /**
+     * The program with every root so far. A new program reuses the files of the old one; types
+     * already imported keep coming from the old one.
+     */
+    private current;
+}
+/** Imports with declarations, shared by every compilation in this process. */
+export declare function importDeclarations(fromFile: string, specifier: string): ImportResult;
+/** The standard library and the DOM for a file, shared like the imports. */
+export declare function libraryFor(fromFile: string): Library | undefined;

package/dist/typescript/importer.js

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { TypeConverter } from "./convert.js";
+import { LibraryTypes } from "./library.js";
+// Types of imports that are not `.rk` modules: npm packages, `node:` modules and `.ts` files.
+// The TypeScript compiler finds and reads their declarations; it is loaded only when such an
+// import is checked, and an import without declarations stays untyped (`any`).
+const TYPESCRIPT_EXTENSIONS = ['.d.ts', '.d.mts', '.d.cts', '.ts', '.mts', '.cts', '.tsx'];
+export class DeclarationImporter {
+    ts;
+    /** Files with declarations that imports resolved to; the program is rebuilt when one is added. */
+    roots = new Set();
+    /** `node_modules/@types` folders above the importing files: `@types/node` gives `node:fs`. */
+    typeRoots = new Set();
+    /** The packages in them; TypeScript 6 does not include them by itself. */
+    typePackages = new Set();
+    program;
+    stale = true;
+    converter;
+    /** Types of lib files and packages, shared by the converters of every program. */
+    shared = new Map();
+    libraryTypes;
+    results = new Map();
+    /** The exports of the module `specifier` imported from the file `fromFile`. */
+    import(fromFile, specifier) {
+        const key = `${dirname(fromFile)}\0${specifier}`;
+        if (this.results.has(key))
+            return this.results.get(key);
+        const ts = this.loadTypeScript();
+        const result = ts ? this.resolve(ts, fromFile, specifier) : undefined;
+        this.results.set(key, result);
+        return result;
+    }
+    /**
+     * The standard library and the DOM for a file: TypeScript's lib files and the `@types` packages
+     * above it. The globals come from the program as it is when they are used.
+     */
+    library(fromFile) {
+        const ts = this.loadTypeScript();
+        if (!ts)
+            return undefined;
+        this.addTypeRoots(fromFile);
+        const current = () => this.current(ts).library;
+        return {
+            value: (name) => current().value(name),
+            type: (name) => current().type(name),
+            primitive: (kind) => current().primitive(kind),
+            array: (element) => current().array(element),
+            element: (tag, svg) => current().element(tag, svg),
+            event: (name) => current().event(name),
+            names: (of) => current().names(of),
+        };
+    }
+    loadTypeScript() {
+        if (this.ts === undefined) {
+            try {
+                this.ts = createRequire(import.meta.url)('typescript');
+            }
+            catch {
+                this.ts = null;
+            }
+        }
+        return this.ts;
+    }
+    resolve(ts, fromFile, specifier) {
+        this.addTypeRoots(fromFile);
+        const { resolvedModule } = ts.resolveModuleName(specifier, fromFile, this.options(ts), ts.sys);
+        if (resolvedModule) {
+            const file = resolvedModule.resolvedFileName;
+            // A JS file without declarations next to it.
+            if (!TYPESCRIPT_EXTENSIONS.some((extension) => file.endsWith(extension)))
+                return undefined;
+            if (!this.roots.has(file)) {
+                this.roots.add(file);
+                this.stale = true;
+            }
+            const { program, converter } = this.current(ts);
+            const source = program.getSourceFile(file);
+            const module = source && program.getTypeChecker().getSymbolAtLocation(source);
+            return module ? { exports: converter.moduleExports(module) } : undefined;
+        }
+        // `node:fs`, `fs`: modules declared with `declare module "..."`, as in @types/node.
+        const { program, converter } = this.current(ts);
+        const name = JSON.stringify(specifier);
+        const ambient = program
+            .getTypeChecker()
+            .getAmbientModules()
+            .find((module) => module.name === name);
+        return ambient ? { exports: converter.moduleExports(ambient) } : undefined;
+    }
+    addTypeRoots(fromFile) {
+        for (let directory = dirname(fromFile);; directory = dirname(directory)) {
+            const types = join(directory, 'node_modules', '@types');
+            if (!this.typeRoots.has(types) && existsSync(types)) {
+                this.typeRoots.add(types);
+                for (const name of readdirSync(types)) {
+                    if (!name.startsWith('.'))
+                        this.typePackages.add(name);
+                }
+                this.stale = true;
+            }
+            if (dirname(directory) === directory)
+                break;
+        }
+    }
+    options(ts) {
+        return {
+            // ES2025 has the helpers of iterators, `take`, `map` and the like, which iterators use.
+            target: ts.ScriptTarget.ES2025,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            allowImportingTsExtensions: true,
+            esModuleInterop: true,
+            strict: true,
+            skipLibCheck: true,
+            noEmit: true,
+            typeRoots: [...this.typeRoots],
+            types: [...this.typePackages],
+        };
+    }
+    /**
+     * The program with every root so far. A new program reuses the files of the old one; types
+     * already imported keep coming from the old one.
+     */
+    current(ts) {
+        if (this.stale || !this.program || !this.converter || !this.libraryTypes) {
+            const options = this.options(ts);
+            this.program = ts.createProgram({
+                // Without a root file, a program reads neither the lib nor the `types` packages.
+                rootNames: [ts.getDefaultLibFilePath(options), ...this.roots],
+                options,
+                ...(this.program ? { oldProgram: this.program } : {}),
+            });
+            this.converter = new TypeConverter(ts, this.program, this.shared);
+            this.libraryTypes = new LibraryTypes(ts, this.program, this.converter);
+            this.stale = false;
+        }
+        return { program: this.program, converter: this.converter, library: this.libraryTypes };
+    }
+}
+let shared;
+/** Imports with declarations, shared by every compilation in this process. */
+export function importDeclarations(fromFile, specifier) {
+    shared ??= new DeclarationImporter();
+    return shared.import(fromFile, specifier);
+}
+/** The standard library and the DOM for a file, shared like the imports. */
+export function libraryFor(fromFile) {
+    shared ??= new DeclarationImporter();
+    return shared.library(fromFile);
+}