rooklang 0.3.3 → 0.4.0

package/dist/codegen/mutations.js

@@ -1,4 +1,5 @@
 import { decoratedName } from "../decorators.js";
+import { mayChange } from "../methods.js";
 import { forEachChild } from "../walk.js";
 // What code reads: the names of values, and the variable a change goes into.
 /** The variable at the start of `a.b[i].c()`, or `null`. */
@@ -11,8 +12,6 @@ export function rootName(node) {
             return rootName(node.object);
         case 'CallExpression':
             return rootName(node.callee);
-        case 'DecoratorGet':
-            return rootName(node.target);
         case 'DecoratorMember':
             return decoratedName(node.decorator.name, node.member.name);
         default:
@@ -100,3 +99,45 @@ export function effectReads(node, names) {
             forEachChild(node, (child) => effectReads(child, names));
     }
 }
+/**
+ * What a statement (or an expression body) changes: the targets of assignments, `++` and
+ * `delete`, and the values that a method that may change them is called on, such as `push`.
+ * Nested blocks and functions are not included: their statements are handled on their own.
+ */
+export function writeTargets(node, typeOf) {
+    const found = [];
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'BlockStatement':
+            case 'EventHandler':
+            case 'FuncDeclaration':
+            case 'FuncExpression':
+            case 'ArrowFunction':
+            case 'ClassDeclaration':
+                return;
+            case 'SwitchCase':
+                node.tests.forEach(visit);
+                return;
+            case 'AssignmentStatement':
+                found.push(...node.targets);
+                break;
+            case 'IncDecStatement':
+            case 'DeleteStatement':
+                found.push(node.target);
+                break;
+            case 'CallExpression': {
+                const { callee } = node;
+                if (callee.kind === 'MemberExpression' &&
+                    mayChange(typeOf(callee.object), callee.property.name)) {
+                    found.push(callee.object);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        forEachChild(node, visit);
+    };
+    visit(node);
+    return found;
+}

package/dist/codegen/options.d.ts

@@ -0,0 +1,42 @@
+import type * as ast from '../ast.ts';
+import type { Type } from '../checker/types.ts';
+import type { DecoratorSource } from '../decorators.ts';
+import type { InlinePackage } from '../inline-packages.ts';
+import type { StyleModule } from '../style-modules.ts';
+import type { ImportedComponent } from './imported.ts';
+import type { RuntimeMode } from './runtime.ts';
+export interface JsOptions {
+    /** The Rook source, used to keep the blank lines between statements. */
+    source: string;
+    /** Replace `.rk` with `.js` in relative import paths, for output written next to the sources. */
+    rewriteImports: boolean;
+    /** Types from the checker, when it ran; without them the generated code is more general. */
+    types?: WeakMap<ast.Expression, Type> | undefined;
+    /** Decorators imported from other modules, by name: their code is inlined here. */
+    decorators?: ReadonlyMap<string, ImportedDecorator> | undefined;
+    /** Components imported from other modules, by name: called, or inlined when they are small. */
+    components?: ReadonlyMap<string, ImportedComponent> | undefined;
+    /** Components of the module that become functions, since inlining them adds too many lines. */
+    functions?: ReadonlySet<string> | undefined;
+    /** The CSS modules the module imports, by their paths as written. */
+    styleModules?: ReadonlyMap<string, StyleModule> | undefined;
+    /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
+    goroutines?: {
+        workerUrl: string;
+        nodeLoader?: string | undefined;
+    } | {
+        targets: readonly string[];
+    } | undefined;
+    /** How the module gets the runtime it uses: imported, by default, or in it (runtime.ts). */
+    runtime?: RuntimeMode | undefined;
+    /** The data classes of the module, whose imports stay even if only types use them. */
+    dataClasses?: ReadonlySet<string> | undefined;
+    /** State of other modules that this one imports, `local → name there`: it only reads it. */
+    shared?: ReadonlyMap<string, string> | undefined;
+}
+/** A decorator of another module, with the types of the expressions of that module. */
+export interface ImportedDecorator extends DecoratorSource {
+    types: WeakMap<ast.Expression, Type> | null;
+    /** The components of that module its code uses, which go with it into the components here. */
+    inline: InlinePackage | null;
+}

package/dist/codegen/options.js

@@ -0,0 +1 @@
+export {};

package/dist/codegen/reactive.d.ts

@@ -1,59 +1,8 @@
 import type * as ast from '../ast.ts';
 import type { Type } from '../checker/types.ts';
+import type { Live, Source } from './live.ts';
 import { readNames } from './mutations.ts';
-/** What markup can depend on: a `state` variable, or a property that gets the parent's state. */
-export interface Source {
-    /** Unique in the module; marks the places that change the source in the generated code. */
-    readonly id: number;
-    readonly name: string;
-    readonly kind: 'state' | 'prop';
-    /** The function that brings dependent nodes up to date, e.g. `$$updateCount3`. */
-    readonly update: string;
-    /**
-     * Statements that compute again the `derived` values that read it: `double = count * 2`. They
-     * run first, also before the markup exists, so that the values are right whenever they are read.
-     */
-    readonly computations: string[];
-    /** Statements that bring the nodes depending on it up to date. */
-    readonly dependents: string[];
-    /** Places that change it. */
-    readonly writes: Write[];
-}
-export interface Write {
-    /** Whether it may run before the markup exists: in a function of the body, not in a handler. */
-    early: boolean;
-    /** A dependent it does not need: `bind:` does not update its own element. */
-    skip: number | null;
-}
-/** Everything a change of the source runs: the computations, then the updates of the nodes. */
-export declare function updatesOf(source: Source): string[];
-/**
- * Where the updates of live markup go: the update functions of a component's state, or the update
- * of a block of `{if ...}` / `{for ...}`.
- */
-export interface Live {
-    /** Sources whose values an expression reads. */
-    dependencies(node: ast.Node): Set<Source>;
-    /** Adds a statement that brings a part of the markup up to date when the sources change. */
-    depend(sources: ReadonlySet<Source>, statement: string): void;
-    /** The index that the next statement for a source gets, for `bind:` to skip its own update. */
-    ownIndex(source: Source): number | null;
-}
-/**
- * A block of markup control flow: a branch of `{if ...}` or the content for one item of
- * `{for ...}`. It is created again when needed, so its updates go into a function of its own,
- * which runs when any source that the block reads changes.
- */
-export declare class Block implements Live {
-    readonly statements: string[];
-    /** Sources that any statement depends on. */
-    readonly sources: Set<Source>;
-    private readonly parent;
-    constructor(parent: Live);
-    dependencies(node: ast.Node): Set<Source>;
-    depend(sources: ReadonlySet<Source>, statement: string): void;
-    ownIndex(): null;
-}
+export { Block, type Live, type Source, type Write, updatesOf } from './live.ts';
 /**
  * The reactivity of one inlined component. The analysis goes by names: a local variable that
  * has the name of a state variable can only cause extra updates, never a missed one.
@@ -70,7 +19,7 @@ export declare class Reactive implements Live {
     private readonly functions;
     /** Local functions that the live markup calls: they run while it is created and updated. */
     private readonly renderFunctions;
-    constructor(component: ast.ComponentDeclaration, setup: unknown, props: Iterable<string>, createSource: (name: string, kind: Source['kind']) => Source);
+    constructor(component: ast.ComponentDeclaration, setup: unknown, props: Iterable<string>, createSource: (name: string, kind: Source['kind']) => Source, shared?: ReadonlySet<string>);
     /** Whether a statement of the body declares a function that the live markup calls. */
     declaresRenderFunction(node: ast.Statement): boolean;
     /** Adds a statement that computes a `derived` value again when the sources change. */
@@ -82,11 +31,7 @@ export declare class Reactive implements Live {
      * the names that the node itself reads.
      */
     dependencies(node: ast.Node, read?: typeof readNames): Set<Source>;
-    /**
-     * `state` variables that a statement (or an expression body) changes: by assignment, `++`,
-     * or a method that may change the value, such as `push`. Nested blocks and functions are not
-     * included: their statements are handled on their own.
-     */
+    /** `state` variables that a statement changes, by assignment, `++` or a method like `push`. */
     writtenBy(node: ast.Node, typeOf: (node: ast.Expression) => Type | undefined): Set<Source>;
     /** Sources whose value `node` refers into: `todos`, `todos[i].tags`, `todos.find(...)`. */
     rootSources(node: ast.Expression): ReadonlySet<Source>;

package/dist/codegen/reactive.js

@@ -1,38 +1,11 @@
+import { ownStatements } from "../checker/helpers.js";
 import { wrappedMarkup } from "../decorators.js";
 import { containsReturn, returnedMarkup } from "../recursion.js";
 import { forEachChild } from "../walk.js";
-import { mayChange } from "../methods.js";
-import { readNames, rootName } from "./mutations.js";
+import { readNames, rootName, writeTargets } from "./mutations.js";
+// Reactivity of components: which markup depends on which state, and which code changes it.
+export { Block, updatesOf } from "./live.js";
 const EMPTY = new Set();
-/** Everything a change of the source runs: the computations, then the updates of the nodes. */
-export function updatesOf(source) {
-    return [...source.computations, ...source.dependents];
-}
-/**
- * A block of markup control flow: a branch of `{if ...}` or the content for one item of
- * `{for ...}`. It is created again when needed, so its updates go into a function of its own,
- * which runs when any source that the block reads changes.
- */
-export class Block {
-    statements = [];
-    /** Sources that any statement depends on. */
-    sources = new Set();
-    parent;
-    constructor(parent) {
-        this.parent = parent;
-    }
-    dependencies(node) {
-        return this.parent.dependencies(node);
-    }
-    depend(sources, statement) {
-        this.statements.push(statement);
-        for (const source of sources)
-            this.sources.add(source);
-    }
-    ownIndex() {
-        return null;
-    }
-}
 /**
  * The reactivity of one inlined component. The analysis goes by names: a local variable that
  * has the name of a state variable can only cause extra updates, never a missed one.
@@ -49,10 +22,22 @@ export class Reactive {
     functions = new Map();
     /** Local functions that the live markup calls: they run while it is created and updated. */
     renderFunctions = new Set();
-    constructor(component, setup, props, createSource) {
+    constructor(component, setup, props, createSource, shared = new Set()) {
         this.setup = setup;
+        // State of the module that the component reads; its own names, set after, hide it.
+        const read = new Set();
+        readNames(component, read);
+        for (const name of read) {
+            if (shared.has(name))
+                this.sources.set(name, createSource(name, 'shared'));
+        }
         for (const name of props)
             this.sources.set(name, createSource(name, 'prop'));
+        // A bound property changes as state does, whether the parent sets it or not.
+        for (const param of component.params) {
+            if (param.bind)
+                this.sources.set(param.name.name, createSource(param.name.name, 'state'));
+        }
         // Markup declared after an early return may never be created, so it is not updated.
         let returned = false;
         for (const statement of component.body.body) {
@@ -146,52 +131,15 @@ export class Reactive {
         visit(node, read);
         return found;
     }
-    /**
-     * `state` variables that a statement (or an expression body) changes: by assignment, `++`,
-     * or a method that may change the value, such as `push`. Nested blocks and functions are not
-     * included: their statements are handled on their own.
-     */
+    /** `state` variables that a statement changes, by assignment, `++` or a method like `push`. */
     writtenBy(node, typeOf) {
         const found = new Set();
-        const write = (target) => {
+        for (const target of writeTargets(node, typeOf)) {
             for (const source of this.rootSources(target)) {
                 if (source.kind === 'state')
                     found.add(source);
             }
-        };
-        const visit = (node) => {
-            switch (node.kind) {
-                case 'BlockStatement':
-                case 'EventHandler':
-                case 'FuncDeclaration':
-                case 'FuncExpression':
-                case 'ArrowFunction':
-                case 'ClassDeclaration':
-                    return;
-                case 'SwitchCase':
-                    node.tests.forEach(visit);
-                    return;
-                case 'AssignmentStatement':
-                    node.targets.forEach(write);
-                    break;
-                case 'IncDecStatement':
-                case 'DeleteStatement':
-                    write(node.target);
-                    break;
-                case 'CallExpression': {
-                    const { callee } = node;
-                    if (callee.kind === 'MemberExpression' &&
-                        mayChange(typeOf(callee.object), callee.property.name)) {
-                        write(callee.object);
-                    }
-                    break;
-                }
-                default:
-                    break;
-            }
-            forEachChild(node, visit);
-        };
-        visit(node);
+        }
         return found;
     }
     /** Sources whose value `node` refers into: `todos`, `todos[i].tags`, `todos.find(...)`. */
@@ -241,8 +189,22 @@ export class Reactive {
                     add(node.value.name, this.rootSources(node.iterable));
                     if (node.key && inMarkup)
                         add(node.key.name, this.dependencies(node.iterable));
+                    // With a key, the block of an item may get another object with the same key.
+                    if (node.withKey && inMarkup)
+                        add(node.value.name, this.dependencies(node.iterable));
                     break;
                 case 'VariableDeclaration':
+                    // `derived first { return todos[0] }` points into what it returns.
+                    if (node.body) {
+                        const name = node.names[0].name;
+                        add(name, this.dependencies(node.body));
+                        for (const statement of ownStatements(node.body.body)) {
+                            if (statement.kind !== 'ReturnStatement')
+                                continue;
+                            for (const value of statement.values)
+                                add(name, this.rootSources(value));
+                        }
+                    }
                     node.names.forEach((name, i) => {
                         const value = node.values.length === node.names.length ? node.values[i] : node.values[0];
                         if (!value)

package/dist/codegen/runtime.d.ts

@@ -1,7 +1,11 @@
 /** How a module gets the runtime: by an import, or with the code of the runtime in it. */
 export type RuntimeMode = 'import' | 'inline';
-/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
-export declare const PREDECLARED: ReadonlySet<string>;
+/**
+ * Predeclared names of goroutines and channels, and what they are in JS: `close(ch)` is
+ * `$$Channel.close(ch)`, and `Channel` itself is `$$Channel`, so that the names of a program stay
+ * its own.
+ */
+export declare const PREDECLARED: ReadonlyMap<string, string>;
 /** The names of the runtime that code uses, in order. */
 export declare function runtimeNames(code: string): string[];
 /** What gives a module these names of the runtime: an import, or the files that have them. */
@@ -10,4 +14,4 @@ export declare function runtimeCode(names: readonly string[], mode: RuntimeMode)
  * The `go` of a module: in a module, a call in a worker that starts with its worker module; in the
  * worker module, a call in the same worker, of a function of `$$goroutines`.
  */
-export declare function moduleGo(workerUrl: string | null): string[];
+export declare function moduleGo(workerUrl: string | null, nodeLoader?: string): string[];

package/dist/codegen/runtime.js

@@ -1,13 +1,22 @@
 import { RUNTIME_MODULE } from "../runtime-module.js";
 import { RUNTIME_FILES } from "../runtime/sources.js";
-/** Predeclared functions of goroutines and channels: `close(ch)` is `$$close(ch)`. */
-export const PREDECLARED = new Set([
-    'after',
-    'cancel',
-    'close',
-    'stream',
-    'tick',
-    'transfer',
+/**
+ * Predeclared names of goroutines and channels, and what they are in JS: `close(ch)` is
+ * `$$Channel.close(ch)`, and `Channel` itself is `$$Channel`, so that the names of a program stay
+ * its own.
+ */
+export const PREDECLARED = new Map([
+    ['abortSignal', '$$Channel.abortSignal'],
+    ['after', '$$Channel.after'],
+    ['cancel', '$$cancel'],
+    ['Channel', '$$Channel'],
+    ['close', '$$Channel.close'],
+    ['done', '$$Channel.done'],
+    ['signal', '$$Channel.signal'],
+    ['stream', '$$Channel.stream'],
+    ['tick', '$$Channel.tick'],
+    ['Topic', '$$Topic'],
+    ['transfer', '$$transfer'],
 ]);
 /** A name of generated code, but not a member: `$$chan(...)`, and not `channel.$$chan`. */
 const NAME = /(?<![.\w$])\$\$[A-Za-z_][\w$]*/g;
@@ -50,20 +59,25 @@ export function runtimeCode(names, mode) {
         add(owners.get(name));
     // The files only declare, but for a few that register what a thread shares, so their order does
     // not matter: the one of RUNTIME_FILES.
-    return [...files]
+    const code = [...files]
         .filter(([file]) => needed.has(file))
         .flatMap(([, { code }], i) => [...(i > 0 ? [''] : []), ...code.split('\n')]);
+    const list = names.join(', ');
+    // A function of its own keeps the names of the runtime that are not `$$`, such as check() of
+    // decode, apart from those of the program, which may declare a check() too: only the names that
+    // the code uses come out of it.
+    return [`const { ${list} } = (() => {`, ...code, '', `return { ${list} };`, '})();'];
 }
 /**
  * The `go` of a module: in a module, a call in a worker that starts with its worker module; in the
  * worker module, a call in the same worker, of a function of `$$goroutines`.
  */
-export function moduleGo(workerUrl) {
+export function moduleGo(workerUrl, nodeLoader) {
     if (workerUrl === null) {
         return ['const $$go = (fn, args) => $$goHere($$goroutines, fn, args);'];
     }
     return [
-        ...startWorker(workerUrl),
+        ...startWorker(workerUrl, nodeLoader),
         '',
         'const $$go = (name, args) => $$goWorker($$startWorker, name, args);',
     ];
@@ -72,9 +86,14 @@ export function moduleGo(workerUrl) {
  * The start of a worker of a module: a Web Worker, or a worker thread of Node. Node takes only the
  * path of a `file:` URL, without the query of `app.rk?goroutines`, so its worker starts with a
  * module that imports the whole URL. An absolute URL, such as the Blob of the playground, is used
- * as it is.
+ * as it is. With `nodeLoader`, as under Vitest, the worker of Node imports the loader of `.rk`
+ * files first, since its thread has neither Vite nor the loader of `rook run`.
  */
-function startWorker(url) {
+function startWorker(url, nodeLoader) {
+    // The loader registers its hooks when it runs, so the module comes after it, by a dynamic import.
+    const code = nodeLoader === undefined
+        ? '`import ${JSON.stringify(url.href)};`'
+        : `\`import ${JSON.stringify(nodeLoader)}; await import(\${JSON.stringify(url.href)});\``;
     const base = /^[a-z][a-z\d+.-]*:/i.test(url) ? '' : ', import.meta.url';
     const workerUrl = `new URL(${JSON.stringify(url)}${base})`;
     return [
@@ -86,7 +105,7 @@ function startWorker(url) {
         '  const { Worker: NodeWorker } = await import(/* @vite-ignore */ threads);',
         // Vite bundles the Web Worker; this URL is only for Node.
         `  const url = new URL(/* @vite-ignore */ ${JSON.stringify(url)}${base});`,
-        '  const code = `import ${JSON.stringify(url.href)};`;',
+        `  const code = ${code};`,
         '  return new NodeWorker(new URL(`data:text/javascript,${encodeURIComponent(code)}`));',
         '}',
     ];

package/dist/codegen/shared.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import type { Type } from '../checker/types.ts';
+export interface SharedState {
+    /** The sets of updates by the name of the state here: its own, and those it imports. */
+    readonly listeners: ReadonlyMap<string, string>;
+    /** The states of this module, which only it changes. */
+    readonly own: ReadonlySet<string>;
+    /** Names that refer into the value of a state of this module: `for item in items`. */
+    readonly aliases: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/** The set of updates of a state: `$$listeners$items`, or that of its local name for an import. */
+export declare function listenersName(name: string): string;
+/** The states of the program and those it imports, `local → name in its module`. */
+export declare function sharedState(program: ast.Program, imported: ReadonlyMap<string, string> | undefined): SharedState;
+/**
+ * The states of this module that a statement changes, through them or through names that refer
+ * into them. The analysis goes by names, as that of components: a local variable with the name of
+ * a state only causes an extra run of the updates.
+ */
+export declare function sharedWrites(node: ast.Node, shared: SharedState, typeOf: (node: ast.Expression) => Type | undefined): string[];
+/** The states of this module whose value `node` refers into: `items`, `items[0]`, `item.tags`. */
+export declare function rootsOf(node: ast.Expression, shared: SharedState): ReadonlySet<string>;

package/dist/codegen/shared.js

@@ -0,0 +1,93 @@
+import { forEachChild } from "../walk.js";
+import { rootName, writeTargets } from "./mutations.js";
+/** The set of updates of a state: `$$listeners$items`, or that of its local name for an import. */
+export function listenersName(name) {
+    return `$$listeners$${name}`;
+}
+/** The states of the program and those it imports, `local → name in its module`. */
+export function sharedState(program, imported) {
+    const own = new Set();
+    for (const statement of program.body) {
+        if (statement.kind !== 'VariableDeclaration' || statement.keyword !== 'state')
+            continue;
+        for (const name of statement.names)
+            if (name.name !== '_')
+                own.add(name.name);
+    }
+    const listeners = new Map();
+    for (const name of [...own, ...(imported?.keys() ?? [])])
+        listeners.set(name, listenersName(name));
+    return { listeners, own, aliases: own.size > 0 ? aliasesOf(program, own) : new Map() };
+}
+/**
+ * The states of this module that a statement changes, through them or through names that refer
+ * into them. The analysis goes by names, as that of components: a local variable with the name of
+ * a state only causes an extra run of the updates.
+ */
+export function sharedWrites(node, shared, typeOf) {
+    if (shared.own.size === 0)
+        return [];
+    const found = new Set();
+    for (const target of writeTargets(node, typeOf)) {
+        for (const name of rootsOf(target, shared))
+            found.add(name);
+    }
+    return [...found];
+}
+/** The states of this module whose value `node` refers into: `items`, `items[0]`, `item.tags`. */
+export function rootsOf(node, shared) {
+    const name = rootName(node);
+    if (name === null)
+        return new Set();
+    if (shared.own.has(name))
+        return new Set([name]);
+    return shared.aliases.get(name) ?? new Set();
+}
+/**
+ * Names that refer into the states anywhere in the module: the items of `for item in items`, a
+ * variable given `items[0]`, the parameters of a callback of `items.find(item => ...)`. Repeats
+ * until nothing changes, since an alias of an alias is one too.
+ */
+function aliasesOf(program, own) {
+    const aliases = new Map();
+    const roots = (node) => rootsOf(node, { listeners: new Map(), own, aliases });
+    let changed = true;
+    const add = (name, states) => {
+        if (name === '_' || own.has(name))
+            return;
+        for (const state of states) {
+            const set = aliases.get(name) ?? new Set();
+            if (set.has(state))
+                continue;
+            set.add(state);
+            aliases.set(name, set);
+            changed = true;
+        }
+    };
+    const visit = (node) => {
+        if (node.kind === 'ForInStatement')
+            add(node.value.name, roots(node.iterable));
+        if (node.kind === 'VariableDeclaration' && node.keyword !== 'state') {
+            node.names.forEach((name, i) => {
+                const value = node.values.length === node.names.length ? node.values[i] : node.values[0];
+                if (value)
+                    add(name.name, roots(value));
+            });
+        }
+        if (node.kind === 'CallExpression' && node.callee.kind === 'MemberExpression') {
+            const states = roots(node.callee.object);
+            for (const arg of node.arguments) {
+                if (arg.kind !== 'ArrowFunction' && arg.kind !== 'FuncExpression')
+                    continue;
+                for (const param of arg.params)
+                    add(param.name.name, states);
+            }
+        }
+        forEachChild(node, visit);
+    };
+    while (changed) {
+        changed = false;
+        visit(program);
+    }
+    return aliases;
+}

package/dist/codegen/simple-statements.d.ts

@@ -1,13 +1,12 @@
 import type * as ast from '../ast.ts';
-import { CallEmitter } from './calls.ts';
+import { TryEmitter } from './try.ts';
 /** Statements: lists and blocks of them, variables, assignments, `return`; the others are in later layers. */
-export declare abstract class SimpleStatementEmitter extends CallEmitter {
+export declare abstract class SimpleStatementEmitter extends TryEmitter {
     protected abstract forInStatement(node: ast.ForInStatement): void;
     protected abstract selectStatement(node: ast.SelectStatement): void;
     protected abstract forStatement(node: ast.ForStatement): void;
     protected abstract ifStatement(node: ast.IfStatement): string;
-    protected abstract switchStatement(node: ast.SwitchStatement, discriminant: ast.Expression): void;
-    protected abstract taglessSwitch(node: ast.SwitchStatement): void;
+    protected abstract switchStatement(node: ast.SwitchStatement): void;
     protected abstract tryStatement(node: ast.TryStatement): string;
     protected abstract classDeclaration(node: ast.ClassDeclaration): void;
     protected abstract importDeclaration(node: ast.ImportDeclaration): void;
@@ -15,7 +14,7 @@ export declare abstract class SimpleStatementEmitter extends CallEmitter {
     protected labels: number;
     /** A `defer` inside an if/loop/switch; implemented by FunctionEmitter. */
     protected abstract deferStatement(node: ast.DeferStatement): void;
-    /** `mount() { ... }` of a component (see ComponentEmitter). */
+    /** `mount { ... }` of a component (see FunctionEmitter). */
     protected abstract mountStatement(node: ast.MountStatement): void;
     /** `effect { ... }` of a component (see FunctionEmitter). */
     protected abstract effectStatement(node: ast.EffectStatement): void;
@@ -29,7 +28,14 @@ export declare abstract class SimpleStatementEmitter extends CallEmitter {
     /** A block's statements in a new scope, without the braces; `then` writes more code in it. */
     protected blockStatements(statements: readonly ast.Statement[], then?: () => void): void;
     protected blockStatement(node: ast.BlockStatement): string;
+    /**
+     * The start of the statement being written, which its first line gets as a mark for the source
+     * map (source-map.ts). Imports have none, since the import of the runtime goes among them, and
+     * neither does the code of other modules, whose places are in their own sources.
+     */
+    private sourceMark;
     protected statement(node: ast.Statement): void;
+    protected line(text: string): void;
     protected emitStatement(node: ast.Statement): void;
     /** `let a, b = 1, 2` → `let a = 1, b = 2`; `const q, err = f()` → `const [q, err] = f()`. */
     protected variableDeclaration(node: ast.VariableDeclaration): string;