rooklang 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { build, displayPath } from "./build.js";
+import { CompileError, compileFile } from "./compile-file.js";
+import { markupFor } from "./config.js";
+import { formatDiagnostic } from "./diagnostics.js";
+import { tokenize } from "./lexer/lexer.js";
+import { parse } from "./parser/parser.js";
+import { SourceFile } from "./source.js";
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const HELP = `Rook ${version}
+
+Usage:
+  rook build <file.rk | dir>...   Compile to .js files, with the .rk files they import
+  rook run <file.rk>              Compile and run, with the .rk files it imports
+  rook tokens <file.rk>           Print lexer tokens (for debugging)
+  rook ast <file.rk>              Print the syntax tree (for debugging)
+
+Options:
+      --out-dir <dir>   build: write the .js files to <dir>, keeping the folder structure
+                        (by default they go next to the .rk files)
+      --stdout          build: print the JS of a single file instead of writing files
+      --no-check        Skip type checking
+      --markup          Turn markup and components on; by default they are on where the
+                        package.json has "rook": { "markup": true }
+      --no-markup       Turn them off
+  -h, --help            Show this help
+  -v, --version         Show version`;
+/** A mistake in how the CLI was called. */
+class UsageError extends Error {
+}
+function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            'out-dir': { type: 'string' },
+            stdout: { type: 'boolean' },
+            'no-check': { type: 'boolean' },
+            markup: { type: 'boolean' },
+            'no-markup': { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
+        },
+    });
+    if (values.version) {
+        console.log(version);
+        return;
+    }
+    const [command, ...files] = positionals;
+    if (values.help || !command) {
+        console.log(HELP);
+        return;
+    }
+    if (files.length === 0)
+        throw new UsageError(`missing input file for "${command}"`);
+    for (const path of files) {
+        if (!existsSync(path))
+            throw new UsageError(`file not found: ${path}`);
+    }
+    if (command !== 'build' && files.length > 1) {
+        throw new UsageError(`"${command}" takes a single file`);
+    }
+    const file = files[0];
+    const typeCheck = !values['no-check'];
+    if (values.markup && values['no-markup']) {
+        throw new UsageError('--markup and --no-markup cannot be used together');
+    }
+    // Unless one of them is given, each file takes the setting of its package.json (config.ts).
+    const markup = values.markup ? true : values['no-markup'] ? false : undefined;
+    switch (command) {
+        case 'build':
+            if (values.stdout) {
+                if (files.length > 1 || statSync(file).isDirectory()) {
+                    throw new UsageError('--stdout needs a single .rk file');
+                }
+                process.stdout.write(compileFile(file, { rewriteImports: true, typeCheck, markup }).code);
+            }
+            else {
+                buildFiles(files, { outDir: values['out-dir'], typeCheck, markup });
+            }
+            break;
+        case 'run':
+            process.exitCode = runFile(file, typeCheck, markup);
+            break;
+        case 'tokens':
+            printTokens(new SourceFile(file, readFileSync(file, 'utf8')));
+            break;
+        case 'ast':
+            printAst(new SourceFile(file, readFileSync(file, 'utf8')), markup ?? markupFor(file));
+            break;
+        default:
+            throw new UsageError(`unknown command "${command}"`);
+    }
+}
+/** Builds the files and directories and writes the `.js` files, or none if there are errors. */
+function buildFiles(entries, options) {
+    for (const entry of entries) {
+        if (!statSync(entry).isDirectory() && !entry.endsWith('.rk')) {
+            throw new UsageError(`not a .rk file: ${entry}`);
+        }
+    }
+    const { outputs, errors, warnings } = build(entries, options);
+    for (const { file, diagnostics } of warnings) {
+        for (const warning of diagnostics)
+            console.warn(`${formatDiagnostic(file, warning, 'warning')}\n`);
+    }
+    if (errors.length > 0) {
+        const messages = errors.flatMap(({ file, diagnostics }) => diagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)));
+        throw new CompileError(messages.join('\n\n'));
+    }
+    for (const { source, output, code, declarations, worker } of outputs) {
+        const extra = `${declarations ? ' + .d.ts' : ''}${worker ? ' + .worker.js' : ''}`;
+        mkdirSync(dirname(output), { recursive: true });
+        writeFileSync(output, code);
+        if (declarations)
+            writeFileSync(declarations.output, declarations.code);
+        if (worker)
+            writeFileSync(worker.output, worker.code);
+        console.log(`${displayPath(source)} → ${displayPath(output)}${extra}`);
+    }
+}
+/**
+ * Runs a program in a process of its own that imports loader.ts first: so do the worker threads
+ * of its goroutines, which do not share the hooks of the thread that registers them. They take
+ * the compiled code from a directory of the run, removed after it.
+ */
+function runFile(file, typeCheck, markup) {
+    const loader = new URL('./loader.ts', import.meta.url).href;
+    const run = fileURLToPath(new URL('./run.ts', import.meta.url));
+    const cache = mkdtempSync(join(tmpdir(), 'rook-run-'));
+    try {
+        const { status, signal } = spawnSync(process.execPath, ['--import', loader, run, file], {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ROOK_RUN_CACHE: cache,
+                ...(typeCheck ? {} : { ROOK_NO_CHECK: '1' }),
+                ...(markup === undefined ? {} : { ROOK_MARKUP: markup ? '1' : '0' }),
+            },
+        });
+        return status ?? (signal ? 1 : 0);
+    }
+    finally {
+        rmSync(cache, { recursive: true, force: true });
+    }
+}
+function printTokens(file) {
+    const { tokens, diagnostics } = tokenize(file.text);
+    for (const token of tokens) {
+        const { line, column } = file.position(token.start);
+        const text = token.kind === ';' && token.text === '' ? '(newline)' : JSON.stringify(token.text);
+        console.log(`${line}:${column}`.padEnd(8) + token.kind.padEnd(16) + text);
+    }
+    reportDiagnostics(file, diagnostics);
+}
+function printAst(file, markup) {
+    const { program, diagnostics } = parse(file.text, { markup });
+    // Positions are left out and identifiers printed as plain names to keep the output readable.
+    const compact = (key, value) => {
+        if (key === 'start' || key === 'end' || key === 'raw')
+            return undefined;
+        if (typeof value === 'object' && value !== null && 'kind' in value && 'name' in value) {
+            if (value.kind === 'Identifier')
+                return value.name;
+        }
+        return value;
+    };
+    console.log(JSON.stringify(program, compact, 2));
+    reportDiagnostics(file, diagnostics);
+}
+function reportDiagnostics(file, diagnostics) {
+    for (const diagnostic of diagnostics)
+        console.error(`${formatDiagnostic(file, diagnostic)}\n`);
+    if (diagnostics.length > 0)
+        process.exitCode = 1;
+}
+try {
+    main();
+}
+catch (err) {
+    if (err instanceof CompileError)
+        console.error(err.message);
+    else if (err instanceof UsageError)
+        console.error(`rook: ${err.message}`);
+    else
+        console.error(err);
+    process.exitCode = 1;
+}

