rooklang 0.0.0-stage → 0.3.1

package/dist/codegen/refs.js

@@ -0,0 +1,160 @@
+import { attrsParam } from "../attrs.js";
+import { mentionsName } from "../names.js";
+import { componentRoot, constantAttributes, isComponentUse, ownRoot, refName, refTargets, } from "../refs.js";
+import { hasClass } from "../styles.js";
+import { isSvgElement, svgElements } from "../svg.js";
+import { forEachChild } from "../walk.js";
+import { EarlyReturnEmitter } from "./early-returns.js";
+export class RefEmitter extends EarlyReturnEmitter {
+    /** The elements that the refs of the component being written are bound to. */
+    refElements = new Map();
+    /** Those of them that are SVG elements. */
+    svgTargets = new Set();
+    rootPreset = null;
+    /** Tags of components that refs point to or that are at the top of components: lazily. */
+    rootTags = null;
+    /** Writes the code of a component: its refs, and the element at its top if a ref created it. */
+    withRefs(component, preset, emit) {
+        const saved = {
+            refElements: this.refElements,
+            svgTargets: this.svgTargets,
+            rootPreset: this.rootPreset,
+            inSvg: this.inSvg,
+            attrsParam: this.attrsParam,
+        };
+        this.refElements = refTargets(component.body);
+        this.svgTargets = this.refElements.size > 0 ? svgElements(component.body) : new Set();
+        this.rootPreset = preset;
+        // The markup of a component starts outside <svg>, wherever the component is used.
+        this.inSvg = false;
+        // Its `{...attrs}` applies the attributes it was given.
+        this.attrsParam = attrsParam(component)?.name.name ?? null;
+        try {
+            return emit();
+        }
+        finally {
+            this.refElements = saved.refElements;
+            this.svgTargets = saved.svgTargets;
+            this.rootPreset = saved.rootPreset;
+            this.inSvg = saved.inSvg;
+            this.attrsParam = saved.attrsParam;
+        }
+    }
+    /** `ref input`: `const input = document.createElement("input");` and its constant attributes. */
+    refDeclaration(node) {
+        for (const id of node.names) {
+            const name = this.name(id.name);
+            const target = this.refElements.get(id.name);
+            const preset = target && this.rootPreset?.node === target ? this.rootPreset : null;
+            if (preset?.created) {
+                this.line(`const ${name} = ${preset.name};`);
+                continue;
+            }
+            const element = target ? this.elementOf(target) : null;
+            // Only without the checker: it reports a ref that points to no element.
+            if (!element?.tag) {
+                this.line(`const ${name} = null;`);
+                continue;
+            }
+            const tag = element.tag.name;
+            // The root of another component has no <svg> above it in its own markup.
+            const svg = element === target ? this.svgTargets.has(target) : isSvgElement(tag, false);
+            const scope = this.scopeOf(element);
+            const constants = constantAttributes(element);
+            // The class of the style is constant too, when the element has no class of its own.
+            const scopeClass = scope && !hasClass(element) ? scope : null;
+            let creation = { covered: new Set(), scoped: false };
+            if (preset) {
+                this.createdElements++;
+                this.line(`const ${name} = ${preset.name} ?? ${this.createElement(tag, svg)};`);
+            }
+            else {
+                creation = this.createWith(`const ${name}`, name, tag, svg, constants, null, scope, scopeClass);
+            }
+            for (const attribute of constants) {
+                if (!creation.covered.has(attribute))
+                    this.attribute(name, tag, attribute, null, svg, scope);
+            }
+            if (scopeClass !== null && !creation.scoped)
+                this.scopeClass(name, scopeClass, svg);
+        }
+    }
+    /**
+     * The element that markup fills in instead of creating one: that of its ref, which has its
+     * constant attributes already, or the one a ref to the component created.
+     */
+    presetElement(node) {
+        const ref = refName(node);
+        if (ref !== null)
+            return { name: this.name(ref), created: true };
+        const preset = this.rootPreset;
+        return preset?.node === node && node.tag !== null ? preset : null;
+    }
+    /**
+     * What a use of a component gives it as the element at its top: the element of a ref on the use,
+     * or the one given to the component being written, when the use is at its top.
+     */
+    rootFor(use) {
+        const ref = refName(use);
+        if (ref !== null)
+            return { name: this.name(ref), created: true };
+        const preset = this.rootPreset;
+        return preset?.node === use ? { name: preset.name, created: preset.created } : null;
+    }
+    /** The preset of an inlined component, whose names may hide the variable with the element. */
+    inlineRoot(component, given) {
+        const own = ownRoot(component);
+        if (!given || typeof own === 'string')
+            return null;
+        let { name } = given;
+        if (!name.startsWith('$$') && mentionsName(component, new Set([name.replace(/\$$/, '')]))) {
+            name = `$$root${this.nextId()}`;
+            this.line(`const ${name} = ${given.name};`);
+        }
+        return { node: own, name, created: given.created };
+    }
+    /**
+     * Whether the function of a component takes `$$root`: when the element at its top is known, and
+     * a ref may point to it, here or in another module, or a component that does returns it.
+     */
+    takesRoot(component) {
+        if (typeof this.componentRootOf(component, new Set()) === 'string')
+            return false;
+        this.rootTags ??= this.findRootTags();
+        return component.exported || this.rootTags.has(component.name.name);
+    }
+    findRootTags() {
+        const tags = new Set();
+        const visit = (node) => {
+            if (node.kind === 'ElementExpression' && isComponentUse(node) && refName(node) !== null) {
+                tags.add(node.tag.name);
+            }
+            forEachChild(node, visit);
+        };
+        visit(this.program);
+        for (const component of this.components.values()) {
+            const own = ownRoot(component);
+            if (typeof own !== 'string' && isComponentUse(own))
+                tags.add(own.tag.name);
+        }
+        return tags;
+    }
+    /** The element that markup creates: itself, or the one at the top of the component it uses. */
+    elementOf(node) {
+        if (!isComponentUse(node))
+            return node;
+        const component = this.components.get(node.tag.name);
+        const root = component ? this.componentRootOf(component, new Set()) : null;
+        return typeof root === 'string' ? null : root;
+    }
+    componentRootOf(component, seen) {
+        const imported = this.importedRoots.get(component);
+        if (imported !== undefined)
+            return imported;
+        seen.add(component);
+        return componentRoot(component, (tag) => {
+            const other = this.components.get(tag);
+            return other && !seen.has(other) ? this.componentRootOf(other, seen) : undefined;
+        });
+    }
+}

