rooklang 0.0.0-stage → 0.3.0

package/dist/run.js

@@ -0,0 +1,21 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { CompileError } from "./compile-file.js";
+// The process of `rook run`, started with `--import` of loader.ts: it runs the program and shows
+// compile errors without a stack trace.
+try {
+    await import(__rewriteRelativeImportExtension(pathToFileURL(resolve(process.argv[2])).href));
+}
+catch (err) {
+    // Anything else is thrown by the running program: show the full stack trace.
+    console.error(err instanceof CompileError ? err.message : err);
+    process.exitCode = 1;
+}

package/dist/source.d.ts

@@ -0,0 +1,15 @@
+/** A source file with fast offset → line/column lookup. */
+export declare class SourceFile {
+    readonly name: string;
+    readonly text: string;
+    /** Offset at which each line starts. */
+    private readonly lineStarts;
+    constructor(name: string, text: string);
+    /** 1-based line and column of a character offset. */
+    position(offset: number): {
+        line: number;
+        column: number;
+    };
+    /** Text of a 1-based line, without the line break. */
+    lineText(line: number): string;
+}

package/dist/source.js

@@ -0,0 +1,34 @@
+/** A source file with fast offset → line/column lookup. */
+export class SourceFile {
+    name;
+    text;
+    /** Offset at which each line starts. */
+    lineStarts = [0];
+    constructor(name, text) {
+        this.name = name;
+        this.text = text;
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] === '\n')
+                this.lineStarts.push(i + 1);
+        }
+    }
+    /** 1-based line and column of a character offset. */
+    position(offset) {
+        let low = 0;
+        let high = this.lineStarts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if (this.lineStarts[mid] <= offset)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return { line: low + 1, column: offset - this.lineStarts[low] + 1 };
+    }
+    /** Text of a 1-based line, without the line break. */
+    lineText(line) {
+        const start = this.lineStarts[line - 1] ?? this.text.length;
+        const end = this.lineStarts[line] ?? this.text.length;
+        return this.text.slice(start, end).replace(/\r?\n$/, '');
+    }
+}

package/dist/style-modules.d.ts

@@ -0,0 +1,17 @@
+import type * as ast from './ast.ts';
+export interface StyleModule {
+    /** The hash of the CSS: the suffix of its classes and the id of its `<style>`. */
+    id: string;
+    /** Its classes, in the order they are written, and the names they get. */
+    classes: Map<string, string>;
+    css: string;
+    problems: string[];
+}
+/** Whether an import is of a CSS module. */
+export declare function isStyleModule(specifier: string): boolean;
+export declare function styleModule(text: string): StyleModule;
+/**
+ * The classes of a CSS module that the program never names: `styles.button` and
+ * `styles["is-active"]` name one. Any other use, e.g. `styles[kind]`, may name each of them.
+ */
+export declare function unusedClasses(program: ast.Program, local: string, module: StyleModule): string[];

package/dist/style-modules.js

@@ -0,0 +1,49 @@
+import { hash } from "./css/hash.js";
+import { parseCss } from "./css/parse.js";
+import { printCss, valueText } from "./css/print.js";
+import { renameClasses } from "./css/selectors.js";
+import { forEachChild } from "./walk.js";
+/** Whether an import is of a CSS module. */
+export function isStyleModule(specifier) {
+    return specifier.endsWith('.module.css');
+}
+export function styleModule(text) {
+    const id = hash(text);
+    const sheet = parseCss(text);
+    const classes = new Map();
+    const css = printCss(sheet.nodes, {
+        selector: (selector) => renameClasses(selector, (name) => `${name}_${id}`, (name) => classes.set(name, `${name}_${id}`)),
+        value: (declaration) => valueText(declaration, () => ''),
+    });
+    return { id, classes, css, problems: sheet.problems.map((problem) => problem.message) };
+}
+/**
+ * The classes of a CSS module that the program never names: `styles.button` and
+ * `styles["is-active"]` name one. Any other use, e.g. `styles[kind]`, may name each of them.
+ */
+export function unusedClasses(program, local, module) {
+    const used = new Set();
+    let dynamic = false;
+    const visit = (node) => {
+        if (node.kind === 'MemberExpression' && isLocal(node.object)) {
+            used.add(node.property.name);
+            return;
+        }
+        if (node.kind === 'IndexExpression' && isLocal(node.object)) {
+            if (node.index.kind === 'StringLiteral')
+                used.add(node.index.value);
+            else
+                dynamic = true;
+            return;
+        }
+        if (isLocal(node))
+            dynamic = true;
+        forEachChild(node, visit);
+    };
+    const isLocal = (node) => node.kind === 'Identifier' && node.name === local;
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration')
+            visit(statement);
+    }
+    return dynamic ? [] : [...module.classes.keys()].filter((name) => !used.has(name));
+}

