rooklang 0.4.1 → 0.5.0

package/dist/codegen/calls.js

@@ -5,7 +5,7 @@ import { isYieldCall } from "../iterators.js";
 import { TYPED_ARRAYS, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { hasOptionalLink } from "./analysis.js";
 import { ExpressionEmitter } from "./expressions.js";
-import { ARROW, BINARY, POSTFIX } from "./syntax.js";
+import { ARROW, BINARY, POSTFIX, PRIMARY } from "./syntax.js";
 // Calls, `new`, array literals and conversions. A `[]byte` is a Uint8Array: a literal where the
 // checker found one expected becomes `new Uint8Array([...])`, and the conversions of Go between
 // text and its UTF-8 bytes use TextEncoder and TextDecoder, `[]byte(s)` and `string(data)`. In an
@@ -43,6 +43,28 @@ export class CallEmitter extends ExpressionEmitter {
      * given to it, after the local names it uses; the arguments are copied there. In the worker
      * module a literal runs in the same worker, with copies of those names as its first parameters.
      */
+    objectLiteral(node) {
+        if (node.properties.length === 0)
+            return '{}';
+        const properties = node.properties.map((property) => {
+            if (property.kind === 'SpreadElement') {
+                return `...${this.expression(property.argument, ARROW)}`;
+            }
+            const key = property.key.kind === 'StringLiteral' ? property.key.raw : property.key.name;
+            // `fetch(req) { ... }`: a method of JS, whose `this` is the object.
+            if (property.method && property.value.kind === 'FuncExpression') {
+                const [params, body] = this.func(property.value.params, property.value.body);
+                return `${property.value.async ? 'async ' : ''}${key}(${params}) ${body}`;
+            }
+            const value = this.expression(property.value, ARROW);
+            // A renamed shorthand (`{ delete }` → `delete$`) must keep its key.
+            return property.shorthand && value === key ? key : `${key}: ${value}`;
+        });
+        return `{ ${properties.join(', ')} }`;
+    }
+    taggedTemplate(node) {
+        return `${this.expression(node.tag, POSTFIX)}${this.expression(node.quasi, PRIMARY)}`;
+    }
     go(node) {
         const { callee } = node.call;
         const literal = callee.kind === 'FuncExpression' ? callee : null;

package/dist/codegen/component-props.js

@@ -58,10 +58,17 @@ export class ComponentPropsEmitter extends ControlFlowEmitter {
      */
     binder(target) {
         const name = `$$bind${this.nextId()}`;
+        const list = target.kind === 'Identifier' ? this.loopLists.get(target.name) : undefined;
         const text = this.liveExpression(target);
         // `todos` of `bind:todos={todos}`, or the state that `bind:open={menu.open}` writes into.
-        const written = [...(this.reactive?.rootSources(target) ?? [])].filter((source) => source.kind === 'state');
+        const written = [...(this.reactive?.rootSources(list ?? target) ?? [])].filter((source) => source.kind === 'state');
         const body = this.block(() => {
+            // The item of `{for row in rows}`: a new one replaces it in the list, wherever it is now.
+            if (list) {
+                const items = this.liveExpression(list, POSTFIX);
+                this.line(`const $$at = ${items}.indexOf(${text});`);
+                this.line(`if ($$at !== -1) ${items}[$$at] = $$value;`);
+            }
             this.line(`${text} = $$value;`);
             for (const name of rootsOf(target, this.shared)) {
                 this.line(`$$changed(${this.shared.listeners.get(name)});`);

package/dist/codegen/control-flow.d.ts

@@ -8,6 +8,8 @@ import { type Live, type Source } from './reactive.ts';
  * returns its update.
  */
 export declare abstract class ControlFlowEmitter extends ElementEmitter {
+    /** The lists of the `{for}` loops around the code, by the names of their items. */
+    protected readonly loopLists: Map<string, ast.Expression>;
     /** Writes the code that creates the content and returns what to append; see the class. */
     protected liveControl(statement: ControlStatement, live: Live, sources: ReadonlySet<Source>): string;
     /** The choice of an if/else chain, `() => a ? 0 : b ? 1 : -1`, and its blocks. */
@@ -20,6 +22,7 @@ export declare abstract class ControlFlowEmitter extends ElementEmitter {
      * state go into its update. The block of `<Page />` gets the component, `($$component3) => ...`.
      */
     protected blockCreator(statements: readonly ast.Statement[], parent: Live, loop?: ast.ForInStatement, component?: ast.Identifier): string;
+    private blockFunction;
     /** The key of a list, `with key todo.id`: `(todo) => todo.id`, which its blocks are found by. */
     private listKey;
     /** A classic `for` loop in live markup: a function that runs it and returns the content. */

package/dist/codegen/control-flow.js

@@ -9,6 +9,8 @@ import { CONDITIONAL, indentMore, upperFirst } from "./syntax.js";
  * returns its update.
  */
 export class ControlFlowEmitter extends ElementEmitter {
+    /** The lists of the `{for}` loops around the code, by the names of their items. */
+    loopLists = new Map();
     /** Writes the code that creates the content and returns what to append; see the class. */
     liveControl(statement, live, sources) {
         const id = this.nextId();
@@ -88,6 +90,21 @@ export class ControlFlowEmitter extends ElementEmitter {
     blockCreator(statements, parent, loop, component) {
         const block = new Block(parent);
         const params = loop ? loopParameters(loop) : component ? [parameter(component)] : [];
+        const saved = loop && this.loopLists.get(loop.value.name);
+        // `bind:row={row}` in the block writes into the list.
+        if (loop)
+            this.loopLists.set(loop.value.name, loop.iterable);
+        try {
+            return this.blockFunction(block, statements, params, loop);
+        }
+        finally {
+            if (loop && saved)
+                this.loopLists.set(loop.value.name, saved);
+            else if (loop)
+                this.loopLists.delete(loop.value.name);
+        }
+    }
+    blockFunction(block, statements, params, loop) {
         return this.withFunction('none', params, () => this.withRendering(this.rendering + 1, () => {
             const paramList = this.params(params);
             const fragment = `$$block${this.nextId()}`;

package/dist/codegen/expressions.d.ts

@@ -22,6 +22,10 @@ export declare abstract class ExpressionEmitter extends Emitter {
     protected abstract streamChan(node: ast.StreamChanExpression): string;
     protected abstract queue(node: ast.QueueExpression): string;
     protected abstract topic(node: ast.TopicExpression): string;
+    /** `{ a: 1, ...b, f() { ... } }`; implemented by CallEmitter. */
+    protected abstract objectLiteral(node: ast.ObjectLiteral): string;
+    /** sql`select ... ${id}`; implemented by CallEmitter. */
+    protected abstract taggedTemplate(node: ast.TaggedTemplateExpression): string;
     /** `go f(x)`; implemented by CallEmitter. */
     protected abstract go(node: ast.GoExpression): string;
     /** `decode<T>(x)`; implemented by DecodeEmitter. */
@@ -54,7 +58,6 @@ export declare abstract class ExpressionEmitter extends Emitter {
     private expressionWithPrecedence;
     protected elements(elements: readonly (ast.Expression | ast.SpreadElement)[]): string;
     private template;
-    private objectLiteral;
     private arrowFunction;
     private unary;
     private binary;

package/dist/codegen/expressions.js

@@ -82,9 +82,12 @@ export class ExpressionEmitter extends Emitter {
                 return [decoratedName(node.decorator.name, node.member.name), PRIMARY];
             case 'ThisExpression':
                 return ['this', PRIMARY];
-            // `as` is only for the checker.
+            // `as` and `user!` are only for the checker.
             case 'AsExpression':
+            case 'NonNullExpression':
                 return this.expressionWithPrecedence(node.expression);
+            case 'TaggedTemplateExpression':
+                return [this.taggedTemplate(node), POSTFIX];
             case 'SuperExpression':
                 return ['super', PRIMARY];
             case 'ArrayLiteral': {
@@ -171,20 +174,6 @@ export class ExpressionEmitter extends Emitter {
         });
         return `${text}\``;
     }
-    objectLiteral(node) {
-        if (node.properties.length === 0)
-            return '{}';
-        const properties = node.properties.map((property) => {
-            if (property.kind === 'SpreadElement') {
-                return `...${this.expression(property.argument, ARROW)}`;
-            }
-            const key = property.key.kind === 'StringLiteral' ? property.key.raw : property.key.name;
-            const value = this.expression(property.value, ARROW);
-            // A renamed shorthand (`{ delete }` → `delete$`) must keep its key.
-            return property.shorthand && value === key ? key : `${key}: ${value}`;
-        });
-        return `{ ${properties.join(', ')} }`;
-    }
     arrowFunction(node) {
         const { body } = node;
         const async = node.async ? 'async ' : '';

package/dist/codegen/functions.d.ts

@@ -2,6 +2,8 @@ import type * as ast from '../ast.ts';
 import { WebComponentEmitter } from './web-components.ts';
 /** Function bodies and `defer`. */
 export declare abstract class FunctionEmitter extends WebComponentEmitter {
+    /** `a, times = 1, ...parts`: default values and the rest parameter are those of JS. */
+    protected params(params: ast.Parameter[]): string;
     /** Parameters and body of a function, method or func literal. */
     protected func(params: ast.Parameter[], body: ast.BlockStatement): [string, string];
     /**

package/dist/codegen/functions.js

@@ -4,6 +4,19 @@ import { WebComponentEmitter } from "./web-components.js";
 import { ARROW, POSTFIX } from "./syntax.js";
 /** Function bodies and `defer`. */
 export class FunctionEmitter extends WebComponentEmitter {
+    /** `a, times = 1, ...parts`: default values and the rest parameter are those of JS. */
+    params(params) {
+        const names = super.params(params).split(', ');
+        return params
+            .map((param, i) => {
+            if (param.rest)
+                return `...${names[i]}`;
+            return param.defaultValue
+                ? `${names[i]} = ${this.expression(param.defaultValue, ARROW)}`
+                : names[i];
+        })
+            .join(', ');
+    }
     /** Parameters and body of a function, method or func literal. */
     func(params, body) {
         const defers = findDefers(body);

package/dist/codegen/mutations.d.ts

@@ -4,6 +4,12 @@ import type { Type } from '../checker/types.ts';
 export declare function rootName(node: ast.Expression): string | null;
 /** Names whose values a node reads, not counting code that runs on events. */
 export declare function readNames(node: ast.Node, names: Set<string>): void;
+/**
+ * Names of the functions that code may run while it runs: those it calls and those it gives to a
+ * call, `items.map(format)`. A function it only gives as a value, `act={copy}` or
+ * `act={() => show("x")}`, runs later, when whoever gets it calls it.
+ */
+export declare function calledNames(node: ast.Node, names: Set<string>): void;
 /**
  * Names an effect reads while it runs: not in the functions it creates, which run later, nor in
  * its `defer`, nor the variables it writes, or `count++` would run it again.

package/dist/codegen/mutations.js

@@ -57,6 +57,42 @@ export function readNames(node, names) {
             forEachChild(node, (child) => readNames(child, names));
     }
 }
+/**
+ * Names of the functions that code may run while it runs: those it calls and those it gives to a
+ * call, `items.map(format)`. A function it only gives as a value, `act={copy}` or
+ * `act={() => show("x")}`, runs later, when whoever gets it calls it.
+ */
+export function calledNames(node, names) {
+    switch (node.kind) {
+        case 'CallExpression':
+            if (node.callee.kind === 'Identifier')
+                names.add(node.callee.name);
+            else
+                calledNames(node.callee, names);
+            for (const arg of node.arguments) {
+                if (arg.kind === 'Identifier')
+                    names.add(arg.name);
+                else if (arg.kind === 'ArrowFunction' || arg.kind === 'FuncExpression') {
+                    forEachChild(arg, (child) => calledNames(child, names));
+                }
+                else
+                    calledNames(arg, names);
+            }
+            return;
+        case 'ArrowFunction':
+        case 'FuncExpression':
+        case 'EventHandler':
+        case 'MountStatement':
+        case 'EffectStatement':
+            return;
+        case 'JsxAttribute':
+            if (node.value !== null && !/^on[A-Z]/.test(node.name.name))
+                calledNames(node.value, names);
+            return;
+        default:
+            forEachChild(node, (child) => calledNames(child, names));
+    }
+}
 /**
  * Names an effect reads while it runs: not in the functions it creates, which run later, nor in
  * its `defer`, nor the variables it writes, or `count++` would run it again.

package/dist/codegen/options.d.ts

@@ -33,6 +33,8 @@ export interface JsOptions {
     dataClasses?: ReadonlySet<string> | undefined;
     /** State of other modules that this one imports, `local → name there`: it only reads it. */
     shared?: ReadonlyMap<string, string> | undefined;
+    /** What each `export { ... } from` passes on in JS, with hidden names (reexports.ts). */
+    reexports?: ReadonlyMap<ast.ExportFromDeclaration, readonly string[]> | undefined;
 }
 /** A decorator of another module, with the types of the expressions of that module. */
 export interface ImportedDecorator extends DecoratorSource {

package/dist/codegen/reactive.js

@@ -2,7 +2,7 @@ import { ownStatements } from "../checker/helpers.js";
 import { wrappedMarkup } from "../decorators.js";
 import { containsReturn, returnedMarkup } from "../recursion.js";
 import { forEachChild } from "../walk.js";
-import { readNames, rootName, writeTargets } from "./mutations.js";
+import { calledNames, 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();
@@ -69,19 +69,23 @@ export class Reactive {
             ...wrappedMarkup(component),
         ];
         const seen = new Set();
-        const visit = (node) => {
+        // A function the markup only gives away, `act={copy}`, runs later and keeps its updates.
+        const visit = (node, body = false) => {
             const names = new Set();
-            readNames(node, names);
+            if (body)
+                forEachChild(node, (child) => calledNames(child, names));
+            else
+                calledNames(node, names);
             for (const name of names) {
                 const fn = this.functions.get(name);
                 if (!fn || seen.has(name))
                     continue;
                 seen.add(name);
                 this.renderFunctions.add(fn);
-                visit(fn);
+                visit(fn, true);
             }
         };
-        markup.forEach(visit);
+        markup.forEach((node) => visit(node));
     }
     /** Whether a statement of the body declares a function that the live markup calls. */
     declaresRenderFunction(node) {

package/dist/codegen/simple-statements.js

@@ -170,8 +170,10 @@ export class SimpleStatementEmitter extends TryEmitter {
             case 'EffectStatement':
                 this.effectStatement(node);
                 break;
+            // Components write their styles themselves (ComponentEmitter), and StatementEmitter the
+            // exports of other modules.
             case 'StyleStatement':
-                // Components write their styles themselves (ComponentEmitter).
+            case 'ExportFromDeclaration':
                 break;
         }
     }

package/dist/codegen/statements.d.ts

@@ -20,6 +20,10 @@ export declare abstract class StatementEmitter extends ParallelLoopEmitter {
      * decorators uses, and that of exported components when other modules inline them.
      */
     protected hiddenExports(): void;
+    /** `const { name, size: bytes, ...rest } = file`, as in JS. */
+    protected variableDeclaration(node: ast.VariableDeclaration): string;
+    /** `export { Rows } from "./rows.js"` with the hidden names that go with them (reexports.ts). */
+    private exportFrom;
     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. */

package/dist/codegen/statements.js

@@ -17,6 +17,10 @@ export class StatementEmitter extends ParallelLoopEmitter {
     sharedReads = null;
     /** State of the module: the updates of the components that read it are kept beside it. */
     emitStatement(node) {
+        if (node.kind === 'ExportFromDeclaration') {
+            this.exportFrom(node);
+            return;
+        }
         super.emitStatement(node);
         if (node.kind !== 'VariableDeclaration' || node.keyword !== 'state')
             return;
@@ -124,9 +128,34 @@ export class StatementEmitter extends ParallelLoopEmitter {
         this.blankLine();
         this.line(`export { ${names.join(', ')} };`);
     }
+    /** `const { name, size: bytes, ...rest } = file`, as in JS. */
+    variableDeclaration(node) {
+        if (!node.pattern)
+            return super.variableDeclaration(node);
+        const { keys, rest } = node.pattern;
+        const fields = keys.map((key, i) => {
+            const name = this.name(node.names[i].name);
+            const field = key.kind === 'StringLiteral' ? key.raw : key.name;
+            return field === name ? name : `${field}: ${name}`;
+        });
+        if (rest)
+            fields.push(`...${this.name(node.names.at(-1).name)}`);
+        return `${node.keyword} { ${fields.join(', ')} } = ${this.expression(node.values[0], ARROW)}`;
+    }
+    /** `export { Rows } from "./rows.js"` with the hidden names that go with them (reexports.ts). */
+    exportFrom(node) {
+        const source = this.importPath(node.source);
+        const names = node.specifiers ? (this.options.reexports?.get(node) ?? []) : null;
+        if (names === null)
+            this.line(`export * from ${source};`);
+        else if (names.length > 0)
+            this.line(`export { ${names.join(', ')} } from ${source};`);
+    }
     importPath(source) {
         const path = source.value;
-        if (this.options.rewriteImports && /^\.{1,2}\//.test(path) && path.endsWith('.rk')) {
+        // `./button.rk` and the aliases `#ui/button.rk` and `@/ui/button.rk` (aliases.ts): the built
+        // module is next to its source.
+        if (this.options.rewriteImports && !isBare(path) && path.endsWith('.rk')) {
             return JSON.stringify(`${path.slice(0, -'.rk'.length)}.js`);
         }
         return source.raw;
@@ -235,3 +264,10 @@ function hash(text) {
     }
     return value.toString(16).padStart(8, '0');
 }
+/** `pkg/file.rk` of another package, which is not built with this one. */
+function isBare(path) {
+    return (!/^\.{1,2}\//.test(path) &&
+        !path.startsWith('#') &&
+        !path.startsWith('@/') &&
+        !path.startsWith('~/'));
+}

package/dist/codegen/updates.d.ts

@@ -19,6 +19,8 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     protected rendering: number;
+    /** Functions that live markup gives as values: they run later, not while it is rendered. */
+    private readonly later;
     /**
      * After a statement that changes state of the module, the updates of the components that read
      * it; code that renders markup changes none, as with the state of a component.
@@ -41,9 +43,12 @@ export declare abstract class UpdateEmitter extends StatementEmitter {
     protected liveFunction(node: ast.Expression): string;
     /**
      * An expression that is evaluated again on updates: elements inside it are created in place,
-     * so that each evaluation creates new ones.
+     * so that each evaluation creates new ones. A function that it gives as a value, as to a property
+     * `onAdd={() => count++}`, runs later, so what it changes updates the markup as it does in the
+     * value the markup was created with.
      */
     protected liveExpression(node: ast.Expression, precedence?: number): string;
+    protected expression(node: ast.Expression, minPrecedence: number, forceParens?: boolean): string;
 }
 /**
  * Replaces the markers of a component's sources: by the call of the update function, by the only

package/dist/codegen/updates.js

@@ -1,7 +1,7 @@
 import { widenLiterals } from "../checker/types.js";
 import { updatesOf } from "./reactive.js";
 import { StatementEmitter } from "./statements.js";
-import { startsWithObjectLiteral } from "./analysis.js";
+import { functionValues, startsWithObjectLiteral } from "./analysis.js";
 import { sharedWrites } from "./shared.js";
 import { ARROW } from "./syntax.js";
 /**
@@ -21,6 +21,8 @@ export class UpdateEmitter extends StatementEmitter {
      * the markup, which would update it again; code that runs later (handlers) is not included.
      */
     rendering = 0;
+    /** Functions that live markup gives as values: they run later, not while it is rendered. */
+    later = new WeakSet();
     /**
      * After a statement that changes state of the module, the updates of the components that read
      * it; code that renders markup changes none, as with the state of a component.
@@ -157,11 +159,20 @@ export class UpdateEmitter extends StatementEmitter {
     }
     /**
      * An expression that is evaluated again on updates: elements inside it are created in place,
-     * so that each evaluation creates new ones.
+     * so that each evaluation creates new ones. A function that it gives as a value, as to a property
+     * `onAdd={() => count++}`, runs later, so what it changes updates the markup as it does in the
+     * value the markup was created with.
      */
     liveExpression(node, precedence = ARROW) {
+        for (const value of functionValues(node))
+            this.later.add(value);
         return this.withRendering(this.rendering + 1, () => this.withHoisting(false, () => this.expression(node, precedence)));
     }
+    expression(node, minPrecedence, forceParens = false) {
+        return this.later.has(node)
+            ? this.withRendering(0, () => super.expression(node, minPrecedence, forceParens))
+            : super.expression(node, minPrecedence, forceParens);
+    }
 }
 /**
  * Replaces the markers of a component's sources: by the call of the update function, by the only

package/dist/compile.js

@@ -6,6 +6,7 @@ import { goroutines, goTarget, workerProgram } from "./goroutines.js";
 import { withoutMarks } from "./source-map.js";
 import { parse } from "./parser/parser.js";
 import { isStyleModule, styleModule, unusedClasses } from "./style-modules.js";
+import { reexportedNames } from "./reexports.js";
 /**
  * Where the worker module of a module is: a `.worker.js` next to its `.js`, or, where `.rk`
  * files are imported as they are (`rook run`), the module itself with `?goroutines`. Vite drops
@@ -48,6 +49,7 @@ export function compileModule(source, options = {}) {
         runtime: options.runtime,
         dataClasses,
         ...importedCode(program, options.importModule),
+        reexports: reexportedNames(program, options.importModule),
     };
     const sourceName = options.sourceName ?? 'main.rk';
     const main = withoutMarks(generateJs(program, {

package/dist/completion.js

@@ -16,7 +16,8 @@ const STRINGS = new Set([
     'CssText',
     'RegExp',
 ]);
-const VALUE_KEYWORDS = KEYWORDS;
+// `type` is a keyword only at the start of a statement, where it is offered too.
+const VALUE_KEYWORDS = [...KEYWORDS, 'type'];
 // `queue` is a type of its own only in a type: elsewhere it is a name.
 const TYPE_KEYWORDS = ['func', 'comp', 'chan', 'queue', 'topic'];
 /** Keywords only at the start of a statement at the top level of a component or a decorator. */

package/dist/declarations.js

@@ -29,6 +29,10 @@ class DeclarationPrinter {
                 case 'ImportDeclaration':
                     this.importDeclaration(statement);
                     break;
+                case 'ExportFromDeclaration':
+                    exports = true;
+                    this.exportFrom(statement);
+                    break;
                 case 'FuncDeclaration':
                     if (statement.exported)
                         this.functionDeclaration(statement);
@@ -73,6 +77,20 @@ class DeclarationPrinter {
         const source = node.source.value.replace(/\.rk$/, '.js');
         this.lines.push(`import ${parts.join(', ')} from ${JSON.stringify(source)};`);
     }
+    /** `export { Row } from "./rows.js"`: the values and types it passes on; components have none. */
+    exportFrom(node) {
+        const source = JSON.stringify(node.source.value.replace(/\.rk$/, '.js'));
+        if (!node.specifiers) {
+            this.lines.push(`export * from ${source};`);
+            return;
+        }
+        const { exports } = this.checked;
+        const names = node.specifiers
+            .filter(({ local }) => exports.values.has(local.name) || exports.types.has(local.name))
+            .map(({ imported, local }) => imported.name === local.name ? local.name : `${imported.name} as ${local.name}`);
+        if (names.length > 0)
+            this.lines.push(`export { ${names.join(', ')} } from ${source};`);
+    }
     functionDeclaration(node) {
         const type = this.checked.declarations.values.get(node.name.name);
         if (type?.kind !== 'function')

package/dist/lexer/base.d.ts

@@ -14,8 +14,9 @@ export declare abstract class LexerBase {
     protected lastEndsValue(): boolean;
     protected lastEndsStatement(): boolean;
     /**
-     * Unlike Go, a line starting with `.` / `?.` continues a method chain, and a line starting with
-     * a closing bracket ends a list, so no semicolon is needed before it.
+     * Unlike Go, a line starting with `.` / `?.` continues a method chain, a line starting with `?`
+     * or `:` continues a conditional expression, and a line starting with a closing bracket ends a
+     * list, so no semicolon is needed before it.
      */
     protected nextLineContinues(): boolean;
     protected insertSemicolon(): void;

package/dist/lexer/base.js

@@ -55,21 +55,30 @@ export class LexerBase {
     }
     lastEndsStatement() {
         const last = this.tokens.at(-1);
-        return last !== undefined && ENDS_STATEMENT.has(last.kind);
+        if (last === undefined)
+            return false;
+        // `env.PORT!` at the end of a line: the `!` right after a value, which takes it not to be null.
+        if (last.kind === '!') {
+            const before = this.tokens.at(-2);
+            return before !== undefined && before.end === last.start && ENDS_VALUE.has(before.kind);
+        }
+        return ENDS_STATEMENT.has(last.kind);
     }
     /**
-     * Unlike Go, a line starting with `.` / `?.` continues a method chain, and a line starting with
-     * a closing bracket ends a list, so no semicolon is needed before it.
+     * Unlike Go, a line starting with `.` / `?.` continues a method chain, a line starting with `?`
+     * or `:` continues a conditional expression, and a line starting with a closing bracket ends a
+     * list, so no semicolon is needed before it.
      */
     nextLineContinues() {
         const t = this.text;
         const c = t[this.pos];
         const next = t[this.pos + 1];
-        if (c === ')' || c === ']' || c === '}')
+        if (c === ')' || c === ']' || c === '}' || c === ':')
             return true;
         if (c === '.')
             return next !== '.' && !isDigit(next);
-        return c === '?' && next === '.' && !isDigit(t[this.pos + 2]);
+        // `? "yes"` and `?.name`, but not `??`, which stays at the end of the line as other operators.
+        return c === '?' && next !== '?';
     }
     insertSemicolon() {
         const end = this.tokens.at(-1)?.end ?? 0;

package/dist/lexer/lexer.js

@@ -30,7 +30,10 @@ class Lexer extends StyleLexer {
             }
             if (this.pos >= this.text.length)
                 break;
+            const count = this.tokens.length;
             this.scanToken();
+            if (sawNewline && this.tokens.length > count)
+                this.tokens[count].newlineBefore = true;
         }
         if (this.lastEndsStatement())
             this.insertSemicolon();

package/dist/lexer/token.d.ts

@@ -1,4 +1,4 @@
-export declare const KEYWORDS: readonly ["func", "comp", "go", "chan", "return", "let", "const", "type", "interface", "class", "extends", "new", "this", "super", "if", "else", "for", "in", "break", "continue", "switch", "case", "default", "defer", "try", "catch", "finally", "throw", "import", "export", "null", "true", "false", "typeof", "instanceof", "async", "await"];
+export declare const KEYWORDS: readonly ["func", "comp", "go", "chan", "return", "let", "const", "interface", "class", "extends", "new", "this", "super", "if", "else", "for", "in", "break", "continue", "switch", "case", "default", "defer", "try", "catch", "finally", "throw", "import", "export", "null", "true", "false", "typeof", "instanceof", "async", "await"];
 export declare const PUNCTUATORS: readonly ["{", "}", "(", ")", "[", "]", ";", ",", ":", ".", "...", "?", "?.", "??", "=>", "=", "+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "&&=", "||=", "??=", "==", "!=", "<", "<-", ">", "<=", ">=", "+", "-", "*", "/", "%", "**", "++", "--", "&", "|", "^", "~", "<<", ">>", ">>>", "&&", "||", "!", "@"];
 export type Keyword = (typeof KEYWORDS)[number];
 export type Punctuator = (typeof PUNCTUATORS)[number];
@@ -24,6 +24,11 @@ interface TokenBase {
     text: string;
     start: number;
     end: number;
+    /**
+     * A line break comes before the token. No semicolon is inserted after `>`, which may be an
+     * operator; the parser ends a declaration after `Map<string, number>` by it.
+     */
+    newlineBefore?: boolean;
 }
 export interface NumberToken extends TokenBase {
     kind: 'Number';

package/dist/lexer/token.js

@@ -6,7 +6,6 @@ export const KEYWORDS = [
     'return',
     'let',
     'const',
-    'type',
     'interface',
     'class',
     'extends',

package/dist/modules.js

@@ -1,5 +1,5 @@
 import { readFileSync, statSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { resolveRookModule } from "./aliases.js";
 import { check } from "./checker/checker.js";
 import { markupFor } from "./config.js";
 import { parse } from "./parser/parser.js";
@@ -9,9 +9,10 @@ const cache = new Map();
 const loading = new Set();
 /** Finds the types exported by a `.rk` module imported from the file `fromFile`. */
 export function loadModuleExports(fromFile, specifier, markup) {
-    if (!specifier.startsWith('./') && !specifier.startsWith('../'))
+    // A relative path, or an alias of package.json or tsconfig.json (aliases.ts).
+    const path = specifier.endsWith('.rk') ? resolveRookModule(fromFile, specifier) : null;
+    if (path === null)
         return undefined;
-    const path = resolve(dirname(fromFile), specifier);
     let version;
     try {
         const stats = statSync(path);

package/dist/parser/base.d.ts

@@ -66,6 +66,11 @@ export declare abstract class ParserBase {
     protected requireMarkup(what: string): void;
     protected peek(offset?: number): Token;
     protected check(kind: TokenKind): boolean;
+    /**
+     * The line ended with the `>` of type arguments, `votes Map<string, number>`: the lexer inserts
+     * no semicolon after `>`, which may be an operator, so the line break ends the declaration here.
+     */
+    protected afterTypeArguments(): boolean;
     /** Whether the current token is the word `word`, e.g. the contextual keyword `from`. */
     protected checkWord(word: string): boolean;
     protected next(): Token;