package/dist/codegen/select-helpers.d.ts

@@ -0,0 +1,2 @@
+export type SelectHelper = 'select';
+export declare const SELECT_HELPERS: Readonly<Record<SelectHelper, readonly string[]>>;

package/dist/codegen/select-helpers.js

@@ -0,0 +1,135 @@
+// `select`. Its cases may wait in channels of several threads; a channel that can go on with a case
+// asks the thread of the select to lock it first, so that only one case goes on, as Go locks the
+// channels of a select.
+export const SELECT_HELPERS = {
+    select: [
+        '// `select`: the index of the case that went on, and what it received. A case is { channel } to',
+        '// receive or { channel, value } to send; from another thread, { channel, send, value }. One that',
+        '// can go on at once wins, a random one as in Go; else `default`, -1, if there is one; else the',
+        '// first that can go on later. A case with a null channel never goes on.',
+        'async function $$select(cases, hasDefault) {',
+        '  const registry = $$registry();',
+        '  const all = cases.map((each, i) => ({',
+        '    i,',
+        '    id: typeof each.channel === "string" ? each.channel : (each.channel?.$$chan ?? null),',
+        '    send: each.send ?? "value" in each,',
+        '    value: each.value,',
+        '  }));',
+        '  const live = all.filter(({ id }) => id !== null);',
+        '  const owners = new Set(live.map(({ id }) => $$ownerOf(id)));',
+        '  // The channels of one other thread: the select runs there.',
+        '  if (owners.size === 1 && !owners.has(registry.key)) {',
+        '    const [owner] = owners;',
+        '    return $$ask(owner, { op: "select", cases: all.map(({ id: channel, send, value }) => ({ channel, send, value })), hasDefault });',
+        '  }',
+        '  const order = live.map(({ i }) => i).sort(() => Math.random() - 0.5);',
+        '  for (const i of order) {',
+        '    const { id, send, value } = all[i];',
+        '    const owner = $$ownerOf(id);',
+        '    const ready =',
+        '      owner === registry.key',
+        '        ? $$try(id, send, value)',
+        '        : await $$ask(owner, { op: "try", channel: id, send, value });',
+        '    if (ready) return [i, ...ready];',
+        '  }',
+        '  if (hasDefault) return [-1];',
+        '  return new Promise((resolve, reject) => {',
+        '    const sid = registry.asks++;',
+        '    const channels = new Map();',
+        '    registry.selects.set(sid, { locked: false, resolve, reject, channels });',
+        '    live.forEach(({ i, id, send, value }) => {',
+        '      const owner = $$ownerOf(id);',
+        '      if (!channels.has(owner)) channels.set(owner, []);',
+        '      channels.get(owner).push(id);',
+        '      if (owner === registry.key) {',
+        '        const entry = { select: { key: owner, sid }, case: i, value };',
+        '        registry.states.get(id)[send ? "senders" : "receivers"].push(entry);',
+        '      } else {',
+        '        $$post(owner, { op: "wait", sid, case: i, channel: id, send, value });',
+        '      }',
+        '    });',
+        '    for (const owner of channels.keys()) if (owner !== registry.key) $$pin(owner, 1);',
+        '    for (const id of channels.get(registry.key) ?? []) $$pump(id);',
+        '  });',
+        '}',
+        '',
+        '// What a case of a select gets at once, if it can go on: [] for a send, [value, ok] for a receive.',
+        '// A receiver or sender that a select of another thread waits with is left to $$pump.',
+        'function $$try(id, send, value) {',
+        '  const state = $$registry().states.get(id);',
+        '  if (!state) throw $$stopped();',
+        '  if (state.busy) return null;',
+        '  if (send && state.closed) throw new Error("send on a closed channel");',
+        '  if (!send && state.buffer.length > 0) {',
+        '    const received = state.buffer.shift();',
+        '    $$pump(id);',
+        '    return [received, true];',
+        '  }',
+        '  const queue = send ? state.receivers : state.senders;',
+        '  while (queue.length > 0) {',
+        '    const [entry] = queue;',
+        '    if (entry.select && entry.select.key !== $$registry().key) break;',
+        '    const lock = entry.select ? $$lock(entry.select.sid) : "locked";',
+        '    if (lock === "busy") break;',
+        '    queue.shift();',
+        '    if (lock === "done") continue;',
+        '    if (!send) {',
+        '      $$finish(entry);',
+        '      return [entry.value, true];',
+        '    }',
+        '    $$finish(entry, [value, true]);',
+        '    return [];',
+        '  }',
+        '  if (send && state.buffer.length < state.size) {',
+        '    state.buffer.push(value);',
+        '    $$pump(id);',
+        '    return [];',
+        '  }',
+        '  return !send && state.closed ? [Array.isArray(state.zero) ? [] : state.zero, false] : null;',
+        '}',
+        '',
+        '// The thread of a select decides which of its cases goes on: a channel locks the select, then',
+        '// commits a case or unlocks it.',
+        'function $$lock(sid) {',
+        '  const select = $$registry().selects.get(sid);',
+        '  if (!select) return "done";',
+        '  if (select.locked) return "busy";',
+        '  select.locked = true;',
+        '  return "locked";',
+        '}',
+        '',
+        'function $$unlock(sid) {',
+        '  const select = $$registry().selects.get(sid);',
+        '  if (select) select.locked = false;',
+        '}',
+        '',
+        'function $$commit(sid, i, result, error) {',
+        '  const registry = $$registry();',
+        '  const select = registry.selects.get(sid);',
+        '  if (!select) return;',
+        '  registry.selects.delete(sid);',
+        '  // The other cases leave the queues of their channels.',
+        '  for (const [owner, channels] of select.channels) {',
+        '    if (owner === registry.key) {',
+        '      $$unwait({ key: owner, sid }, channels);',
+        '    } else {',
+        '      $$post(owner, { op: "cancel", sid, channels });',
+        '      $$pin(owner, -1);',
+        '    }',
+        '  }',
+        '  if (error) select.reject(error);',
+        '  else select.resolve([i, ...(result ?? [])]);',
+        '}',
+        '',
+        'function $$unwait(select, channels) {',
+        '  const { states } = $$registry();',
+        '  const other = (entry) => entry.select?.key !== select.key || entry.select.sid !== select.sid;',
+        '  for (const id of channels) {',
+        '    const state = states.get(id);',
+        '    if (!state) continue;',
+        '    state.receivers = state.receivers.filter(other);',
+        '    state.senders = state.senders.filter(other);',
+        '  }',
+        '}',
+    ],
+};

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

