rooklang 0.3.2 → 0.3.4

package/dist/completion.d.ts

@@ -1,10 +1,12 @@
-import { type Completion } from './checker/checker.ts';
+import { type Completion, type CompletionContext } from './checker/checker.ts';
 import { type CoreCompileOptions } from './compile.ts';
-export type { Completion, CompletionContext } from './checker/checker.ts';
+export type { Completion, CompletionContext, TextEdit } from './checker/checker.ts';
 export interface CompletionList {
     /** Offsets of what the chosen item replaces: the part of the name before the cursor. */
     start: number;
     end: number;
+    /** What the cursor is in; none where nothing is suggested or the check did not reach it. */
+    context?: CompletionContext;
     items: Completion[];
 }
 export declare function completeModule(source: string, offset: number, options?: CoreCompileOptions): CompletionList;

package/dist/completion.js

@@ -1,9 +1,8 @@
-import { check } from "./checker/checker.js";
+import { check, } from "./checker/checker.js";
 import { prepareCheck } from "./compile.js";
 import { tokenize } from "./lexer/lexer.js";
 import { KEYWORDS } from "./lexer/token.js";
 import { parse } from "./parser/parser.js";
-import { RESERVED } from "./parser/syntax.js";
 import { forEachChild } from "./walk.js";
 const CURSOR = '$$cursor';
 const STRINGS = new Set([
@@ -15,10 +14,11 @@ const STRINGS = new Set([
     'JsxText',
     'JsxString',
     'CssText',
+    'RegExp',
 ]);
-const VALUE_KEYWORDS = KEYWORDS.filter((keyword) => !RESERVED.has(keyword));
+const VALUE_KEYWORDS = KEYWORDS;
 // `queue` is a type of its own only in a type: elsewhere it is a name.
-const TYPE_KEYWORDS = ['func', 'comp', 'chan', 'queue'];
+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. */
 const COMPONENT_KEYWORDS = ['state', 'derived', 'ref', 'style', 'effect', 'mount'];
 export function completeModule(source, offset, options = {}) {
@@ -55,7 +55,12 @@ export function completeModule(source, offset, options = {}) {
         const { program } = parse(text, { markup: options.markup ?? true });
         const result = completeIn(program, options);
         if (result) {
-            return { start, end: offset, items: withKeywords(result, statementKeywords(program)) };
+            return {
+                start,
+                end: offset,
+                context: result.context,
+                items: withKeywords(result, statementKeywords(program)),
+            };
         }
         // The cursor is where a name is declared, `let ti|`: nothing to suggest.
         if (pathTo(program, CURSOR).length > 0)

package/dist/declarations.js

@@ -137,7 +137,7 @@ class DeclarationPrinter {
             switch (member.kind) {
                 case 'FieldDeclaration': {
                     const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
-                    const modifiers = this.modifiers(member.visibility, member.isStatic);
+                    const modifiers = this.modifiers(member.visibility, member.isStatic, member.readonly);
                     // As in the declaration files TypeScript writes, private members have no type.
                     if (member.visibility === 'private')
                         lines.push(`${modifiers}${member.name.name};`);
@@ -147,6 +147,17 @@ class DeclarationPrinter {
                 }
                 case 'ConstructorDeclaration': {
                     const modifiers = this.modifiers(member.visibility, false);
+                    // The parameters that are properties are declared as fields, as TypeScript writes them.
+                    member.params.forEach((param, i) => {
+                        const { property } = param;
+                        const type = info.ctor?.params[i];
+                        if (!property)
+                            return;
+                        const field = `${this.modifiers(property.visibility, false, property.readonly)}${param.name.name}`;
+                        lines.push(property.visibility === 'private' || !type
+                            ? `${field};`
+                            : `${field}: ${tsType(type)};`);
+                    });
                     if (info.ctor) {
                         lines.push(`${modifiers}constructor${parameters(member.params, info.ctor)};`);
                     }
@@ -154,8 +165,11 @@ class DeclarationPrinter {
                 }
                 case 'MethodDeclaration': {
                     const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
-                    const modifiers = this.modifiers(member.visibility, member.isStatic);
-                    if (member.visibility === 'private')
+                    const modifiers = this.modifiers(member.visibility, member.isStatic) +
+                        (member.abstract ? 'abstract ' : '');
+                    if (member.accessor)
+                        lines.push(accessor(member, modifiers, found?.type));
+                    else if (member.visibility === 'private')
                         lines.push(`${modifiers}${member.name.name}();`);
                     else if (found?.type.kind === 'function') {
                         lines.push(`${modifiers}${member.name.name}${this.signature(member.params, found.type)};`);
@@ -164,10 +178,11 @@ class DeclarationPrinter {
                 }
             }
         }
-        this.lines.push(`${exported}declare class ${jsName(node.name.name)}${this.typeParams(info.typeParams)}${heritage} {`, ...lines.map((line) => `    ${line}`), '}');
+        this.lines.push(`${exported}declare ${node.abstract ? 'abstract ' : ''}class ${jsName(node.name.name)}${this.typeParams(info.typeParams)}${heritage} {`, ...lines.map((line) => `    ${line}`), '}');
     }
-    modifiers(visibility, isStatic) {
-        return `${visibility === 'public' ? '' : `${visibility} `}${isStatic ? 'static ' : ''}`;
+    modifiers(visibility, isStatic, readonly) {
+        return (`${visibility === 'public' ? '' : `${visibility} `}${isStatic ? 'static ' : ''}` +
+            (readonly ? 'readonly ' : ''));
     }
     /** `<T, U extends Shape>` */
     typeParams(params) {
@@ -191,6 +206,17 @@ function parameters(params, type) {
     });
     return `(${list.join(', ')})`;
 }
+/** `get area(): number;` or `set area(v: number);`; a private one, as TypeScript writes it, untyped. */
+function accessor(node, modifiers, type) {
+    const head = `${modifiers}${node.accessor} ${node.name.name}`;
+    const param = jsName(node.params[0]?.name.name ?? 'value');
+    if (node.visibility === 'private' || !type) {
+        return node.accessor === 'get' ? `${head}();` : `${head}(${param});`;
+    }
+    return node.accessor === 'get'
+        ? `${head}(): ${tsType(type)};`
+        : `${head}(${param}: ${tsType(type)});`;
+}
 /** `Base` or `events.EventEmitter` in `extends`; other expressions cannot be written in types. */
 function expressionName(node) {
     if (node.kind === 'Identifier')

package/dist/decorator-copy.js

@@ -47,7 +47,10 @@ export function renamer(renames, copied, other = {}) {
     const generic = (node, hidden) => {
         const result = {};
         for (const [key, value] of Object.entries(node)) {
-            if (Array.isArray(value)) {
+            // Labels are not values: `outer: for` and `break outer` keep their names.
+            if (key === 'label')
+                result[key] = value;
+            else if (Array.isArray(value)) {
                 result[key] = value.map((item) => (isNode(item) ? copy(item, hidden) : item));
             }
             else {
@@ -106,7 +109,7 @@ export function renamer(renames, copied, other = {}) {
                 return done({
                     ...node,
                     params: node.params.map((param) => copy(param, inner)),
-                    body: copy(node.body, inner),
+                    body: node.body && copy(node.body, inner),
                 }, node);
             }
             case 'FieldDeclaration':

package/dist/goroutines.d.ts

@@ -34,4 +34,4 @@ export declare function reach(program: ast.Program, names: Iterable<string>): Re
  * The program of the worker module: the imports and the declarations that the functions `targets`
  * reach, unexported, since the worker module is only loaded by the worker.
  */
-export declare function workerProgram(program: ast.Program, targets: readonly string[]): ast.Program;
+export declare function workerProgram(program: ast.Program, targets: readonly string[], dataClasses?: Iterable<string>): ast.Program;

package/dist/goroutines.js

@@ -165,9 +165,10 @@ export function reach(program, names) {
  * The program of the worker module: the imports and the declarations that the functions `targets`
  * reach, unexported, since the worker module is only loaded by the worker.
  */
-export function workerProgram(program, targets) {
+export function workerProgram(program, targets, dataClasses = []) {
     const lifted = { ...program, body: [...program.body, ...literalFunctions(program)] };
-    const { statements, imports } = reach(lifted, targets);
+    // The data classes come too, so that their instances get their class here (runtime/classes.js).
+    const { statements, imports } = reach(lifted, [...targets, ...dataClasses]);
     const body = [];
     for (const [statement, names] of imports) {
         body.push({
@@ -229,8 +230,8 @@ function usedNames(statement) {
                     if (member.value)
                         add(freeNames({ params: [], body: block([expression(member.value)]) }));
                 }
-                else {
-                    add(freeNames(member));
+                else if (member.body) {
+                    add(freeNames({ params: member.params, body: member.body }));
                 }
             }
             return names;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { type CompileResult } from './compile.ts';
 import { type CompletionList } from './completion.ts';
+export { importFixes, type ImportFix } from './auto-import.ts';
 export type { CompileResult } from './compile.ts';
-export type { Completion, CompletionList } from './completion.ts';
+export type { Completion, CompletionList, TextEdit } from './completion.ts';
 export type { Diagnostic } from './diagnostics.ts';
 export { formatDiagnostic } from './diagnostics.ts';
 export { SourceFile } from './source.ts';
@@ -19,6 +20,8 @@ export interface CompileOptions {
     declarations?: boolean;
     /** Where the worker module of `go` is, relative to the module; see workerUrl() in compile.ts. */
     workerUrl?: string;
+    /** A module that a worker thread of Node imports first, to load `.rk` files (vite.ts). */
+    nodeLoader?: string;
     /** Markup and components; by default as the package.json of the file says (src/config.ts). */
     markup?: boolean;
     /** Import the runtime from "rooklang/runtime", the default, or put it into the module. */
@@ -27,7 +30,8 @@ export interface CompileOptions {
 export declare function compile(source: string, options?: CompileOptions): CompileResult;
 /**
  * What can be written at `offset` in a module, for editors: names, members, types, tags and
- * attributes. The imports are read from disk, like those of `compile`.
+ * attributes, and after them the names that other modules of the package export, with the imports
+ * they need. The imports are read from disk, like those of `compile`.
  */
 export declare function complete(source: string, offset: number, options?: {
     filename?: string;

package/dist/index.js

@@ -1,10 +1,12 @@
+import { importCompletions } from "./auto-import.js";
 import { compileModule, workerUrl, } from "./compile.js";
 import { completeModule } from "./completion.js";
 import { markupFor } from "./config.js";
 import { loadModuleExports } from "./modules.js";
 import { readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { importDeclarations, libraryFor } from "./typescript/importer.js";
+export { importFixes } from "./auto-import.js";
 export { formatDiagnostic } from "./diagnostics.js";
 export { SourceFile } from "./source.js";
 export function compile(source, options = {}) {
@@ -16,20 +18,27 @@ export function compile(source, options = {}) {
         markup,
         rewriteImports,
         workerUrl: options.workerUrl ?? workerUrl(filename ?? 'main.rk', rewriteImports),
+        nodeLoader: options.nodeLoader,
         typeCheck: options.typeCheck ?? true,
         declarations: options.declarations ?? false,
         runtime: options.runtime,
+        sourceName: filename === undefined ? undefined : basename(filename),
     });
 }
 /**
  * What can be written at `offset` in a module, for editors: names, members, types, tags and
- * attributes. The imports are read from disk, like those of `compile`.
+ * attributes, and after them the names that other modules of the package export, with the imports
+ * they need. The imports are read from disk, like those of `compile`.
  */
 export function complete(source, offset, options = {}) {
-    return completeModule(source, offset, {
-        ...filesOf(options.filename, true, options.markup),
-        markup: options.markup ?? markupFor(options.filename),
+    const { filename } = options;
+    const list = completeModule(source, offset, {
+        ...filesOf(filename, true, options.markup),
+        markup: options.markup ?? markupFor(filename),
     });
+    if (filename === undefined)
+        return list;
+    return { ...list, items: [...list.items, ...importCompletions(source, filename, list)] };
 }
 /** Reading what a module imports: other modules, declarations, CSS modules and the library. */
 function filesOf(filename, typeCheck, markup) {

package/dist/lexer/base.d.ts

@@ -10,6 +10,8 @@ export declare abstract class LexerBase {
     constructor(text: string);
     /** Skips whitespace and comments; returns whether a line break was skipped. */
     protected skipTrivia(): boolean;
+    /** After a value `/` divides; elsewhere it starts a regular expression, as in JS. */
+    protected lastEndsValue(): boolean;
     protected lastEndsStatement(): boolean;
     /**
      * Unlike Go, a line starting with `.` / `?.` continues a method chain, and a line starting with

package/dist/lexer/base.js

@@ -1,4 +1,4 @@
-import { ENDS_STATEMENT, isDigit } from "./tables.js";
+import { ENDS_STATEMENT, ENDS_VALUE, isDigit } from "./tables.js";
 // The lexer is a chain of layers: base → literals → markup → style → Lexer (lexer.ts). This layer
 // keeps the position and the modes (code, markup tags, markup content, CSS), skips spaces and
 // comments, and inserts semicolons at the ends of lines.
@@ -48,6 +48,11 @@ export class LexerBase {
         }
         return sawNewline;
     }
+    /** After a value `/` divides; elsewhere it starts a regular expression, as in JS. */
+    lastEndsValue() {
+        const last = this.tokens.at(-1);
+        return last !== undefined && ENDS_VALUE.has(last.kind);
+    }
     lastEndsStatement() {
         const last = this.tokens.at(-1);
         return last !== undefined && ENDS_STATEMENT.has(last.kind);

package/dist/lexer/lexer.js

@@ -71,6 +71,9 @@ class Lexer extends StyleLexer {
             this.push('}', start, start + 1);
             this.modes.pop();
         }
+        else if (c === '/' && !this.lastEndsValue()) {
+            this.scanRegExp(start);
+        }
         else if (c === '<' && this.startsElement()) {
             this.push('JsxTagOpen', start, start + 1);
             this.modes.push({ kind: 'tag', start });

package/dist/lexer/literals.d.ts

@@ -1,6 +1,11 @@
 import { LexerBase } from './base.ts';
 import { type CharTest } from './tables.ts';
 export declare abstract class LiteralLexer extends LexerBase {
+    /**
+     * `/ab+c/gi`: the pattern goes up to a `/` that is not escaped or inside `[...]`, on one line,
+     * as in JS. JS checks the pattern when it loads the module, so an invalid one is an error here.
+     */
+    protected scanRegExp(start: number): void;
     protected scanNumber(start: number): void;
     /** Consumes digits and `_` separators starting at `pos`; returns the end offset. */
     protected scanDigits(pos: number, isValid: CharTest): number;

package/dist/lexer/literals.js

@@ -1,7 +1,57 @@
 import { LexerBase } from "./base.js";
 import { IDENTIFIER, SIMPLE_ESCAPES, isDigit, isHexDigit, isOctalDigit, isBinaryDigit, } from "./tables.js";
-// Numbers, strings, template strings and escapes.
+// Numbers, strings, template strings, regular expressions and escapes.
+/** The flags of a regular expression, each at most once. */
+const FLAGS = /^(?!.*(.).*\1)[dgimsuvy]*$/;
 export class LiteralLexer extends LexerBase {
+    /**
+     * `/ab+c/gi`: the pattern goes up to a `/` that is not escaped or inside `[...]`, on one line,
+     * as in JS. JS checks the pattern when it loads the module, so an invalid one is an error here.
+     */
+    scanRegExp(start) {
+        const t = this.text;
+        let pos = start + 1;
+        let inClass = false;
+        while (pos < t.length && t[pos] !== '\n' && (inClass || t[pos] !== '/')) {
+            if (t[pos] === '\\' && t[pos + 1] !== '\n')
+                pos++;
+            else if (t[pos] === '[')
+                inClass = true;
+            else if (t[pos] === ']')
+                inClass = false;
+            pos++;
+        }
+        const pattern = t.slice(start + 1, pos);
+        if (t[pos] !== '/') {
+            this.error('unterminated regular expression: end it with "/"', start, pos);
+            this.tokens.push({
+                kind: 'RegExp',
+                text: t.slice(start, pos),
+                value: pattern,
+                start,
+                end: pos,
+            });
+            this.pos = pos;
+            return;
+        }
+        IDENTIFIER.lastIndex = pos + 1;
+        const flags = IDENTIFIER.exec(t)?.[0] ?? '';
+        const end = pos + 1 + flags.length;
+        this.tokens.push({ kind: 'RegExp', text: t.slice(start, end), value: pattern, start, end });
+        this.pos = end;
+        if (!FLAGS.test(flags) || (flags.includes('u') && flags.includes('v'))) {
+            this.error(`invalid flags "${flags}" of a regular expression: each of d, g, i, m, s, u, v and y goes once, and not u with v`, pos + 1, end);
+            return;
+        }
+        try {
+            new RegExp(pattern, flags);
+        }
+        catch (error) {
+            // "Invalid regular expression: /(/: Unterminated group" → "unterminated group".
+            const reason = error.message.replace(/^.*: /, '');
+            this.error(`invalid regular expression: ${reason.charAt(0).toLowerCase()}${reason.slice(1)}`, start, end);
+        }
+    }
     scanNumber(start) {
         const t = this.text;
         let pos = start;

package/dist/lexer/markup.js

@@ -1,14 +1,13 @@
 import { LiteralLexer } from "./literals.js";
-import { ENDS_VALUE, JSX_NAME, decodeEntities } from "./tables.js";
+import { JSX_NAME, decodeEntities } from "./tables.js";
 // Markup: where an element starts, tags with their attributes, and text content.
 export class MarkupLexer extends LiteralLexer {
     /** `<` starts markup where a value is expected and is "less than" after a value. */
     startsElement() {
-        const last = this.tokens.at(-1);
-        if (last && ENDS_VALUE.has(last.kind))
+        if (this.lastEndsValue())
             return false;
         // `chan<number>(10)` makes a channel: its `<` opens the type of the values.
-        if (last?.kind === 'chan')
+        if (this.tokens.at(-1)?.kind === 'chan')
             return false;
         const next = this.text[this.pos + 1];
         return next === '>' || (next !== undefined && /^[\p{ID_Start}$_]$/u.test(next));

package/dist/lexer/tables.js

@@ -8,6 +8,7 @@ export const ENDS_STATEMENT = new Set([
     'Number',
     'BigInt',
     'String',
+    'RegExp',
     'Template',
     'TemplateTail',
     'true',
@@ -34,6 +35,7 @@ export const ENDS_VALUE = new Set([
     'Number',
     'BigInt',
     'String',
+    'RegExp',
     'Template',
     'TemplateTail',
     'true',

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", "map"];
+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 PUNCTUATORS: readonly ["{", "}", "(", ")", "[", "]", ";", ",", ":", ".", "...", "?", "?.", "??", "=>", "=", "+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "&&=", "||=", "??=", "==", "!=", "<", "<-", ">", "<=", ">=", "+", "-", "*", "/", "%", "**", "++", "--", "&", "|", "^", "~", "<<", ">>", ">>>", "&&", "||", "!", "@"];
 export type Keyword = (typeof KEYWORDS)[number];
 export type Punctuator = (typeof PUNCTUATORS)[number];
@@ -7,9 +7,10 @@ export type Punctuator = (typeof PUNCTUATORS)[number];
  * substitutions: `a${x}b${y}c` becomes TemplateHead("a") x TemplateMiddle("b") y TemplateTail("c"),
  * and a template without substitutions is a single Template token. In markup, JsxText is the text
  * between tags and JsxString an attribute value in quotes; both have HTML entities decoded. CssText is
- * the raw text of a `style { ... }` block between the values from code.
+ * the raw text of a `style { ... }` block between the values from code. RegExp is `/ab+c/g`, whose
+ * value is the pattern as it is written, without the slashes and the flags.
  */
-export type StringKind = 'String' | 'Template' | 'TemplateHead' | 'TemplateMiddle' | 'TemplateTail' | 'JsxText' | 'JsxString' | 'CssText';
+export type StringKind = 'String' | 'Template' | 'TemplateHead' | 'TemplateMiddle' | 'TemplateTail' | 'JsxText' | 'JsxString' | 'CssText' | 'RegExp';
 /**
  * Tokens of markup such as `<a href="/">text</a>`: JsxTagOpen `<`, JsxCloseTagOpen `</`, JsxName
  * (tag and attribute names, which may contain `-` and `:`), JsxTagEnd `>` and JsxSelfClose `/>`.

package/dist/lexer/token.js

@@ -36,8 +36,6 @@ export const KEYWORDS = [
     'instanceof',
     'async',
     'await',
-    // Reserved for future use.
-    'map',
 ];
 export const PUNCTUATORS = [
     '{',

package/dist/loader.js

@@ -1,19 +1,23 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { registerHooks } from 'node:module';
-import { join } from 'node:path';
+import { appendFileSync, existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { createRequire, registerHooks } from 'node:module';
+import { dirname, extname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { isMainThread } from 'node:worker_threads';
-import { displayPath } from "./build.js";
-import { RUNTIME_MODULE } from "./codegen/runtime.js";
-import { compileFile } from "./compile-file.js";
+import { RUNTIME_MODULE } from "./runtime-module.js";
+import { sourceMapComment } from "./source-map.js";
 // `rook run` imports this module first (`node --import`): Node then imports `.rk` files,
 // compiled when they load, and `app.rk?goroutines` is the worker module of `go` in app.rk.
 // The worker threads of `go` import it too, since they get the `--import` of the process. The main
 // thread compiles a module before any worker needs it, so it leaves the code of each module and
 // of its worker module in ROOK_RUN_CACHE, a directory of the run, and the workers take it from
-// there: compiling again, with the types, would take each of them as long. ROOK_NO_CHECK turns
-// type checking off, and ROOK_MARKUP, 1 or 0, markup and components on or off for every file.
+// there: compiling again, with the types, would take each of them as long. So a worker does not
+// even load the compiler, which takes ~80 ms, unless a module is missing from the cache; the hooks
+// are synchronous, so it is loaded with require(). ROOK_NO_CHECK turns type checking off, and
+// ROOK_MARKUP, 1 or 0, markup and components on or off for every file. The code has its source map
+// in it, and the process runs with --enable-source-maps, so stack traces show the lines of .rk.
+// The main thread lists the files it compiles, and those they read, in `files` of the directory of
+// the run, with the time each was changed, for `rook run --watch` (run-file.ts).
 const typeCheck = process.env['ROOK_NO_CHECK'] === undefined;
 const markupSetting = process.env['ROOK_MARKUP'];
 const markup = markupSetting === undefined ? undefined : markupSetting === '1';
@@ -24,6 +28,9 @@ function cached(url) {
 }
 // The compiled code imports the runtime of this compiler, wherever the program is.
 const runtime = import.meta.resolve(RUNTIME_MODULE);
+const require = createRequire(import.meta.url);
+// The files next to this one: .ts in src, .js in the dist of the package.
+const extension = extname(fileURLToPath(import.meta.url));
 registerHooks({
     resolve(specifier, context, nextResolve) {
         if (specifier === RUNTIME_MODULE)
@@ -39,20 +46,40 @@ registerHooks({
             return { format: 'module', source: readFileSync(file, 'utf8'), shortCircuit: true };
         }
         const moduleUrl = new URL(pathname, url).href;
+        const { displayPath } = require(`./build${extension}`);
+        const { compileFile } = require(`./compile-file${extension}`);
         const path = displayPath(fileURLToPath(moduleUrl));
+        if (isMainThread && cache)
+            list([resolve(path)]);
         const result = compileFile(path, {
             rewriteImports: false,
             typeCheck,
             markup,
             quiet: !isMainThread,
         });
+        const code = withMap(result.code, result.map);
+        const worker = result.worker === undefined ? undefined : withMap(result.worker, result.workerMap);
         if (isMainThread && cache) {
-            writeFileSync(cached(moduleUrl), result.code);
-            if (result.worker !== undefined) {
-                writeFileSync(cached(`${moduleUrl}?goroutines`), result.worker);
-            }
+            // The CSS modules it imports; the .rk modules are listed when they are loaded.
+            const read = result.dependencies.map((each) => resolve(dirname(path), each));
+            list(read.filter((each) => existsSync(each)));
+            writeFileSync(cached(moduleUrl), code);
+            if (worker !== undefined)
+                writeFileSync(cached(`${moduleUrl}?goroutines`), worker);
         }
-        const source = search === '?goroutines' ? (result.worker ?? '') : result.code;
+        const source = search === '?goroutines' ? (worker ?? '') : code;
         return { format: 'module', source, shortCircuit: true };
     },
 });
+/** The code with its source map in it. */
+function withMap(code, map) {
+    if (map === undefined || code === '')
+        return code;
+    const data = Buffer.from(JSON.stringify(map)).toString('base64');
+    return `${code}${sourceMapComment(`data:application/json;base64,${data}`)}`;
+}
+/** Adds files to the list of the run: a line of the path and the time it was changed. */
+function list(paths) {
+    const lines = paths.map((path) => `${path}\t${statSync(path).mtimeMs}\n`);
+    appendFileSync(join(cache, 'files'), lines.join(''));
+}

package/dist/parser/base.d.ts

@@ -4,6 +4,8 @@ import type { StringToken, Token, TokenKind } from '../lexer/token.ts';
 import { type Context } from './syntax.ts';
 export declare abstract class ParserBase {
     protected abstract parseBreakOrContinue(): ast.BreakStatement | ast.ContinueStatement;
+    protected abstract parseLabeled(): ast.Statement;
+    protected abstract parseReturn(): ast.ReturnStatement;
     protected abstract parseDefer(): ast.DeferStatement;
     protected abstract parseFor(): ast.ForStatement | ast.ForInStatement;
     protected abstract parseGoFor(): ast.ForStatement | ast.ForInStatement;
@@ -37,6 +39,8 @@ export declare abstract class ParserBase {
     protected abstract parseMake(): ast.MakeExpression;
     protected abstract parseStreamChan(start: number): ast.StreamChanExpression;
     protected abstract parseQueue(): ast.QueueExpression | null;
+    protected abstract parseTopic(): ast.TopicExpression | null;
+    protected abstract parseDecode(): ast.DecodeExpression | null;
     protected abstract parseArrowFunction(async?: boolean): ast.ArrowFunction;
     protected abstract parseFuncExpression(async?: boolean): ast.FuncExpression;
     protected abstract parseIdentifier(what?: string): ast.Identifier;

package/dist/parser/base.js

@@ -1,6 +1,6 @@
 import { STATEMENT_KEYWORDS, BRACKETS, ParseError, describe } from "./syntax.js";
 // The parser is a chain of layers, one per area: base → simple statements → statements → control
-// flow → declarations → decorators → classes → types → expressions → literals → markup → Parser
+// flow → jumps → declarations → decorators → classes → types → expressions → literals → markup → Parser
 // (parser.ts). Statements, expressions and markup contain each other, so methods of later layers
 // that earlier ones call are declared here as abstract.
 //
@@ -21,6 +21,7 @@ export class ParserBase {
         noObjectLiteral: false,
         inComponent: false,
         inMarkup: false,
+        labels: [],
     };
     /** Expressions written in parentheses, which the tree itself does not record. */
     parenthesized = new WeakSet();

package/dist/parser/classes.d.ts

@@ -3,6 +3,8 @@ import { DecoratorParser } from './decorators.ts';
 export declare abstract class ClassParser extends DecoratorParser {
     protected parseClass(start: number, exported: boolean): ast.ClassDeclaration;
     protected parseClassMember(): ast.ClassMember[];
+    /** A method, a getter or a setter, after its name; an abstract one has no body. */
+    private parseMethod;
     protected parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
     protected parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
 }