package/dist/styles.d.ts

@@ -0,0 +1,36 @@
+import type * as ast from './ast.ts';
+import { type CssDeclaration, type CssNode, type CssProblem } from './css/parse.ts';
+export interface ComponentStyle {
+    /** `rook-product-card-1x9k2az`: the class of the elements of the component's own markup. */
+    scope: string;
+    nodes: CssNode[];
+    /** Problems of the CSS, with offsets in the source of the module. */
+    problems: CssProblem[];
+    /** The values from code, in the order they are numbered in the declarations. */
+    values: ast.Expression[];
+    /** Declarations with values from code and the CSS variables they become. */
+    variables: Map<CssDeclaration, string>;
+    /** The offset in the source of an offset in the parsed text. */
+    sourceOffset: (offset: number) => number;
+}
+/** The `style` blocks at the top level of the body of a component or a decorator. */
+export declare function styleBlocks(body: ast.BlockStatement): ast.StyleStatement[];
+/** The style of a component or a decorator, or null if it has no `style` block. */
+export declare function componentStyle(name: string, body: ast.BlockStatement): ComponentStyle | null;
+/** The CSS of a style: the class of the component in the selectors, variables for the values. */
+export declare function scopedCss(style: ComponentStyle): string;
+/** `ProductCard` → `product-card`. */
+export declare function kebabCase(name: string): string;
+/** Whether an element has a `class` attribute. */
+export declare function hasClass(node: ast.ElementExpression): boolean;
+/** The elements of the markup of a body: those that get the class of its style. */
+export declare function ownElements(body: ast.Node): ast.ElementExpression[];
+/**
+ * Selectors of a style that no element of the markup of `body` can match: with a tag, a class or
+ * an id that none of them has. Elements with `class={...}` may have any class.
+ */
+export declare function unmatchedSelectors(style: ComponentStyle, body: ast.Node): {
+    selector: string;
+    start: number;
+    end: number;
+}[];

package/dist/styles.js

