rooklang 0.3.3 → 0.4.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.d.ts

@@ -5,7 +5,7 @@ export type CopyListener = (copy: ast.Node, original: ast.Node) => void;
 export declare function originOf(node: ast.Node): ast.Node;
 /**
  * Renames of the names that are not values: tags of components, `<Icon />`, and decorators,
- * `get(@visible.shown)`. Code of another module refers to those of its own module.
+ * `@visible.shown`. Code of another module refers to those of its own module.
  */
 export interface OtherNames {
     tags?: ReadonlyMap<string, string>;

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':
@@ -140,6 +143,7 @@ export function renamer(renames, copied, other = {}) {
                 return done({
                     ...node,
                     iterable: copy(node.iterable, hidden),
+                    ...(node.withKey ? { withKey: copy(node.withKey, scoped(names, hidden)) } : {}),
                     body: copy(node.body, scoped(names, hidden)),
                 }, node);
             }

package/dist/decorator-names.d.ts

@@ -0,0 +1,14 @@
+import type * as ast from './ast.ts';
+import type { DecoratorSource } from './decorators.ts';
+/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
+export declare function decoratedName(decorator: string, member: string): string;
+/**
+ * The public members that a decorator gives the components it is applied to: its own and those of
+ * the decorators it includes, each with whether it changes (state and derived values do).
+ */
+export declare function publicMembers(decorator: ast.DecoratorDeclaration, decorators: ReadonlyMap<string, DecoratorSource>, seen?: ReadonlySet<ast.DecoratorDeclaration>): Map<string, boolean>;
+/**
+ * `@shop.count` of a member that `shop` gets from the `cart` it includes: a variable of `shop`
+ * that is that of `cart`, `derived` when it changes, so that what reads it is updated.
+ */
+export declare function aliases(included: DecoratorSource, use: ast.DecoratorUse, prefix: string, decorators: ReadonlyMap<string, DecoratorSource>, prefixes: ReadonlyMap<string, string> | undefined): ast.VariableDeclaration[];

package/dist/decorator-names.js

@@ -0,0 +1,56 @@
+// The names of the members of decorators in the components they are applied to, and the members
+// that a decorator gives with those of the decorators it includes.
+/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
+export function decoratedName(decorator, member) {
+    return `$$${decorator}$${member}`;
+}
+/**
+ * The public members that a decorator gives the components it is applied to: its own and those of
+ * the decorators it includes, each with whether it changes (state and derived values do).
+ */
+export function publicMembers(decorator, decorators, seen = new Set()) {
+    const members = new Map();
+    const inner = new Set([...seen, decorator]);
+    for (const use of decorator.includes) {
+        const included = decorators.get(use.name.name);
+        if (!included || inner.has(included.node))
+            continue;
+        for (const [name, changes] of publicMembers(included.node, decorators, inner)) {
+            members.set(name, changes);
+        }
+    }
+    for (const statement of decorator.body.body) {
+        if (statement.kind === 'FuncDeclaration' && statement.isPublic) {
+            members.set(statement.name.name, false);
+        }
+        else if (statement.kind === 'VariableDeclaration' && statement.isPublic) {
+            const changes = statement.keyword === 'state' || statement.keyword === 'derived';
+            for (const name of statement.names)
+                members.set(name.name, changes);
+        }
+    }
+    return members;
+}
+/**
+ * `@shop.count` of a member that `shop` gets from the `cart` it includes: a variable of `shop`
+ * that is that of `cart`, `derived` when it changes, so that what reads it is updated.
+ */
+export function aliases(included, use, prefix, decorators, prefixes) {
+    const from = prefixes?.get(included.node.name.name) ?? included.node.name.name;
+    return [...publicMembers(included.node, decorators)].map(([member, changes]) => ({
+        kind: 'VariableDeclaration',
+        exported: false,
+        isPublic: false,
+        keyword: changes ? 'derived' : 'const',
+        names: [
+            { kind: 'Identifier', name: decoratedName(prefix, member), start: use.start, end: use.end },
+        ],
+        type: null,
+        values: [
+            { kind: 'Identifier', name: decoratedName(from, member), start: use.start, end: use.end },
+        ],
+        body: null,
+        start: use.start,
+        end: use.end,
+    }));
+}

package/dist/decorators.d.ts

@@ -1,7 +1,6 @@
 import type * as ast from './ast.ts';
 import { type CopyListener } from './decorator-copy.ts';
-/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
-export declare function decoratedName(decorator: string, member: string): string;
+export { decoratedName, publicMembers } from './decorator-names.ts';
 /**
  * Whether a declaration of an applied component gets an argument of a decorator. When the
  * argument reads the component's properties, the declaration is a `state` that the properties
@@ -45,7 +44,7 @@ export declare function moduleNamesOf(decorator: ast.DecoratorDeclaration, progr
  * The component with its decorators applied. Its body first declares the arguments of each
  * decorator and runs its body, from the top decorator down, then runs the component's own body.
  * The names of a decorator get its prefix, `$$visible$shown`, so they clash neither with each other
- * nor with the component's names, and `get(@visible.shown)` reads that variable. The `mount()` of
+ * nor with the component's names, and `@visible.shown` reads that variable. The `mount` of
  * the decorators runs after the component's own, from the inside out, so it goes before every
  * `return` of the component's body.
  *

package/dist/decorators.js

@@ -1,14 +1,12 @@
 import { renamer } from "./decorator-copy.js";
+import { aliases, decoratedName } from "./decorator-names.js";
 import { declaredIn, freeNames, mentionsName, topLevelNames } from "./names.js";
 import { containsReturn } from "./recursion.js";
 import { forEachChild } from "./walk.js";
 // Applying decorators: a component with decorators becomes one component whose body runs the
 // bodies of its decorators first. The checker uses it to see what the inlined code uses, the
 // generator to write it.
-/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
-export function decoratedName(decorator, member) {
-    return `$$${decorator}$${member}`;
-}
+export { decoratedName, publicMembers } from "./decorator-names.js";
 const argumentDeclarations = new WeakSet();
 const wrappedContents = new WeakSet();
 /**
@@ -69,7 +67,7 @@ export function moduleNamesOf(decorator, program) {
  * The component with its decorators applied. Its body first declares the arguments of each
  * decorator and runs its body, from the top decorator down, then runs the component's own body.
  * The names of a decorator get its prefix, `$$visible$shown`, so they clash neither with each other
- * nor with the component's names, and `get(@visible.shown)` reads that variable. The `mount()` of
+ * nor with the component's names, and `@visible.shown` reads that variable. The `mount` of
  * the decorators runs after the component's own, from the inside out, so it goes before every
  * `return` of the component's body.
  *
@@ -83,37 +81,55 @@ export function moduleNamesOf(decorator, program) {
 export function decorate(component, decorators, copied, prefixes) {
     if (component.decorators.length === 0)
         return component;
-    const props = new Set(component.params.map((param) => param.name.name));
+    // Arguments that read the properties, or such arguments of a decorator that includes another,
+    // are state: they change with them.
+    const reactive = new Set(component.params.map((param) => param.name.name));
     const setup = [];
     const mounts = [];
     const wrappers = [];
-    for (const use of component.decorators) {
-        const source = decorators.get(use.name.name);
-        if (!source)
-            continue;
+    // `argument` copies an argument into the component: one of the component stays as it is, one of
+    // a decorator it includes is that decorator's code.
+    const apply = (source, args, argument, applying) => {
         const decorator = source.node;
+        // A decorator that includes itself, through others too, is reported by the checker.
+        const inner = new Set([...applying, decorator]);
         const prefix = prefixes?.get(decorator.name.name) ?? decorator.name.name;
         const names = [...decoratorNames(decorator), ...source.moduleNames];
         const renames = membersOf(prefix, names);
         const copy = renamer(renames, copied, { decorators: prefixes, tags: source.tags });
         decorator.params.forEach((param, i) => {
-            // A default value is the decorator's code, an argument the component's.
-            const value = use.arguments[i] ?? (param.defaultValue && copy(param.defaultValue, new Set()));
+            const given = args[i];
+            // A default value is the decorator's code.
+            const value = given
+                ? argument(given)
+                : param.defaultValue && copy(param.defaultValue, new Set());
+            const name = renames.get(param.name.name);
+            const changes = value !== null && value !== undefined && mentionsName(value, reactive);
             const declaration = {
                 kind: 'VariableDeclaration',
                 exported: false,
                 isPublic: false,
-                keyword: value && mentionsName(value, props) ? 'state' : 'const',
-                names: [{ ...param.name, name: renames.get(param.name.name) }],
+                keyword: changes ? 'state' : 'const',
+                names: [{ ...param.name, name }],
                 type: param.type,
                 values: value ? [value] : [],
+                body: null,
                 start: param.start,
                 end: param.end,
             };
+            if (changes)
+                reactive.add(name);
             argumentDeclarations.add(declaration);
             copied?.(declaration, param);
             setup.push(declaration);
         });
+        for (const use of decorator.includes) {
+            const included = decorators.get(use.name.name);
+            if (!included || inner.has(included.node))
+                continue;
+            apply(included, use.arguments, (value) => copy(value, new Set()), inner);
+            setup.push(...aliases(included, use, prefix, decorators, prefixes));
+        }
         const wrapper = wrapperOf(decorator);
         const own = [];
         for (const statement of decorator.body.body) {
@@ -128,6 +144,11 @@ export function decorate(component, decorators, copied, prefixes) {
         mounts.push(own);
         if (wrapper)
             wrappers.push(applyWrapper(source, wrapper, copied, prefix, prefixes));
+    };
+    for (const use of component.decorators) {
+        const source = decorators.get(use.name.name);
+        if (source)
+            apply(source, use.arguments, (value) => value, new Set());
     }
     const inside = mounts.reverse().flat();
     const chain = wrappers.reverse();
@@ -186,6 +207,7 @@ function wrapped(node, chain) {
         names: [{ ...wrapper.content }],
         type: wrapper.type,
         values: [value],
+        body: null,
         start: node.start,
         end: node.end,
     };

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/inline-packages.d.ts

@@ -27,6 +27,7 @@ export interface ModulePackages {
  * recursive or a web component cannot be inlined, and neither can one that reaches components or
  * decorators the module imports: those would bring the names of a third module. Nor can code that
  * uses a component of the module as a value, which is the function in the module, or that assigns
- * a variable of the module: another module could only read it.
+ * a variable of the module: another module could only read it. Nor can code that reads state of
+ * the module, `state items` at its top level: it listens to the changes there.
  */
 export declare function inlinePackages(program: ast.Program): ModulePackages;

package/dist/inline-packages.js

@@ -7,7 +7,8 @@ import { forEachChild } from "./walk.js";
  * recursive or a web component cannot be inlined, and neither can one that reaches components or
  * decorators the module imports: those would bring the names of a third module. Nor can code that
  * uses a component of the module as a value, which is the function in the module, or that assigns
- * a variable of the module: another module could only read it.
+ * a variable of the module: another module could only read it. Nor can code that reads state of
+ * the module, `state items` at its top level: it listens to the changes there.
  */
 export function inlinePackages(program) {
     const components = new Map();
@@ -30,9 +31,13 @@ export function inlinePackages(program) {
     };
     const topLevel = topLevelNames(program);
     const usesComponentValues = (node) => componentValues(node, (name) => components.has(name)).length > 0;
-    const assignsModuleNames = (node) => {
+    const states = new Set(program.body.flatMap((statement) => statement.kind === 'VariableDeclaration' && statement.keyword === 'state'
+        ? statement.names.map((name) => name.name)
+        : []));
+    // It assigns a variable of the module or reads its state, which only the module can do.
+    const needsItsModule = (node) => {
         const assigned = assignedNames(node);
-        return [...freeNames(node)].some((name) => topLevel.has(name) && assigned.has(name));
+        return [...freeNames(node)].some((name) => topLevel.has(name) && (assigned.has(name) || states.has(name)));
     };
     /** The package of a component, or of the tags in the code of a decorator. */
     const build = (root, tags) => {
@@ -69,7 +74,7 @@ export function inlinePackages(program) {
             found.components.set(current, component);
             if (usesComponentValues(expanded.get(current)))
                 return false;
-            if (assignsModuleNames(expanded.get(current)))
+            if (needsItsModule(expanded.get(current)))
                 return false;
             for (const use of component.decorators) {
                 const source = sources.get(use.name.name);

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 `/>`.