package/dist/codegen/analysis.d.ts

@@ -0,0 +1,18 @@
+import type * as ast from '../ast.ts';
+export type BindingKind = 'let' | 'const' | 'state' | 'derived' | 'ref' | 'param' | 'function' | 'class' | 'import' | 'loop' | 'catch';
+/** Names declared directly in a list of statements. */
+export declare function declarationsOf(statements: readonly ast.Statement[]): [string, BindingKind][];
+/** `defer` statements of a function body, excluding those of nested functions. */
+export declare function findDefers(body: ast.BlockStatement): ast.DeferStatement[];
+/** Whether markup appears in an expression, not counting nested functions (they handle theirs). */
+export declare function containsElement(node: ast.Node): boolean;
+/** Whether a member chain has `?.` somewhere: then the rest of it may not be evaluated. */
+export declare function hasOptionalLink(node: ast.Expression): boolean;
+export declare function endsWithJump(statements: readonly ast.Statement[]): boolean;
+export declare function startsWithObjectLiteral(node: ast.Expression): boolean;
+/** The variable at the start of `a.b.c`, or `null`. */
+export declare function rootName(node: ast.Expression): string | null;
+/** Literals, which can be put into inlined code as they are. */
+export declare function isConstant(node: ast.Expression): boolean;
+/** Expressions without side effects, which may be evaluated more than once. */
+export declare function isSimple(node: ast.Expression): boolean;

package/dist/codegen/analysis.js