@@ -0,0 +1,160 @@
+import { hash } from "./css/hash.js";
+import { parseCss, SLOT } from "./css/parse.js";
+import { holdsRules } from "./css/parse.js";
+import { printCss, valueText } from "./css/print.js";
+import { requirements, scopeSelector, splitComplex, splitList } from "./css/selectors.js";
+import { forEachChild } from "./walk.js";
+/** The `style` blocks at the top level of the body of a component or a decorator. */
+export function styleBlocks(body) {
+    return body.body.filter((statement) => statement.kind === 'StyleStatement');
+}
+/** The style of a component or a decorator, or null if it has no `style` block. */
+export function componentStyle(name, body) {
+    const blocks = styleBlocks(body);
+    if (blocks.length === 0)
+        return null;
+    // The blocks as one text, values from code as SLOT; `segments` map it back to the source.
+    let text = '';
+    const segments = [];
+    const values = [];
+    for (const block of blocks) {
+        for (const part of block.parts) {
+            segments.push({ at: text.length, offset: part.start });
+            if (part.kind === 'CssText') {
+                text += part.value;
+            }
+            else {
+                text += SLOT;
+                values.push(part);
+            }
+        }
+        text += '\n';
+    }
+    const sourceOffset = (offset) => {
+        const segment = segments.findLast((each) => each.at <= offset) ?? { at: 0, offset: 0 };
+        return segment.offset + offset - segment.at;
+    };
+    const scope = `rook-${kebabCase(name)}-${hash(text)}`;
+    const sheet = parseCss(text);
+    const variables = new Map();
+    visitDeclarations(sheet.nodes, (declaration) => {
+        if (declaration.value.some((part) => typeof part === 'number')) {
+            variables.set(declaration, `--${scope}-${variables.size}`);
+        }
+    });
+    return {
+        scope,
+        nodes: sheet.nodes,
+        problems: sheet.problems.map((problem) => ({
+            message: problem.message,
+            start: sourceOffset(problem.start),
+            end: sourceOffset(problem.end),
+        })),
+        values,
+        variables,
+        sourceOffset,
+    };
+}
+/** The CSS of a style: the class of the component in the selectors, variables for the values. */
+export function scopedCss(style) {
+    return printCss(style.nodes, {
+        selector: (selector) => scopeSelector(selector, style.scope),
+        value: (declaration) => {
+            const variable = style.variables.get(declaration);
+            return variable ? `var(${variable})` : valueText(declaration, () => '');
+        },
+    });
+}
+/** `ProductCard` → `product-card`. */
+export function kebabCase(name) {
+    return name
+        .replace(/[^\w-]/g, '')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase();
+}
+function visitDeclarations(nodes, visit) {
+    for (const node of nodes) {
+        if (node.kind === 'declaration')
+            visit(node);
+        else if (node.body)
+            visitDeclarations(node.body, visit);
+    }
+}
+/** Whether an element has a `class` attribute. */
+export function hasClass(node) {
+    return node.attributes.some((attribute) => attribute.kind === 'JsxAttribute' && attribute.name.name === 'class');
+}
+/** The elements of the markup of a body: those that get the class of its style. */
+export function ownElements(body) {
+    const found = [];
+    const visit = (node) => {
+        // The use of a component is not an element, but what is passed to it is the markup here.
+        if (node.kind === 'ElementExpression' &&
+            node.tag &&
+            node.value === null &&
+            !/^[A-Z]/.test(node.tag.name)) {
+            found.push(node);
+        }
+        forEachChild(node, visit);
+    };
+    visit(body);
+    return found;
+}
+function describe(node) {
+    let classes = new Set();
+    let id = null;
+    for (const attribute of node.attributes) {
+        if (attribute.kind === 'JsxSpreadAttribute') {
+            classes = null;
+            id = undefined;
+            continue;
+        }
+        const { name, value } = attribute;
+        const text = value?.kind === 'StringLiteral' ? value.value : undefined;
+        if (name.name === 'class' && classes !== null) {
+            classes = text === undefined ? null : new Set(text.split(/\s+/).filter(Boolean));
+        }
+        else if (name.name === 'id') {
+            id = text;
+        }
+    }
+    return { tag: node.tag.name.toLowerCase(), classes, id };
+}
+/**
+ * Selectors of a style that no element of the markup of `body` can match: with a tag, a class or
+ * an id that none of them has. Elements with `class={...}` may have any class.
+ */
+export function unmatchedSelectors(style, body) {
+    const elements = ownElements(body).map(describe);
+    const found = [];
+    const matches = (compound) => {
+        if (compound === '' || compound.includes('&') || compound.includes(':global('))
+            return true;
+        const { tag, classes, ids } = requirements(compound);
+        return elements.some((element) => (tag === null || tag.toLowerCase() === element.tag) &&
+            (element.classes === null || classes.every((name) => element.classes.has(name))) &&
+            (element.id === undefined || ids.every((id) => id === element.id)));
+    };
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === 'rule') {
+                for (const complex of splitList(node.selector)) {
+                    const compounds = splitComplex(complex).filter((_, i) => i % 2 === 0);
+                    if (!compounds.every(matches)) {
+                        found.push({
+                            selector: complex,
+                            start: style.sourceOffset(node.start),
+                            end: style.sourceOffset(node.end),
+                        });
+                    }
+                }
+                visit(node.body);
+            }
+            else if (node.kind === 'at-rule' && node.body && holdsRules(node)) {
+                visit(node.body);
+            }
+        }
+    };
+    visit(style.nodes);
+    return found;
+}

package/dist/svg.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from './ast.ts';
+export declare const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+/** Whether `<tag>` is an SVG element, inside `<svg>` or not. */
+export declare function isSvgElement(tag: string, inSvg: boolean): boolean;
+/** Whether the children of an element are inside SVG: those of `<foreignObject>` are HTML. */
+export declare function childrenInSvg(tag: string | null, svg: boolean, inSvg: boolean): boolean;
+/** The SVG elements of the markup in `root`, for code that creates them out of their place. */
+export declare function svgElements(root: ast.Node): Set<ast.ElementExpression>;

package/dist/svg.js

