rooklang 0.0.0-stage → 0.3.0

package/dist/ast/expressions.d.ts

@@ -0,0 +1,201 @@
+import type { NodeBase, Parameter } from './declarations.ts';
+import type { ElementExpression, TypeNode } from './markup.ts';
+import type { BlockStatement } from './statements.ts';
+export type Expression = Identifier | NumberLiteral | BigIntLiteral | StringLiteral | TemplateLiteral | BooleanLiteral | NullLiteral | ThisExpression | SuperExpression | ArrayLiteral | ObjectLiteral | FuncExpression | ArrowFunction | UnaryExpression | BinaryExpression | ConditionalExpression | CallExpression | NewExpression | MemberExpression | IndexExpression | ElementExpression | DecoratorMember | DecoratorGet | AsExpression | GoExpression | ChanExpression | ConversionExpression | MakeExpression;
+/**
+ * `[]byte("rook")`: the UTF-8 bytes of a string. `string(data)`, the way back, is a call, since
+ * `string` may be the name of a value.
+ */
+export interface ConversionExpression extends NodeBase {
+    kind: 'ConversionExpression';
+    type: TypeNode;
+    argument: Expression;
+}
+/**
+ * `make([]float64, n)`: a new typed array of `n` zeros; with `shared`, `make([]float64, n,
+ * shared)`, on a SharedArrayBuffer, which the workers of `go for` write into without copies.
+ */
+export interface MakeExpression extends NodeBase {
+    kind: 'MakeExpression';
+    type: TypeNode;
+    length: Expression;
+    shared: boolean;
+}
+/** `chan<number>(10)`: a new channel with room for 10 values; `chan<number>()` has none. */
+export interface ChanExpression extends NodeBase {
+    kind: 'ChanExpression';
+    element: TypeNode;
+    size: Expression | null;
+}
+/**
+ * `go work(x)`: calls a function of the module in a worker, with copies of the arguments. As an
+ * expression it is a Promise of what the function returns; as a statement nothing waits for it.
+ */
+export interface GoExpression extends NodeBase {
+    kind: 'GoExpression';
+    call: CallExpression;
+}
+/**
+ * `value as Type`: the value seen as another type, as in TypeScript. The types must be related:
+ * one assignable to the other. Nothing is left of it in JS.
+ */
+export interface AsExpression extends NodeBase {
+    kind: 'AsExpression';
+    expression: Expression;
+    type: TypeNode;
+}
+export interface Identifier extends NodeBase {
+    kind: 'Identifier';
+    name: string;
+}
+export interface NumberLiteral extends NodeBase {
+    kind: 'NumberLiteral';
+    value: number;
+    /** Source text, e.g. `0xff` or `1_000`, so code generation can keep it as written. */
+    raw: string;
+}
+/** `10n`: a bigint. Its value is in `raw` only, so that the tree stays plain data for JSON. */
+export interface BigIntLiteral extends NodeBase {
+    kind: 'BigIntLiteral';
+    /** Source text with the `n`, e.g. `0xffn` or `1_000n`; JS writes it the same way. */
+    raw: string;
+}
+export interface StringLiteral extends NodeBase {
+    kind: 'StringLiteral';
+    /** Contents with escapes resolved. */
+    value: string;
+    /** Source text including quotes. */
+    raw: string;
+}
+/** `` `Hello, ${name}!` ``: `quasis` always has one element more than `expressions`. */
+export interface TemplateLiteral extends NodeBase {
+    kind: 'TemplateLiteral';
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+/** A text part of a template literal, without the backticks and `${` / `}` around it. */
+export interface TemplateElement extends NodeBase {
+    kind: 'TemplateElement';
+    /** Contents with escapes resolved. */
+    value: string;
+    /** Contents as written in the source. */
+    raw: string;
+}
+export interface BooleanLiteral extends NodeBase {
+    kind: 'BooleanLiteral';
+    value: boolean;
+}
+export interface NullLiteral extends NodeBase {
+    kind: 'NullLiteral';
+}
+export interface ThisExpression extends NodeBase {
+    kind: 'ThisExpression';
+}
+/** `super` in `super(name)` and `super.greet()`. */
+export interface SuperExpression extends NodeBase {
+    kind: 'SuperExpression';
+}
+/** `[1, 2, ...rest]` */
+export interface ArrayLiteral extends NodeBase {
+    kind: 'ArrayLiteral';
+    elements: (Expression | SpreadElement)[];
+}
+/** `{ name: "Ann", age, ...defaults }` */
+export interface ObjectLiteral extends NodeBase {
+    kind: 'ObjectLiteral';
+    properties: (Property | SpreadElement)[];
+}
+/** `name: value`, `"content-type": value`, or shorthand `name` (then `value` is an Identifier). */
+export interface Property extends NodeBase {
+    kind: 'Property';
+    key: Identifier | StringLiteral;
+    value: Expression;
+    shorthand: boolean;
+}
+/** `...xs` in array literals, object literals and call arguments. */
+export interface SpreadElement extends NodeBase {
+    kind: 'SpreadElement';
+    argument: Expression;
+}
+/** `func(x number) number { return x * x }` */
+export interface FuncExpression extends NodeBase {
+    kind: 'FuncExpression';
+    /** `async func(...)`: its results are those of the Promise it returns. */
+    async?: true;
+    params: Parameter[];
+    results: TypeNode[];
+    body: BlockStatement;
+}
+/** `x => x * 2`, `(a, b number) => a + b`, `() => { ... }`. The result type is inferred. */
+export interface ArrowFunction extends NodeBase {
+    kind: 'ArrowFunction';
+    /** `async x => ...`. */
+    async?: true;
+    params: Parameter[];
+    body: BlockStatement | Expression;
+}
+/**
+ * `await` and `<-ch`, the receive from a channel, are allowed only in async functions and at the
+ * top level of a module.
+ */
+export type UnaryOperator = '!' | '-' | '+' | '~' | 'typeof' | 'await' | '<-';
+export interface UnaryExpression extends NodeBase {
+    kind: 'UnaryExpression';
+    operator: UnaryOperator;
+    argument: Expression;
+}
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '**' | '==' | '!=' | '<' | '>' | '<=' | '>=' | '&&' | '||' | '??' | '&' | '|' | '^' | '<<' | '>>' | '>>>' | 'instanceof';
+export interface BinaryExpression extends NodeBase {
+    kind: 'BinaryExpression';
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+/** `cond ? a : b` */
+export interface ConditionalExpression extends NodeBase {
+    kind: 'ConditionalExpression';
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+}
+/** `f(x)`, or `f?.(x)` when `optional`. */
+export interface CallExpression extends NodeBase {
+    kind: 'CallExpression';
+    callee: Expression;
+    arguments: (Expression | SpreadElement)[];
+    optional: boolean;
+}
+/** `new User("Ann", 30)` */
+export interface NewExpression extends NodeBase {
+    kind: 'NewExpression';
+    callee: Expression;
+    arguments: (Expression | SpreadElement)[];
+}
+/** `a.b`, or `a?.b` when `optional`. The property may be a keyword, e.g. `xs.map`. */
+export interface MemberExpression extends NodeBase {
+    kind: 'MemberExpression';
+    object: Expression;
+    property: Identifier;
+    optional: boolean;
+}
+/** `a[i]`, or `a?.[i]` when `optional`. */
+export interface IndexExpression extends NodeBase {
+    kind: 'IndexExpression';
+    object: Expression;
+    index: Expression;
+    optional: boolean;
+}
+/**
+ * `@visible.shown`: a public member of a decorator applied to the component. The names belong to
+ * the decorator, not to any scope, so walkers do not visit them as identifiers.
+ */
+export interface DecoratorMember extends NodeBase {
+    kind: 'DecoratorMember';
+    decorator: Identifier;
+    member: Identifier;
+}
+/** `get(@visible.shown)`: reads public state or a constant of a decorator. */
+export interface DecoratorGet extends NodeBase {
+    kind: 'DecoratorGet';
+    target: DecoratorMember;
+}

package/dist/ast/expressions.js

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

package/dist/ast/markup.d.ts

@@ -0,0 +1,141 @@
+import type { ClassMember, DecoratorUse, ImportSpecifier, NodeBase, Parameter, Program, TypeParameter } from './declarations.ts';
+import type { BooleanLiteral, Expression, Identifier, NumberLiteral, Property, SpreadElement, StringLiteral, TemplateElement } from './expressions.ts';
+import type { CatchClause, CssText, ForInStatement, ForStatement, IfStatement, SimpleStatement, Statement, SelectCase, SwitchCase, SwitchStatement } from './statements.ts';
+/** `<a href="/">Link {name}</a>`: creates a DOM element. `tag` is `null` for a fragment `<>...</>`. */
+export interface ElementExpression extends NodeBase {
+    kind: 'ElementExpression';
+    /** The tag name as written: `div`, `my-widget`, `section.content`. */
+    tag: Identifier | null;
+    /**
+     * A tag with a dot takes its component from a value: `section.content` in
+     * `<section.content />`. A capitalized tag, `<Page />`, does so when `Page` is a variable rather
+     * than a component; that depends on the scope, so this is `null` for it unless the code was
+     * copied from another module and the variable renamed.
+     */
+    value: Expression | null;
+    attributes: (JsxAttribute | JsxSpreadAttribute)[];
+    children: JsxChild[];
+}
+export type JsxChild = JsxText | JsxExpressionContainer | JsxStatementContainer | ElementExpression;
+/** Text between tags, with whitespace already cleaned up as in JSX. */
+export interface JsxText extends NodeBase {
+    kind: 'JsxText';
+    value: string;
+}
+/** `{expression}` among the children. Empty ones (`{/* comment *\/}`) are left out. */
+export interface JsxExpressionContainer extends NodeBase {
+    kind: 'JsxExpressionContainer';
+    expression: Expression;
+}
+/**
+ * `{for todo in todos { <li>{todo.title}</li> }}`: control flow among the children. Its blocks
+ * hold markup statements: elements, nested if/for/switch and `const` declarations.
+ */
+export interface JsxStatementContainer extends NodeBase {
+    kind: 'JsxStatementContainer';
+    statement: IfStatement | ForStatement | ForInStatement | SwitchStatement;
+}
+/** An element written as a statement inside markup control flow: it becomes content. */
+export interface JsxElementStatement extends NodeBase {
+    kind: 'JsxElementStatement';
+    element: ElementExpression;
+}
+/**
+ * `href="/"`, `href={url}` or just `disabled` (then `value` is `null`). Attributes `on*` hold an
+ * EventHandler, unless they are given a function (a name, `obj.method` or a function literal).
+ */
+export interface JsxAttribute extends NodeBase {
+    kind: 'JsxAttribute';
+    /** The attribute name as written: `class`, `data-id`, `onClick`. */
+    name: Identifier;
+    value: StringLiteral | Expression | EventHandler | null;
+}
+/** `{...attrs}` */
+export interface JsxSpreadAttribute extends NodeBase {
+    kind: 'JsxSpreadAttribute';
+    argument: Expression;
+}
+/** `onClick={count++}`: statements that run when the event happens, with `event` available. */
+export interface EventHandler extends NodeBase {
+    kind: 'EventHandler';
+    body: SimpleStatement[];
+}
+export type TypeNode = TypeReference | ArrayType | NullableType | FuncType | ComponentType | ObjectType | UnionType | LiteralType | ChanType;
+/**
+ * `chan number`: a channel of numbers, made by `chan<number>(size)`; `chan<- number` only sends
+ * and `<-chan number` only receives.
+ */
+export interface ChanType extends NodeBase {
+    kind: 'ChanType';
+    element: TypeNode;
+    direction: 'both' | 'send' | 'receive';
+}
+/** A named type: `number`, `User`, `Point`, `Box<number>`. */
+export interface TypeReference extends NodeBase {
+    kind: 'TypeReference';
+    name: Identifier;
+    /** Type arguments of a generic type: `<number>` in `Box<number>`. */
+    typeArgs: TypeNode[];
+}
+/** `[]T` */
+export interface ArrayType extends NodeBase {
+    kind: 'ArrayType';
+    element: TypeNode;
+}
+/** `?T` */
+export interface NullableType extends NodeBase {
+    kind: 'NullableType';
+    type: TypeNode;
+}
+/** `func(number, number) bool` */
+export interface FuncType extends NodeBase {
+    kind: 'FuncType';
+    params: TypeNode[];
+    results: TypeNode[];
+    /** `func(yield func(T) bool)`: its one parameter is named `yield`, so it is an iterator. */
+    iterator?: boolean;
+}
+/** `comp(title string, kind ?Kind)`: a component as a value, used as a tag: `<section.content />`. */
+export interface ComponentType extends NodeBase {
+    kind: 'ComponentType';
+    params: Parameter[];
+}
+/** `string | number`; a member may be in parentheses: `[](string | number)`. */
+export interface UnionType extends NodeBase {
+    kind: 'UnionType';
+    types: TypeNode[];
+}
+/** `"all"`, `42` or `true` as a type: the only value of the type. */
+export interface LiteralType extends NodeBase {
+    kind: 'LiteralType';
+    value: StringLiteral | NumberLiteral | BooleanLiteral;
+}
+/** `{ x, y number }` — an anonymous object type. */
+export interface ObjectType extends NodeBase {
+    kind: 'ObjectType';
+    members: TypeMember[];
+}
+/** Members of interfaces and object types. */
+export type TypeMember = PropertySignature | MethodSignature | IndexSignature;
+/** `[string]: Shape`: the type of the fields an object has besides the ones listed. */
+export interface IndexSignature extends NodeBase {
+    kind: 'IndexSignature';
+    /** `string` or `number`. */
+    key: TypeNode;
+    type: TypeNode;
+}
+/** `label ?string`. A field with a nullable type may be omitted in object literals. */
+export interface PropertySignature extends NodeBase {
+    kind: 'PropertySignature';
+    name: Identifier;
+    type: TypeNode;
+}
+/** `area() number` */
+export interface MethodSignature extends NodeBase {
+    kind: 'MethodSignature';
+    name: Identifier;
+    params: Parameter[];
+    results: TypeNode[];
+}
+export type Node = Program | Statement | Expression | TypeNode | ImportSpecifier | Parameter | DecoratorUse | TypeParameter | ClassMember | TypeMember | SwitchCase | SelectCase | CatchClause | Property | SpreadElement | TemplateElement | CssText | JsxText | JsxExpressionContainer | JsxStatementContainer | JsxAttribute | JsxSpreadAttribute | EventHandler;
+export type NodeKind = Node['kind'];

package/dist/ast/markup.js

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

package/dist/ast/statements.d.ts

@@ -0,0 +1,173 @@
+import type { ClassDeclaration, ComponentDeclaration, DecoratorDeclaration, FuncDeclaration, ImportDeclaration, InterfaceDeclaration, NodeBase, TypeAliasDeclaration, VariableDeclaration } from './declarations.ts';
+import type { CallExpression, Expression, Identifier, UnaryExpression } from './expressions.ts';
+import type { JsxElementStatement } from './markup.ts';
+export type Statement = ImportDeclaration | FuncDeclaration | ComponentDeclaration | DecoratorDeclaration | VariableDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | BlockStatement | ExpressionStatement | AssignmentStatement | IncDecStatement | ReturnStatement | IfStatement | ForStatement | ForInStatement | SwitchStatement | BreakStatement | ContinueStatement | ThrowStatement | TryStatement | DeferStatement | MountStatement | EffectStatement | StyleStatement | DeleteStatement | JsxElementStatement | SendStatement | SelectStatement;
+/** Statements allowed in the `init` and `update` parts of a `for` header. */
+export type SimpleStatement = VariableDeclaration | ExpressionStatement | AssignmentStatement | IncDecStatement | DeleteStatement | SendStatement;
+/** `ch <- value`: waits until the channel takes the value, so only in async functions. */
+export interface SendStatement extends NodeBase {
+    kind: 'SendStatement';
+    channel: Expression;
+    value: Expression;
+}
+export interface BlockStatement extends NodeBase {
+    kind: 'BlockStatement';
+    body: Statement[];
+}
+export interface ExpressionStatement extends NodeBase {
+    kind: 'ExpressionStatement';
+    expression: Expression;
+}
+export type AssignmentOperator = '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '>>>=' | '&&=' | '||=' | '??=';
+/**
+ * `x = 1`, `a, b = b, a`, `total += v`. Assignment is a statement, as in Go, so `f(a = 1)` and
+ * `a = b = c` are not valid. Compound operators take exactly one target.
+ */
+export interface AssignmentStatement extends NodeBase {
+    kind: 'AssignmentStatement';
+    operator: AssignmentOperator;
+    /** Identifiers, member or index expressions. */
+    targets: Expression[];
+    /** One value per target, or a single call that returns several values. */
+    values: Expression[];
+}
+/** `i++` and `i--`, statements only (as in Go). */
+export interface IncDecStatement extends NodeBase {
+    kind: 'IncDecStatement';
+    operator: '++' | '--';
+    target: Expression;
+}
+/** `return`, `return x`, `return q, null`. */
+export interface ReturnStatement extends NodeBase {
+    kind: 'ReturnStatement';
+    values: Expression[];
+}
+export interface IfStatement extends NodeBase {
+    kind: 'IfStatement';
+    condition: Expression;
+    consequent: BlockStatement;
+    /** `else { ... }` or `else if ...`. */
+    alternate: BlockStatement | IfStatement | null;
+}
+/**
+ * Every `for` loop except `for ... in`:
+ *
+ *     for let i = 0; i < n; i++ { }   init, condition, update
+ *     for cond { }                    condition only
+ *     for { }                         nothing
+ */
+export interface ForStatement extends NodeBase {
+    kind: 'ForStatement';
+    init: SimpleStatement | null;
+    condition: Expression | null;
+    update: SimpleStatement | null;
+    body: BlockStatement;
+}
+/**
+ * `for x in items { }` (key is `null`) and `for i, x in items { }`; with `go`, `go for i, x in
+ * items { }`, the parts of the array run as goroutines and the loop waits for them (go-for.ts).
+ */
+export interface ForInStatement extends NodeBase {
+    kind: 'ForInStatement';
+    key: Identifier | null;
+    value: Identifier;
+    iterable: Expression;
+    body: BlockStatement;
+    go?: boolean;
+}
+/** `switch cmd { ... }`, or `switch { ... }` without a discriminant as an if/else chain. */
+export interface SwitchStatement extends NodeBase {
+    kind: 'SwitchStatement';
+    discriminant: Expression | null;
+    cases: SwitchCase[];
+}
+/** `case "start", "run": ...`, or `default: ...` when `tests` is empty. */
+export interface SwitchCase extends NodeBase {
+    kind: 'SwitchCase';
+    tests: Expression[];
+    body: Statement[];
+}
+/**
+ * `select { case v = <-ch: ... case out <- v: ... default: ... }`: waits until one of the
+ * operations on channels can go on, does it and runs its case; `default` runs when none can at
+ * once.
+ */
+export interface SelectStatement extends NodeBase {
+    kind: 'SelectStatement';
+    cases: SelectCase[];
+}
+/** A case of `select`: a receive, `<-ch`, a send, `ch <- v`, or `default` when it is null. */
+export interface SelectCase extends NodeBase {
+    kind: 'SelectCase';
+    /** `v` or `v, ok` in `case v, ok = <-ch:`: new variables of the case. */
+    names: Identifier[];
+    operation: UnaryExpression | SendStatement | null;
+    body: Statement[];
+}
+export interface BreakStatement extends NodeBase {
+    kind: 'BreakStatement';
+}
+export interface ContinueStatement extends NodeBase {
+    kind: 'ContinueStatement';
+}
+export interface ThrowStatement extends NodeBase {
+    kind: 'ThrowStatement';
+    argument: Expression;
+}
+export interface TryStatement extends NodeBase {
+    kind: 'TryStatement';
+    block: BlockStatement;
+    handler: CatchClause | null;
+    finalizer: BlockStatement | null;
+}
+/** `catch e { ... }`, or `catch { ... }` without a parameter. */
+export interface CatchClause extends NodeBase {
+    kind: 'CatchClause';
+    param: Identifier | null;
+    body: BlockStatement;
+}
+/** `defer f.close()` or `defer { ... }`. */
+export interface DeferStatement extends NodeBase {
+    kind: 'DeferStatement';
+    body: CallExpression | BlockStatement;
+}
+/**
+ * `mount() { ... }` at the top level of a component: runs once the component's markup is in the
+ * document. It may return a function, which runs when `{if}`, `{switch}` or `{for}` removes the
+ * markup.
+ */
+export interface MountStatement extends NodeBase {
+    kind: 'MountStatement';
+    body: BlockStatement;
+}
+/**
+ * `effect { ... }` at the top level of a component: runs once the markup is created, and again
+ * whenever what it reads changes. Its `defer` runs before it runs again and when the component is
+ * removed.
+ */
+export interface EffectStatement extends NodeBase {
+    kind: 'EffectStatement';
+    body: BlockStatement;
+}
+/**
+ * `style { .card { padding: 8px; color: {accent} } }` at the top level of a component or a
+ * decorator: CSS for its own markup. `parts` are the raw CSS text around the values from code,
+ * which appear only in the values of declarations.
+ */
+export interface StyleStatement extends NodeBase {
+    kind: 'StyleStatement';
+    parts: (CssText | Expression)[];
+}
+/**
+ * `delete scores[name]`: removes a key of an object used as a map (`{ [string]: T }`), or a field
+ * of type `?T`.
+ */
+export interface DeleteStatement extends NodeBase {
+    kind: 'DeleteStatement';
+    target: Expression;
+}
+/** Raw CSS text of a `style` block, as written. */
+export interface CssText extends NodeBase {
+    kind: 'CssText';
+    value: string;
+}

package/dist/ast/statements.js

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

package/dist/ast.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Syntax tree produced by the parser. Every node has a `kind` that discriminates the unions below
+ * and the `start`/`end` offsets of its source text.
+ *
+ * For example, `const q, err = divide(10, 2)` becomes:
+ *
+ *     VariableDeclaration {
+ *       keyword: 'const', names: [Identifier q, Identifier err], type: null,
+ *       values: [CallExpression { callee: Identifier divide, arguments: [NumberLiteral 10, NumberLiteral 2] }],
+ *     }
+ *
+ * Grouped names such as `a, b number` in parameters, fields and interface members are expanded into
+ * separate nodes that share the same type node.
+ */
+export * from './ast/declarations.ts';
+export * from './ast/statements.ts';
+export * from './ast/expressions.ts';
+export * from './ast/markup.ts';

package/dist/ast.js

@@ -0,0 +1,18 @@
+/**
+ * Syntax tree produced by the parser. Every node has a `kind` that discriminates the unions below
+ * and the `start`/`end` offsets of its source text.
+ *
+ * For example, `const q, err = divide(10, 2)` becomes:
+ *
+ *     VariableDeclaration {
+ *       keyword: 'const', names: [Identifier q, Identifier err], type: null,
+ *       values: [CallExpression { callee: Identifier divide, arguments: [NumberLiteral 10, NumberLiteral 2] }],
+ *     }
+ *
+ * Grouped names such as `a, b number` in parameters, fields and interface members are expanded into
+ * separate nodes that share the same type node.
+ */
+export * from "./ast/declarations.js";
+export * from "./ast/statements.js";
+export * from "./ast/expressions.js";
+export * from "./ast/markup.js";

package/dist/attrs.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from './ast.ts';
+import { type MarkupBinding } from './refs.ts';
+/** `...attrs` of a component, its last parameter, or null. */
+export declare function attrsParam(component: ast.ComponentDeclaration): ast.Parameter | null;
+/** Where a component spreads its `...attrs`, with whether that markup is created once. */
+export declare function attrsSpreads(component: ast.ComponentDeclaration): MarkupBinding<ast.JsxSpreadAttribute>[];
+/** The element that gets the attributes: the first one `{...attrs}` is spread on. */
+export declare function attrsTarget(component: ast.ComponentDeclaration): ast.ElementExpression | null;

package/dist/attrs.js

@@ -0,0 +1,23 @@
+import { isComponentUse, markupBindings } from "./refs.js";
+// Attributes passed on: `comp Button(kind Kind, ...attrs)` takes the attributes of a use that are
+// not its properties, and `<button {...attrs}>` puts them on one of its elements. The use is
+// checked against that element, and its code sets them there, on whichever element the component
+// creates. The checker and the generator share these questions about the syntax tree.
+/** `...attrs` of a component, its last parameter, or null. */
+export function attrsParam(component) {
+    return component.params.at(-1)?.rest ? component.params.at(-1) : null;
+}
+/** Where a component spreads its `...attrs`, with whether that markup is created once. */
+export function attrsSpreads(component) {
+    const param = attrsParam(component);
+    if (!param)
+        return [];
+    return markupBindings(component.body, (attribute) => attribute.kind === 'JsxSpreadAttribute' &&
+        attribute.argument.kind === 'Identifier' &&
+        attribute.argument.name === param.name.name);
+}
+/** The element that gets the attributes: the first one `{...attrs}` is spread on. */
+export function attrsTarget(component) {
+    const [spread] = attrsSpreads(component);
+    return spread && !isComponentUse(spread.element) && spread.element.tag ? spread.element : null;
+}

package/dist/browser.d.ts

@@ -0,0 +1,30 @@
+import { type CompletionList } from './completion.ts';
+export { tokenize } from './lexer/lexer.ts';
+export { KEYWORDS } from './lexer/token.ts';
+export type { Completion, CompletionList } from './completion.ts';
+export interface BrowserDiagnostic {
+    message: string;
+    /** 1-based position of the start of the problem. */
+    line: number;
+    column: number;
+    /** 1-based position just after its end. */
+    endLine: number;
+    endColumn: number;
+}
+export interface BrowserCompileResult {
+    /** The generated ES module; empty when there are diagnostics. */
+    code: string;
+    diagnostics: BrowserDiagnostic[];
+    /** Problems that do not stop compilation. */
+    warnings: BrowserDiagnostic[];
+    /** The worker module of `go`, when the program has `go`. */
+    worker?: string;
+}
+export interface BrowserOptions {
+    /** Markup and components; off by default, as in a package without them. */
+    markup?: boolean;
+}
+/** Compiles a program; `workerUrl` is where its worker module of `go` will be, if not next to it. */
+export declare function compile(source: string, workerUrl?: string | null, options?: BrowserOptions): BrowserCompileResult;
+/** What can be written at `offset` of a program: names, properties, tags and attributes. */
+export declare function complete(source: string, offset: number, options?: BrowserOptions): CompletionList;

package/dist/browser.js

@@ -0,0 +1,36 @@
+import { compileModule } from "./compile.js";
+import { completeModule } from "./completion.js";
+import { SourceFile } from "./source.js";
+// The compiler for the browser, used by the documentation site: everything but reading imported
+// modules from disk, so imports are not type checked. Completion is the one of the language server.
+// There is no package.json here: markup and components are on only with `{ markup: true }`.
+export { tokenize } from "./lexer/lexer.js";
+export { KEYWORDS } from "./lexer/token.js";
+/** Compiles a program; `workerUrl` is where its worker module of `go` will be, if not next to it. */
+export function compile(source, workerUrl, options = {}) {
+    const result = compileModule(source, {
+        rewriteImports: false,
+        workerUrl: workerUrl ?? undefined,
+        markup: options.markup ?? false,
+    });
+    const file = new SourceFile('', source);
+    const located = (diagnostic) => {
+        const end = file.position(diagnostic.end);
+        return {
+            message: diagnostic.message,
+            ...file.position(diagnostic.start),
+            endLine: end.line,
+            endColumn: end.column,
+        };
+    };
+    return {
+        code: result.code,
+        diagnostics: result.diagnostics.map(located),
+        warnings: result.warnings.map(located),
+        ...(result.worker === undefined ? {} : { worker: result.worker }),
+    };
+}
+/** What can be written at `offset` of a program: names, properties, tags and attributes. */
+export function complete(source, offset, options = {}) {
+    return completeModule(source, offset, { markup: options.markup ?? false });
+}