@@ -0,0 +1,144 @@
+import { forEachChild } from "../walk.js";
+/** Names declared directly in a list of statements. */
+export function declarationsOf(statements) {
+    const bindings = [];
+    for (const statement of statements) {
+        switch (statement.kind) {
+            case 'VariableDeclaration':
+                for (const name of statement.names)
+                    bindings.push([name.name, statement.keyword]);
+                break;
+            case 'FuncDeclaration':
+                bindings.push([statement.name.name, 'function']);
+                break;
+            case 'ClassDeclaration':
+                bindings.push([statement.name.name, 'class']);
+                break;
+            case 'ImportDeclaration':
+                if (statement.defaultImport)
+                    bindings.push([statement.defaultImport.name, 'import']);
+                if (statement.namespaceImport)
+                    bindings.push([statement.namespaceImport.name, 'import']);
+                for (const specifier of statement.namedImports) {
+                    bindings.push([specifier.local.name, 'import']);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return bindings;
+}
+/** `defer` statements of a function body, excluding those of nested functions. */
+export function findDefers(body) {
+    const defers = [];
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'DeferStatement':
+                defers.push(node);
+                return;
+            case 'FuncDeclaration':
+            case 'FuncExpression':
+            case 'ArrowFunction':
+            case 'ClassDeclaration':
+            case 'MountStatement':
+            case 'EffectStatement':
+                return;
+            default:
+                forEachChild(node, visit);
+        }
+    };
+    forEachChild(body, visit);
+    return defers;
+}
+/** Whether markup appears in an expression, not counting nested functions (they handle theirs). */
+export function containsElement(node) {
+    let found = false;
+    const visit = (child) => {
+        if (found)
+            return;
+        if (child.kind === 'ElementExpression') {
+            found = true;
+            return;
+        }
+        if (child.kind === 'FuncExpression' || child.kind === 'ArrowFunction')
+            return;
+        forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}
+/** Whether a member chain has `?.` somewhere: then the rest of it may not be evaluated. */
+export function hasOptionalLink(node) {
+    switch (node.kind) {
+        case 'MemberExpression':
+        case 'IndexExpression':
+            return node.optional || hasOptionalLink(node.object);
+        case 'CallExpression':
+            return node.optional || hasOptionalLink(node.callee);
+        default:
+            return false;
+    }
+}
+export function endsWithJump(statements) {
+    const kind = statements.at(-1)?.kind;
+    return (kind === 'ReturnStatement' ||
+        kind === 'ThrowStatement' ||
+        kind === 'BreakStatement' ||
+        kind === 'ContinueStatement');
+}
+export function startsWithObjectLiteral(node) {
+    switch (node.kind) {
+        case 'ObjectLiteral':
+            return true;
+        case 'CallExpression':
+            return startsWithObjectLiteral(node.callee);
+        case 'MemberExpression':
+        case 'IndexExpression':
+            return startsWithObjectLiteral(node.object);
+        case 'BinaryExpression':
+            return startsWithObjectLiteral(node.left);
+        case 'ConditionalExpression':
+            return startsWithObjectLiteral(node.test);
+        default:
+            return false;
+    }
+}
+/** The variable at the start of `a.b.c`, or `null`. */
+export function rootName(node) {
+    if (node.kind === 'Identifier')
+        return node.name;
+    return node.kind === 'MemberExpression' ? rootName(node.object) : null;
+}
+/** Literals, which can be put into inlined code as they are. */
+export function isConstant(node) {
+    switch (node.kind) {
+        case 'NumberLiteral':
+        case 'StringLiteral':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.length === 0;
+        case 'UnaryExpression':
+            return node.operator === '-' && node.argument.kind === 'NumberLiteral';
+        default:
+            return false;
+    }
+}
+/** Expressions without side effects, which may be evaluated more than once. */
+export function isSimple(node) {
+    switch (node.kind) {
+        case 'Identifier':
+        case 'NumberLiteral':
+        case 'StringLiteral':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+        case 'ThisExpression':
+            return true;
+        case 'MemberExpression':
+            return isSimple(node.object);
+        default:
+            return false;
+    }
+}

package/dist/codegen/attributes.d.ts

@@ -0,0 +1,40 @@
+import type * as ast from '../ast.ts';
+import type { Live } from './reactive.ts';
+import { UpdateEmitter } from './updates.ts';
+export declare abstract class AttributeEmitter extends UpdateEmitter {
+    protected abstract nextId(): number;
+    protected abstract once(node: ast.Expression): string;
+    /** Counter for `$$li1`, `$$div2`, ... */
+    protected elementCount: number;
+    /** The element that elements of markup blocks are appended to, in plain control flow. */
+    protected contentTarget: string | null;
+    /** Whether the markup being written is inside `<svg>`: its elements are SVG then. */
+    protected inSvg: boolean;
+    /** `attrs` of `...attrs` in the component being written: `{...attrs}` applies them. */
+    protected attrsParam: string | null;
+    /** `document.createElement("div")`, or `createElementNS` for an SVG element. */
+    protected createElement(tag: string, svg: boolean): string;
+    /** `onClick={count++}` becomes `() => { count++; }`; a function is used as it is. */
+    protected handler(value: ast.JsxAttribute['value']): string;
+    protected elementName(tag: string | null): string;
+    protected attribute(element: string, tag: string | null, attribute: ast.JsxAttribute | ast.JsxSpreadAttribute, live: Live | null, svg?: boolean, scope?: string | null): void;
+    /** The class of an element with the class of its style: `"card rook-card-1x9k2az"`. */
+    private scopedClass;
+    /** Sets the class of an element: `className`, or the attribute of an SVG element. */
+    protected scopeClass(element: string, classes: string, svg: boolean): void;
+    /** `<app-card item-count={1} />`: the property of a web component of this module, if it has one. */
+    protected webComponentProperty(tag: string, name: string): ast.Parameter | null;
+    /** A property of a web component is set as a JS property, so it may be an object or a function. */
+    protected webComponentAttribute(element: string, param: ast.Parameter, value: ast.JsxAttribute['value'], live: Live | null): void;
+    /**
+     * Writes the statement that sets a value. In live markup, when the value depends on state, the
+     * same statement also goes into the updates of that state.
+     */
+    protected setLive(live: Live | null, value: ast.Expression, statement: (text: string) => string): void;
+    /**
+     * `bind:value={name}`: the element shows the variable, and what the user enters is written
+     * back to it. In live markup the element is also updated when the variable changes elsewhere.
+     */
+    protected binding(element: string, tag: string, attribute: ast.JsxAttribute, live: Live | null): void;
+    protected handlerFunction(value: ast.JsxAttribute['value']): string;
+}

package/dist/codegen/attributes.js

@@ -0,0 +1,227 @@
+import { domProperty } from "../checker/dom.js";
+import { attributeName } from "../html-tag.js";
+import { SVG_NAMESPACE } from "../svg.js";
+import { eventName, mentions } from "./element-helpers.js";
+import { ARROW } from "./syntax.js";
+import { UpdateEmitter } from "./updates.js";
+// Attributes of elements: properties, setAttribute, styles, `bind:` and event handlers.
+export class AttributeEmitter extends UpdateEmitter {
+    /** Counter for `$$li1`, `$$div2`, ... */
+    elementCount = 0;
+    /** The element that elements of markup blocks are appended to, in plain control flow. */
+    contentTarget = null;
+    /** Whether the markup being written is inside `<svg>`: its elements are SVG then. */
+    inSvg = false;
+    /** `attrs` of `...attrs` in the component being written: `{...attrs}` applies them. */
+    attrsParam = null;
+    /** `document.createElement("div")`, or `createElementNS` for an SVG element. */
+    createElement(tag, svg) {
+        const quoted = JSON.stringify(tag);
+        return svg
+            ? `document.createElementNS(${JSON.stringify(SVG_NAMESPACE)}, ${quoted})`
+            : `document.createElement(${quoted})`;
+    }
+    /** `onClick={count++}` becomes `() => { count++; }`; a function is used as it is. */
+    handler(value) {
+        return this.withRendering(0, () => this.handlerFunction(value));
+    }
+    elementName(tag) {
+        const base = tag === null ? 'fragment' : /^[a-z][a-z0-9]*$/.test(tag) ? tag : 'element';
+        return `$$${base}${this.nextId()}`;
+    }
+    attribute(element, tag, attribute, live, svg = false, scope = null) {
+        if (attribute.kind === 'JsxSpreadAttribute') {
+            const { argument } = attribute;
+            // The attributes passed on: the use made a function that sets them on the element.
+            if (argument.kind === 'Identifier' && argument.name === this.attrsParam) {
+                this.line(`${this.name(argument.name)}?.(${element});`);
+                return;
+            }
+            this.setLive(live, argument, (text) => `Object.assign(${element}, ${text});`);
+            return;
+        }
+        const name = attribute.name.name;
+        const { value } = attribute;
+        if (name === 'class' && scope) {
+            this.scopedClass(element, value, live, svg, scope);
+            return;
+        }
+        const webProperty = tag === null || svg ? null : this.webComponentProperty(tag, name);
+        if (webProperty) {
+            this.webComponentAttribute(element, webProperty, value, live);
+            return;
+        }
+        if (/^on[A-Z]/.test(name)) {
+            this.inHandler++;
+            try {
+                this.line(`${element}.addEventListener(${JSON.stringify(eventName(name))}, ${this.handler(value)});`);
+            }
+            finally {
+                this.inHandler--;
+            }
+            return;
+        }
+        if (value?.kind === 'EventHandler')
+            return;
+        if (name === 'style' && value !== null) {
+            const isString = value.kind === 'StringLiteral' || this.typeOf(value)?.kind === 'string';
+            this.setLive(live, value, (text) => isString
+                ? `${element}.style.cssText = ${text};`
+                : `Object.assign(${element}.style, ${text});`);
+            return;
+        }
+        // SVG attributes are set with setAttribute: their properties are objects.
+        const property = tag === null || svg ? null : domProperty(tag, name);
+        if (value === null) {
+            // `<input disabled>`: true for boolean properties, an empty attribute otherwise.
+            this.line(property?.type.kind === 'bool'
+                ? `${element}.${property.name} = true;`
+                : `${element}.setAttribute(${JSON.stringify(name)}, "");`);
+            return;
+        }
+        if (property) {
+            this.setLive(live, value, (text) => `${element}.${property.name} = ${text};`);
+            return;
+        }
+        const quoted = JSON.stringify(name);
+        if (this.typeOf(value)?.kind !== 'nullable') {
+            this.setLive(live, value, (text) => `${element}.setAttribute(${quoted}, ${text});`);
+        }
+        else if (live && live.dependencies(value).size > 0) {
+            this.helpers.add('attribute');
+            this.setLive(live, value, (text) => `$$attribute(${element}, ${quoted}, ${text});`);
+        }
+        else {
+            // A null value leaves the attribute out.
+            const text = this.once(value);
+            this.line(`if (${text} != null) ${element}.setAttribute(${quoted}, ${text});`);
+        }
+    }
+    /** The class of an element with the class of its style: `"card rook-card-1x9k2az"`. */
+    scopedClass(element, value, live, svg, scope) {
+        if (value === null || value.kind === 'StringLiteral') {
+            this.scopeClass(element, `${value?.value ?? ''} ${scope}`.trim(), svg);
+        }
+        else if (value.kind !== 'EventHandler') {
+            const nullable = this.typeOf(value)?.kind !== 'string';
+            this.setLive(live, value, (text) => {
+                const scoped = `\`\${${nullable ? `${text} ?? ""` : text}} ${scope}\``;
+                return svg
+                    ? `${element}.setAttribute("class", ${scoped});`
+                    : `${element}.className = ${scoped};`;
+            });
+        }
+    }
+    /** Sets the class of an element: `className`, or the attribute of an SVG element. */
+    scopeClass(element, classes, svg) {
+        const text = JSON.stringify(classes);
+        this.line(svg ? `${element}.setAttribute("class", ${text});` : `${element}.className = ${text};`);
+    }
+    /** `<app-card item-count={1} />`: the property of a web component of this module, if it has one. */
+    webComponentProperty(tag, name) {
+        const component = this.webComponents.get(tag);
+        if (!component)
+            return null;
+        const param = component.params.find((param) => param.name.name !== 'children' &&
+            (param.name.name === name || attributeName(param.name.name) === name));
+        return param ?? null;
+    }
+    /** A property of a web component is set as a JS property, so it may be an object or a function. */
+    webComponentAttribute(element, param, value, live) {
+        const target = `${element}.${param.name.name}`;
+        if (value === null) {
+            this.line(`${target} = true;`);
+        }
+        else if (value.kind === 'EventHandler' ||
+            value.kind === 'ArrowFunction' ||
+            value.kind === 'FuncExpression') {
+            this.inHandler++;
+            try {
+                this.line(`${target} = ${this.handler(value)};`);
+            }
+            finally {
+                this.inHandler--;
+            }
+        }
+        else {
+            this.setLive(live, value, (text) => `${target} = ${text};`);
+        }
+    }
+    /**
+     * Writes the statement that sets a value. In live markup, when the value depends on state, the
+     * same statement also goes into the updates of that state.
+     */
+    setLive(live, value, statement) {
+        const sources = live && value.kind !== 'StringLiteral' ? live.dependencies(value) : null;
+        if (!live || !sources || sources.size === 0) {
+            this.line(statement(this.expression(value, ARROW)));
+            return;
+        }
+        const text = statement(this.liveExpression(value));
+        this.line(text);
+        live.depend(sources, text);
+    }
+    /**
+     * `bind:value={name}`: the element shows the variable, and what the user enters is written
+     * back to it. In live markup the element is also updated when the variable changes elsewhere.
+     */
+    binding(element, tag, attribute, live) {
+        const value = attribute.value;
+        const isNumber = attribute.name.name === 'bind:value' && this.typeOf(value)?.kind === 'number';
+        const property = attribute.name.name === 'bind:checked' ? 'checked' : isNumber ? 'valueAsNumber' : 'value';
+        const target = this.liveExpression(value);
+        const current = `${element}.${property}`;
+        this.line(`${current} = ${target};`);
+        const event = property === 'checked' || tag === 'select' ? 'change' : 'input';
+        const written = [...(this.reactive?.rootSources(value) ?? [])].filter((source) => source.kind === 'state');
+        const dependsOn = live?.dependencies(value) ?? new Set();
+        this.inHandler++;
+        try {
+            const body = this.block(() => {
+                this.line(`${target} = ${current};`);
+                for (const source of written) {
+                    // The element already shows what was entered: its own update is skipped.
+                    const own = live && dependsOn.has(source) ? live.ownIndex(source) : null;
+                    this.line(`${this.write(source, own)};`);
+                }
+            });
+            this.line(`${element}.addEventListener(${JSON.stringify(event)}, () => ${body});`);
+        }
+        finally {
+            this.inHandler--;
+        }
+        // NaN from an unfinished number must not clear the input while the user types.
+        const differs = isNumber ? `!Object.is(${current}, ${target})` : `${current} !== ${target}`;
+        if (live && dependsOn.size > 0) {
+            live.depend(dependsOn, `if (${differs}) ${current} = ${target};`);
+        }
+    }
+    handlerFunction(value) {
+        if (value === null)
+            return '() => {}';
+        if (value.kind !== 'EventHandler')
+            return this.expression(value, ARROW);
+        const name = {
+            kind: 'Identifier',
+            name: 'event',
+            start: value.start,
+            end: value.start,
+        };
+        const params = mentions(value, 'event')
+            ? [
+                {
+                    kind: 'Parameter',
+                    name,
+                    type: null,
+                    defaultValue: null,
+                    start: value.start,
+                    end: value.start,
+                },
+            ]
+            : [];
+        return this.withFunction('none', params, () => {
+            const body = this.block(() => this.statements(value.body));
+            return `(${params.length > 0 ? 'event' : ''}) => ${body}`;
+        });
+    }
+}

package/dist/codegen/calls.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import { ExpressionEmitter } from './expressions.ts';
+export declare abstract class CallEmitter extends ExpressionEmitter {
+    protected call(node: ast.CallExpression): string;
+    /** `yield v` for `yield(v)` in an iterator, `yield [k, v]` for `yield(k, v)`; else `null`. */
+    private yielded;
+    protected expressionStatement(node: ast.Expression): string;
+    /** `if !yield(v) { return }`, the way an iterator of Go stops: in a generator, `yield v`. */
+    protected yieldStatement(node: ast.IfStatement): string | null;
+    /** `string(data)`, unless `string` is the name of a value here. */
+    private isStringConversion;
+    protected newExpression(node: ast.NewExpression): string;
+    /** `new (f())()` and `new (a?.B)()` need parentheses around the class expression. */
+    private newCallee;
+    protected arrayLiteral(node: ast.ArrayLiteral): string;
+    /**
+     * `make([]float64, n)` → `new Float64Array(n)`; with `shared`, on a SharedArrayBuffer of its
+     * size in bytes, `new Float64Array($$shared(8 * n))`. Without types the name is the one written.
+     */
+    protected make(node: ast.MakeExpression): string;
+    protected conversion(node: ast.ConversionExpression): string;
+}