@@ -0,0 +1,77 @@
+import { forEachChild } from "./walk.js";
+// SVG in markup. An element is created in the SVG namespace when it is `<svg>`, inside one, or a
+// tag that only SVG has: so a component can return `<path>` to be put into an `<svg>`. The
+// children of `<foreignObject>` are HTML again. Tags that both have (`a`, `title`, `style`,
+// `script`) are SVG only inside `<svg>`.
+export const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+const SVG_ONLY = new Set([
+    'animate',
+    'animateMotion',
+    'animateTransform',
+    'circle',
+    'clipPath',
+    'defs',
+    'desc',
+    'ellipse',
+    'feBlend',
+    'feColorMatrix',
+    'feComposite',
+    'feDropShadow',
+    'feFlood',
+    'feGaussianBlur',
+    'feMerge',
+    'feMergeNode',
+    'feOffset',
+    'filter',
+    'foreignObject',
+    'g',
+    'image',
+    'line',
+    'linearGradient',
+    'marker',
+    'mask',
+    'metadata',
+    'path',
+    'pattern',
+    'polygon',
+    'polyline',
+    'radialGradient',
+    'rect',
+    'stop',
+    'symbol',
+    'text',
+    'textPath',
+    'tspan',
+    'use',
+    'view',
+]);
+/** Whether `<tag>` is an SVG element, inside `<svg>` or not. */
+export function isSvgElement(tag, inSvg) {
+    return tag === 'svg' || SVG_ONLY.has(tag) || (inSvg && !tag.includes('-'));
+}
+/** Whether the children of an element are inside SVG: those of `<foreignObject>` are HTML. */
+export function childrenInSvg(tag, svg, inSvg) {
+    return tag === null ? inSvg : svg && tag !== 'foreignObject';
+}
+/** The SVG elements of the markup in `root`, for code that creates them out of their place. */
+export function svgElements(root) {
+    const found = new Set();
+    const visit = (node, inSvg) => {
+        if (node.kind !== 'ElementExpression' ||
+            node.value !== null ||
+            (node.tag && /^[A-Z]/.test(node.tag.name))) {
+            forEachChild(node, (child) => visit(child, inSvg));
+            return;
+        }
+        const tag = node.tag?.name ?? null;
+        const svg = tag !== null && isSvgElement(tag, inSvg);
+        if (svg)
+            found.add(node);
+        for (const attribute of node.attributes)
+            visit(attribute, inSvg);
+        for (const child of node.children)
+            visit(child, childrenInSvg(tag, svg, inSvg));
+    };
+    visit(root, false);
+    return found;
+}

package/dist/ts-types.d.ts

@@ -0,0 +1,11 @@
+import { type FunctionType, type Type } from './checker/types.ts';
+/** A nullable property may be left out of an object: `name?: string | null`. */
+export declare function property(name: string, type: Type): string;
+export declare function resultType(results: readonly Type[]): string;
+/**
+ * A type in TypeScript syntax. A union keeps the name of its alias, except in the alias itself
+ * (`expand`).
+ */
+export declare function tsType(type: Type, expand?: boolean): string;
+/** What calling an iterator gives: a generator of what its `yield` takes, a value or a pair. */
+export declare function generatorType(iterator: FunctionType): string;

package/dist/ts-types.js