@@ -0,0 +1,42 @@
+import type * as ast from '../ast.ts';
+import { CallEmitter } from './calls.ts';
+/** Statements: lists and blocks of them, variables, assignments, `return`; the others are in later layers. */
+export declare abstract class SimpleStatementEmitter extends CallEmitter {
+    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 tryStatement(node: ast.TryStatement): string;
+    protected abstract classDeclaration(node: ast.ClassDeclaration): void;
+    protected abstract importDeclaration(node: ast.ImportDeclaration): void;
+    /** Counter for the labels of switches compiled to if/else. */
+    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). */
+    protected abstract mountStatement(node: ast.MountStatement): void;
+    /** `effect { ... }` of a component (see FunctionEmitter). */
+    protected abstract effectStatement(node: ast.EffectStatement): void;
+    /** `const link = <a>...</a>`: creates the element right in the variable; see ElementEmitter. */
+    protected abstract elementDeclaration(declaration: string, node: ast.ElementExpression): void;
+    /** An element in the block of `{if ...}` / `{for ...}` in markup; see ElementEmitter. */
+    protected abstract elementStatement(node: ast.JsxElementStatement): void;
+    /** A recursive component, which becomes a function; see ComponentEmitter. */
+    protected abstract componentFunction(node: ast.ComponentDeclaration): void;
+    protected statements(list: readonly ast.Statement[]): void;
+    /** 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;
+    protected statement(node: ast.Statement): 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;
+    /** Go-style zero value of a type, or `null` for types without one. */
+    protected zeroValue(type: ast.TypeNode, seen?: Set<string>): string | null;
+    /** `a = b`, `a, b = b, a` → `[a, b] = [b, a]`, `q, err = f()` → `[q, err] = f()`. */
+    protected assignment(node: ast.AssignmentStatement): string;
+    /** Several results are returned as an array: `return a, b` → `return [a, b]`. */
+    protected returnStatement(node: ast.ReturnStatement): string;
+}