@@ -0,0 +1,133 @@
+import { CONTENT } from "./checker/dom.js";
+import { ERROR_CLASS, memberNames, } from "./checker/types.js";
+// Types of the checker in TypeScript syntax, for declaration files (declarations.ts).
+/** A nullable property may be left out of an object: `name?: string | null`. */
+export function property(name, type) {
+    const optional = type.kind === 'nullable' || type.kind === 'null' ? '?' : '';
+    return `${name}${optional}: ${tsType(type)};`;
+}
+export function resultType(results) {
+    if (results.length === 0)
+        return 'void';
+    if (results.length === 1)
+        return tsType(results[0]);
+    return `[${results.map((result) => tsType(result)).join(', ')}]`;
+}
+/**
+ * A type in TypeScript syntax. A union keeps the name of its alias, except in the alias itself
+ * (`expand`).
+ */
+export function tsType(type, expand = false) {
+    switch (type.kind) {
+        case 'number':
+        case 'bigint':
+        case 'string':
+        case 'any':
+        case 'void':
+        case 'null':
+        case 'never':
+        case 'unknown':
+            return type.kind;
+        case 'bool':
+            return 'boolean';
+        case 'literal':
+            return typeof type.value === 'string' ? JSON.stringify(type.value) : String(type.value);
+        case 'nullable':
+            return `${grouped(type.type)} | null`;
+        case 'union':
+            if (type.name !== undefined && !expand)
+                return type.name;
+            return type.types.map(grouped).join(' | ');
+        case 'array':
+            return `${element(type.element)}[]`;
+        case 'tuple':
+            return `[${type.types.map((each) => tsType(each)).join(', ')}]`;
+        case 'function':
+            return functionType(type);
+        // The function of the component: it returns the node and a function that sets the properties.
+        case 'component': {
+            const params = type.params.map((param) => `${param.name}${param.optional ? '?' : ''}: ${tsType(param.type)}`);
+            return `(${params.join(', ')}) => [Node, ...unknown[]]`;
+        }
+        case 'object':
+            return objectType(type);
+        case 'class': {
+            if (type.info === ERROR_CLASS)
+                return 'Error';
+            const args = type.args ? `<${type.args.map((arg) => tsType(arg)).join(', ')}>` : '';
+            return `${type.info.name}${args}`;
+        }
+        case 'classValue':
+            return `typeof ${type.info.name}`;
+        case 'param':
+            return type.name;
+    }
+}
+function functionType(type) {
+    if (type.iterator)
+        return `() => ${generatorType(type)}`;
+    return `(${anonymousParameters(type)}) => ${resultType(type.results)}`;
+}
+/** What calling an iterator gives: a generator of what its `yield` takes, a value or a pair. */
+export function generatorType(iterator) {
+    const yieldType = iterator.params[0];
+    const taken = yieldType?.kind === 'function' ? yieldType.params : [];
+    const yielded = taken.length === 1 ? tsType(taken[0]) : `[${taken.map((each) => tsType(each)).join(', ')}]`;
+    return `Generator<${yielded}, void, unknown>`;
+}
+/** A method of an object type: `name(arg1: number): string`. */
+function methodType(name, type) {
+    return `${name}(${anonymousParameters(type)}): ${resultType(type.results)};`;
+}
+/** Parameters of a function type, which has no names for them. */
+function anonymousParameters(type) {
+    const params = type.params.map((param, i) => `arg${i + 1}${i < type.required ? '' : '?'}: ${tsType(param)}`);
+    if (type.rest)
+        params.push(`...rest: ${element(type.rest)}[]`);
+    return params.join(', ');
+}
+function objectType(type) {
+    // The children of a component are a fragment at runtime.
+    if (type === CONTENT)
+        return 'Node';
+    // A channel is an object with its id; TypeScript code only passes it on.
+    if (type.name === 'chan' || type.name === 'chan<-' || type.name === '<-chan') {
+        return `{ readonly $$chan: string }`;
+    }
+    if (type.name !== null) {
+        const args = type.instanceOf?.args ?? type.typeParams;
+        return args ? `${type.name}<${args.map((arg) => tsType(arg)).join(', ')}>` : type.name;
+    }
+    const members = [...memberNames(type.members)].map((name) => {
+        const member = type.members.get(name);
+        if (!member)
+            return '';
+        if (member.method && member.type.kind === 'function')
+            return methodType(name, member.type);
+        return property(name, member.type);
+    });
+    if (type.call)
+        members.push(methodType('', type.call));
+    if (type.index)
+        members.unshift(`[key: string]: ${tsType(type.index)};`);
+    return members.length === 0 ? '{}' : `{ ${members.filter(Boolean).join(' ')} }`;
+}
+/** Parentheses around unions and functions inside `| null`: `(string | number) | null`. */
+function grouped(type) {
+    const text = tsType(type);
+    return type.kind === 'function' ||
+        type.kind === 'component' ||
+        (type.kind === 'union' && type.name === undefined)
+        ? `(${text})`
+        : text;
+}
+/** An element type before `[]`: `(string | null)[]`. */
+function element(type) {
+    const text = tsType(type);
+    return type.kind === 'function' ||
+        type.kind === 'component' ||
+        type.kind === 'nullable' ||
+        (type.kind === 'union' && type.name === undefined)
+        ? `(${text})`
+        : text;
+}

package/dist/typed-arrays.d.ts

@@ -0,0 +1,8 @@
+/** The typed array of each element type of Go. */
+export declare const TYPED_ELEMENTS: ReadonlyMap<string, string>;
+/** The typed arrays, by the size of an element in bytes. */
+export declare const TYPED_ARRAYS: ReadonlyMap<string, number>;
+/** Whether the elements of a typed array are bigints. */
+export declare function holdsBigInts(name: string): boolean;
+/** How a typed array is written: `[]float64`, or its own name if Go has none (Uint8ClampedArray). */
+export declare function typedArrayName(name: string): string;

package/dist/typed-arrays.js

@@ -0,0 +1,43 @@
+// Typed arrays, written as slices of Go: `[]float64` is a Float64Array, as `[]byte` is a
+// Uint8Array. The names of the elements are numbers, and bigints for the integers of 64 bits.
+/** The typed array of each element type of Go. */
+export const TYPED_ELEMENTS = new Map([
+    ['byte', 'Uint8Array'],
+    ['uint8', 'Uint8Array'],
+    ['int8', 'Int8Array'],
+    ['int16', 'Int16Array'],
+    ['uint16', 'Uint16Array'],
+    ['int32', 'Int32Array'],
+    ['uint32', 'Uint32Array'],
+    ['float32', 'Float32Array'],
+    ['float64', 'Float64Array'],
+    ['int64', 'BigInt64Array'],
+    ['uint64', 'BigUint64Array'],
+]);
+/** The typed arrays, by the size of an element in bytes. */
+export const TYPED_ARRAYS = new Map([
+    ['Int8Array', 1],
+    ['Uint8Array', 1],
+    ['Uint8ClampedArray', 1],
+    ['Int16Array', 2],
+    ['Uint16Array', 2],
+    ['Int32Array', 4],
+    ['Uint32Array', 4],
+    ['Float32Array', 4],
+    ['Float64Array', 8],
+    ['BigInt64Array', 8],
+    ['BigUint64Array', 8],
+]);
+/** Whether the elements of a typed array are bigints. */
+export function holdsBigInts(name) {
+    return name === 'BigInt64Array' || name === 'BigUint64Array';
+}
+/** How a typed array is written: `[]float64`, or its own name if Go has none (Uint8ClampedArray). */
+export function typedArrayName(name) {
+    if (name === 'Uint8Array')
+        return '[]byte';
+    for (const [element, array] of TYPED_ELEMENTS)
+        if (array === name)
+            return `[]${element}`;
+    return name;
+}

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

@@ -0,0 +1,42 @@
+import { type ClassInfo, type ObjectType, type Type, type TypeParam } from '../checker/types.ts';
+import type * as TS from 'typescript';
+/**
+ * Types of declarations in TypeScript's lib files and in `node_modules`, by file and name. These
+ * files do not change while the compiler runs, so the converters of later programs (a program is
+ * created again when an import adds a file) reuse the types of the first one. Otherwise the same
+ * `Node` of lib.dom would be two different types, and checking that one fits the other would go
+ * through the whole DOM.
+ */
+export type SharedTypes = Map<string, Type | ClassInfo>;
+export declare abstract class ConverterBase {
+    protected abstract object(type: TS.Type, name: string | null, typeParams?: TypeParam[]): ObjectType;
+    protected abstract objectType(type: TS.ObjectType): Type;
+    protected readonly ts: typeof TS;
+    protected readonly program: TS.Program;
+    protected readonly checker: TS.TypeChecker;
+    protected readonly types: Map<TS.Type, Type>;
+    /** Types being converted: a function type that refers to itself becomes `any` inside. */
+    protected readonly converting: Set<TS.Type>;
+    protected readonly params: Map<TS.Type, TypeParam>;
+    protected readonly classes: Map<TS.Symbol, ClassInfo>;
+    protected readonly shared: SharedTypes;
+    protected arrayInterface: ObjectType | undefined;
+    constructor(ts: typeof TS, program: TS.Program, shared?: SharedTypes);
+    /** The key of a declaration that does not change between programs, or `null`. */
+    protected sharedKey(symbol: TS.Symbol, kind: string): string | null;
+    convert(type: TS.Type): Type;
+    protected convertType(type: TS.Type): Type;
+    /** `undefined`, `null` and `void` in a union make it nullable: `string | undefined` is `?string`. */
+    protected union(types: readonly TS.Type[]): Type;
+    protected typeParamOrThis(type: TS.Type): 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>`.
+     */
+    protected typeParam(type: TS.Type): TypeParam;
+    /** Declared in TypeScript's lib files. */
+    protected isLibrary(symbol: TS.Symbol): boolean;
+}
+/** Members that Rook code can name: not `[Symbol.iterator]` and the like. */
+export declare function propertyNames(checker: TS.TypeChecker, type: TS.Type): string[];