package/dist/codegen/simple-statements.js

@@ -0,0 +1,253 @@
+import { isIterator } from "../iterators.js";
+import { holdsBigInts, TYPED_ARRAYS, TYPED_ELEMENTS } from "../typed-arrays.js";
+import { declarationsOf } from "./analysis.js";
+import { CallEmitter } from "./calls.js";
+import { ARROW, arrayPattern, POSTFIX } from "./syntax.js";
+/** Statements: lists and blocks of them, variables, assignments, `return`; the others are in later layers. */
+export class SimpleStatementEmitter extends CallEmitter {
+    /** Counter for the labels of switches compiled to if/else. */
+    labels = 0;
+    statements(list) {
+        let previous;
+        for (const statement of list) {
+            // Types, decorators and inlined components exist only at compile time.
+            if (statement.kind === 'InterfaceDeclaration' ||
+                statement.kind === 'TypeAliasDeclaration' ||
+                statement.kind === 'DecoratorDeclaration' ||
+                (statement.kind === 'ComponentDeclaration' &&
+                    !this.functionComponents.has(this.applied(statement)))) {
+                continue;
+            }
+            if (previous && this.blankLineBetween(previous, statement))
+                this.blankLine();
+            this.statement(statement);
+            previous = statement;
+        }
+    }
+    /** A block's statements in a new scope, without the braces; `then` writes more code in it. */
+    blockStatements(statements, then) {
+        this.withScope(declarationsOf(statements), () => {
+            this.statements(statements);
+            then?.();
+        });
+    }
+    blockStatement(node) {
+        return this.block(() => this.blockStatements(node.body));
+    }
+    statement(node) {
+        this.withHoisting(true, () => this.emitStatement(node));
+    }
+    emitStatement(node) {
+        switch (node.kind) {
+            case 'ImportDeclaration':
+                this.importDeclaration(node);
+                break;
+            case 'FuncDeclaration': {
+                const [params, body] = this.func(node.params, node.body);
+                const exported = node.exported ? 'export ' : '';
+                const async = node.async ? 'async ' : '';
+                const star = isIterator(node.params) ? '*' : '';
+                this.line(`${exported}${async}function${star} ${this.name(node.name.name)}(${params}) ${body}`);
+                break;
+            }
+            case 'VariableDeclaration': {
+                const [name] = node.names;
+                const [value] = node.values;
+                if (node.names.length === 1 && value?.kind === 'ElementExpression' && name?.name !== '_') {
+                    const exported = node.exported ? 'export ' : '';
+                    const keyword = node.keyword === 'state' || node.keyword === 'derived' ? 'let' : node.keyword;
+                    this.elementDeclaration(`${exported}${keyword} ${this.name(name.name)}`, value);
+                    break;
+                }
+                if (node.names.every((name) => name.name === '_') && !node.exported) {
+                    // `const _ = f()` only evaluates the values.
+                    for (const value of node.values)
+                        this.line(`${this.expressionStatement(value)};`);
+                }
+                else {
+                    this.line(`${node.exported ? 'export ' : ''}${this.variableDeclaration(node)};`);
+                }
+                break;
+            }
+            case 'ClassDeclaration':
+                this.classDeclaration(node);
+                break;
+            case 'InterfaceDeclaration':
+            case 'TypeAliasDeclaration':
+            case 'DecoratorDeclaration':
+                break;
+            case 'ComponentDeclaration':
+                this.componentFunction(this.applied(node));
+                break;
+            case 'BlockStatement':
+                this.line(this.blockStatement(node));
+                break;
+            case 'ExpressionStatement':
+                this.line(`${this.expressionStatement(node.expression)};`);
+                break;
+            case 'JsxElementStatement':
+                this.elementStatement(node);
+                break;
+            case 'AssignmentStatement':
+                this.line(`${this.assignment(node)};`);
+                break;
+            case 'IncDecStatement':
+                this.line(`${this.expression(node.target, POSTFIX)}${node.operator};`);
+                break;
+            case 'DeleteStatement':
+                this.line(`delete ${this.expression(node.target, POSTFIX)};`);
+                break;
+            case 'ReturnStatement':
+                this.line(this.returnStatement(node));
+                break;
+            case 'IfStatement': {
+                const yielded = this.yieldStatement(node);
+                this.line(yielded === null ? this.ifStatement(node) : `${yielded};`);
+                break;
+            }
+            case 'ForStatement':
+                this.forStatement(node);
+                break;
+            case 'ForInStatement':
+                this.forInStatement(node);
+                break;
+            case 'SelectStatement':
+                this.selectStatement(node);
+                break;
+            case 'SwitchStatement':
+                if (node.discriminant === null)
+                    this.taglessSwitch(node);
+                else
+                    this.switchStatement(node, node.discriminant);
+                break;
+            case 'BreakStatement': {
+                const label = this.fn.breakTargets.at(-1);
+                this.line(label ? `break ${label};` : 'break;');
+                break;
+            }
+            case 'ContinueStatement':
+                this.line('continue;');
+                break;
+            case 'ThrowStatement':
+                this.line(`throw ${this.expression(node.argument, 0)};`);
+                break;
+            case 'TryStatement':
+                this.line(this.tryStatement(node));
+                break;
+            case 'DeferStatement':
+                this.deferStatement(node);
+                break;
+            // Waits until the channel takes the value.
+            case 'SendStatement': {
+                const channel = this.expression(node.channel, ARROW);
+                this.helpers.add('chan');
+                this.line(`await $$send(${channel}, ${this.expression(node.value, ARROW)});`);
+                break;
+            }
+            case 'MountStatement':
+                this.mountStatement(node);
+                break;
+            case 'EffectStatement':
+                this.effectStatement(node);
+                break;
+            case 'StyleStatement':
+                // Components write their styles themselves (ComponentEmitter).
+                break;
+        }
+    }
+    /** `let a, b = 1, 2` → `let a = 1, b = 2`; `const q, err = f()` → `const [q, err] = f()`. */
+    variableDeclaration(node) {
+        // A state variable is an ordinary variable; updates are added where it changes. A derived one
+        // is computed again by them.
+        const keyword = node.keyword === 'state' || node.keyword === 'derived' ? 'let' : node.keyword;
+        if (node.values.length === 0) {
+            const zero = node.type ? this.zeroValue(node.type) : null;
+            const names = node.names.map((name) => this.name(name.name));
+            return `${keyword} ${names.map((name) => (zero === null ? name : `${name} = ${zero}`)).join(', ')}`;
+        }
+        this.markCommaOk(node.names.length, node.values);
+        const values = node.values.map((value) => this.expression(value, ARROW));
+        const skips = node.names.some((name) => name.name === '_');
+        if (values.length === node.names.length && !skips) {
+            const pairs = node.names.map((name, i) => `${this.name(name.name)} = ${values[i]}`);
+            return `${keyword} ${pairs.join(', ')}`;
+        }
+        const pattern = node.names.map((name) => (name.name === '_' ? '' : this.name(name.name)));
+        const value = values.length === 1 ? values[0] : `[${values.join(', ')}]`;
+        return `${keyword} ${arrayPattern(pattern)} = ${value}`;
+    }
+    /** Go-style zero value of a type, or `null` for types without one. */
+    zeroValue(type, seen = new Set()) {
+        switch (type.kind) {
+            case 'NullableType':
+                return 'null';
+            // `[]byte` is a Uint8Array and `[]float64` a Float64Array, unless the program declares a
+            // type of that name.
+            case 'ArrayType': {
+                const { element } = type;
+                const typed = element.kind === 'TypeReference' && !this.typeAliases.has(element.name.name)
+                    ? TYPED_ELEMENTS.get(element.name.name)
+                    : undefined;
+                return typed === undefined ? '[]' : `new ${typed}()`;
+            }
+            case 'FuncType':
+            case 'ComponentType':
+            case 'ChanType':
+            case 'ObjectType':
+            case 'UnionType':
+            case 'LiteralType':
+                return null;
+            case 'TypeReference': {
+                const name = type.name.name;
+                const alias = this.typeAliases.get(name);
+                if (alias && !seen.has(name))
+                    return this.zeroValue(alias, seen.add(name));
+                if (TYPED_ARRAYS.has(name))
+                    return `new ${name}()`;
+                if (TYPED_ELEMENTS.has(name))
+                    return holdsBigInts(TYPED_ELEMENTS.get(name)) ? '0n' : '0';
+                switch (name) {
+                    case 'number':
+                        return '0';
+                    case 'bigint':
+                        return '0n';
+                    case 'string':
+                        return '""';
+                    case 'bool':
+                        return 'false';
+                    case 'any':
+                    case 'error':
+                        return 'null';
+                    default:
+                        return null;
+                }
+            }
+        }
+    }
+    /** `a = b`, `a, b = b, a` → `[a, b] = [b, a]`, `q, err = f()` → `[q, err] = f()`. */
+    assignment(node) {
+        const isBlank = (target) => target.kind === 'Identifier' && target.name === '_';
+        if (node.targets.every(isBlank)) {
+            // `_ = f()` only evaluates the values.
+            if (node.values.length === 1)
+                return this.expressionStatement(node.values[0]);
+            return `[${node.values.map((value) => this.expression(value, ARROW)).join(', ')}]`;
+        }
+        this.markCommaOk(node.targets.length, node.values);
+        const values = node.values.map((value) => this.expression(value, ARROW));
+        if (node.targets.length === 1) {
+            return `${this.expression(node.targets[0], POSTFIX)} ${node.operator} ${values[0]}`;
+        }
+        const pattern = node.targets.map((target) => isBlank(target) ? '' : this.expression(target, POSTFIX));
+        const value = values.length === 1 ? values[0] : `[${values.join(', ')}]`;
+        return `${arrayPattern(pattern)} = ${value}`;
+    }
+    /** Several results are returned as an array: `return a, b` → `return [a, b]`. */
+    returnStatement(node) {
+        if (node.values.length === 0)
+            return 'return;';
+        if (node.values.length === 1)
+            return `return ${this.expression(node.values[0], 0)};`;
+        return `return [${node.values.map((value) => this.expression(value, ARROW)).join(', ')}];`;
+    }
+}

package/dist/codegen/statements.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import { ParallelLoopEmitter } from './parallel.ts';
+/**
+ * Imports and classes; with the layers below, all statements and declarations. A decorator of
+ * another module is not a value, but its code uses names of its module: the import brings them
+ * under hidden names, `import { $$visible$log } from "./visible.js"`, which that module exports.
+ * So does an inlined component of another module; a called one brings its function, `$$Card`.
+ */
+export declare abstract class StatementEmitter extends ParallelLoopEmitter {
+    /** A CSS module: its object and CSS go with the styles (StyleEmitter), not to an import. */
+    protected abstract styleModuleImport(node: ast.ImportDeclaration): boolean;
+    protected importDeclaration(node: ast.ImportDeclaration): void;
+    /**
+     * `export { log as $$visible$log }`: the names of the module that the code of exported
+     * decorators uses, and that of exported components when other modules inline them.
+     */
+    protected hiddenExports(): void;
+    protected importPath(source: ast.StringLiteral): string;
+    protected classDeclaration(node: ast.ClassDeclaration): void;
+    /** Visibility modifiers are checked by the compiler and do not exist in the output. */
+    protected classMember(member: ast.ClassMember): void;
+}