rooklang 0.3.4 → 0.4.0

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

@@ -1,6 +1,10 @@
 import type * as ast from './ast.ts';
 /** Names assigned anywhere inside `node`: `x = ...`, `x += ...`, `x++`. */
 export declare function assignedNames(node: ast.Node, names?: Set<string>): Set<string>;
+/** `order.delivery.kind`: the variable and the fields of a path, or `null` for other expressions. */
+export declare function pathOf(node: ast.Expression): string[] | null;
+/** Paths of fields assigned anywhere inside `node`, e.g. `order.delivery` of `order.delivery = d`. */
+export declare function assignedPaths(node: ast.Node, paths?: Set<string>): Set<string>;
 /** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
 export declare function mentionsName(node: ast.Node, names: ReadonlySet<string>): boolean;
 /** Every name declared inside `node`: parameters and all local declarations, nested ones too. */

package/dist/names.js

@@ -19,6 +19,30 @@ export function assignedNames(node, names = new Set()) {
     forEachChild(node, (child) => assignedNames(child, names));
     return names;
 }
+/** `order.delivery.kind`: the variable and the fields of a path, or `null` for other expressions. */
+export function pathOf(node) {
+    if (node.kind === 'Identifier')
+        return [node.name];
+    if (node.kind !== 'MemberExpression' || node.optional)
+        return null;
+    const object = pathOf(node.object);
+    return object && [...object, node.property.name];
+}
+/** Paths of fields assigned anywhere inside `node`, e.g. `order.delivery` of `order.delivery = d`. */
+export function assignedPaths(node, paths = new Set()) {
+    const targets = node.kind === 'AssignmentStatement'
+        ? node.targets
+        : node.kind === 'IncDecStatement'
+            ? [node.target]
+            : [];
+    for (const target of targets) {
+        const path = pathOf(target);
+        if (path && path.length > 1)
+            paths.add(path.join('.'));
+    }
+    forEachChild(node, (child) => assignedPaths(child, paths));
+    return paths;
+}
 /** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
 export function mentionsName(node, names) {
     if (node.kind === 'Identifier')
@@ -99,6 +123,7 @@ export function freeNames(component) {
                 for (const name of node.names)
                     declared.add(name.name);
                 node.values.forEach(visit);
+                visit(node.body);
                 return;
             case 'SelectCase':
                 for (const name of node.names)
@@ -120,6 +145,8 @@ export function freeNames(component) {
                 if (node.key)
                     declared.add(node.key.name);
                 visit(node.iterable);
+                if (node.withKey)
+                    visit(node.withKey);
                 visit(node.body);
                 return;
             case 'CatchClause':
@@ -195,6 +222,7 @@ export function collectValueNames(node, names, isComponent = () => true) {
             return;
         case 'VariableDeclaration':
             node.values.forEach(visit);
+            visit(node.body);
             return;
         case 'FuncDeclaration':
         case 'MethodDeclaration':
@@ -237,6 +265,7 @@ export function collectValueNames(node, names, isComponent = () => true) {
             return;
         case 'ForInStatement':
             visit(node.iterable);
+            visit(node.withKey ?? null);
             visit(node.body);
             return;
         case 'CatchClause':

package/dist/parser/base.d.ts

@@ -25,6 +25,7 @@ export declare abstract class ParserBase {
     protected abstract parseClass(start: number, exported: boolean): ast.ClassDeclaration;
     protected abstract parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
     protected abstract parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
+    protected abstract parseFunctionBody(async?: boolean): ast.BlockStatement;
     protected abstract canStartType(offset?: number): boolean;
     protected abstract parseType(): ast.TypeNode;
     protected abstract parseTypeArgs(): ast.TypeNode[];

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 → jumps → declarations → decorators → classes → types → expressions → literals → markup → Parser
+// flow → jumps → params → 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.
 //

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

@@ -17,6 +17,11 @@ export declare abstract class ControlFlowParser extends StatementParser {
         ast.SimpleStatement | null
     ];
     protected parseForIn(start: number, go?: boolean): ast.ForInStatement;
+    /**
+     * `with key todo.id` after the items of a `{for}` in markup: its blocks are found again by the
+     * key instead of the item. `with` and `key` are words only here, not keywords.
+     */
+    private parseWithKey;
     /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
     protected parseGoFor(): ast.ForStatement | ast.ForInStatement;
     protected parseLoopBody(): ast.BlockStatement;

package/dist/parser/control-flow.js

@@ -69,13 +69,39 @@ export class ControlFlowParser extends StatementParser {
         }
         this.expect('in');
         const iterable = this.parseHeaderExpression();
+        const withKey = this.parseWithKey(go);
+        const keyed = withKey ? { withKey } : {};
         if (!go) {
             const body = this.parseLoopBody();
-            return { kind: 'ForInStatement', key, value, iterable, body, ...this.span(start) };
+            return { kind: 'ForInStatement', key, value, iterable, ...keyed, body, ...this.span(start) };
         }
         // The parts run at once in workers: nothing can leave the loop but `continue`.
         const body = this.withContext({ inLoop: true, inBreakable: false, inGoFor: true, labels: [] }, () => this.parseBlock());
-        return { kind: 'ForInStatement', key, value, iterable, body, go, ...this.span(start) };
+        return {
+            kind: 'ForInStatement',
+            key,
+            value,
+            iterable,
+            ...keyed,
+            body,
+            go,
+            ...this.span(start),
+        };
+    }
+    /**
+     * `with key todo.id` after the items of a `{for}` in markup: its blocks are found again by the
+     * key instead of the item. `with` and `key` are words only here, not keywords.
+     */
+    parseWithKey(go) {
+        if (!this.checkWord('with'))
+            return null;
+        const start = this.next().start;
+        this.expectWord('key');
+        const key = this.parseHeaderExpression();
+        if (go || !this.context.inMarkup) {
+            this.error('"with key" finds again the blocks of a {for} in markup, and this loop has none: remove it', start, key.end);
+        }
+        return key;
     }
     /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
     parseGoFor() {

package/dist/parser/declarations.d.ts

@@ -1,29 +1,19 @@
 import type * as ast from '../ast.ts';
-import { JumpParser } from './jumps.ts';
-export declare abstract class DeclarationParser extends JumpParser {
+import { ParamParser } from './params.ts';
+export declare abstract class DeclarationParser extends ParamParser {
     protected parseImport(): ast.ImportDeclaration;
     protected parseImportSpecifier(): ast.ImportSpecifier;
+    /** `state items []Item = []` at the top level of a module: state its components share. */
+    protected parseDeclaration(start: number, exported: boolean): ast.Statement | undefined;
     protected parseExport(): ast.Statement;
     protected parseFuncDeclaration(start: number, exported: boolean): ast.FuncDeclaration;
     /**
      * `<T any, U Shape>` after a name; `<K, V any>` gives both the constraint, as in Go.
      */
     protected parseTypeParams(): ast.TypeParameter[];
-    /**
-     * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
-     * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
-     * properties: `(private name string)`.
-     */
-    protected parseParams(typesOptional: boolean, allowDefaults?: boolean, allowRest?: boolean, allowProperties?: boolean): ast.Parameter[];
-    /** `private`, `readonly` or both before a parameter that is a property of its class. */
-    private parsePropertyModifiers;
-    /** `...attrs`: the attributes that a component passes on to one of its elements. */
-    private parseRestParam;
-    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
-    protected parseResults(): ast.TypeNode[];
     /** `comp Name(properties) { ...; return <markup> }`, maybe after decorators. */
     protected parseComponent(start: number, exported: boolean, htmlTag?: ast.HtmlTag | null, decorators?: ast.DecoratorUse[]): ast.ComponentDeclaration;
-    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount`. */
     protected parseComponentBody(): ast.BlockStatement;
     /** A statement at the top level of a component or a decorator. */
     protected parseComponentStatement(): ast.Statement;

package/dist/parser/declarations.js

@@ -1,7 +1,7 @@
-import { JumpParser } from "./jumps.js";
-import { describe, FUNCTION_BODY, VISIBILITIES } from "./syntax.js";
-// Imports and exports, functions and components with their parameters and results.
-export class DeclarationParser extends JumpParser {
+import { ParamParser } from "./params.js";
+import { describe, FUNCTION_BODY } from "./syntax.js";
+// Imports and exports, functions and components.
+export class DeclarationParser extends ParamParser {
     parseImport() {
         const start = this.next().start;
         if (!this.context.topLevel) {
@@ -50,6 +50,16 @@ export class DeclarationParser extends JumpParser {
         }
         return { kind: 'ImportSpecifier', imported, local, ...this.span(token.start) };
     }
+    /** `state items []Item = []` at the top level of a module: state its components share. */
+    parseDeclaration(start, exported) {
+        if (!this.context.topLevel || !this.checkWord('state') || this.peek(1).kind !== 'Identifier') {
+            return super.parseDeclaration(start, exported);
+        }
+        this.requireMarkup('state of a module is');
+        const declaration = this.parseVariableDeclaration(start, exported);
+        this.endStatement();
+        return declaration;
+    }
     parseExport() {
         const start = this.next().start;
         if (!this.context.topLevel) {
@@ -109,120 +119,6 @@ export class DeclarationParser extends JumpParser {
         this.expectTypeClose('">" after the type parameters');
         return params;
     }
-    /**
-     * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
-     * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
-     * properties: `(private name string)`.
-     */
-    parseParams(typesOptional, allowDefaults = false, allowRest = false, allowProperties = false) {
-        this.expect('(');
-        const params = [];
-        let untyped = 0;
-        while (!this.check(')')) {
-            if (this.check('...')) {
-                params.push(this.parseRestParam(allowRest));
-                break;
-            }
-            const paramStart = this.peek().start;
-            const property = this.parsePropertyModifiers(allowProperties);
-            const name = this.parseIdentifier('parameter name');
-            const type = this.canStartType() ? this.parseType() : null;
-            const defaultValue = allowDefaults && this.accept('=') ? this.parseExpression() : null;
-            params.push({
-                kind: 'Parameter',
-                name,
-                type,
-                defaultValue,
-                ...(property ? { property } : {}),
-                ...this.span(paramStart),
-            });
-            if (type === null) {
-                untyped++;
-            }
-            else {
-                for (const param of params.slice(params.length - 1 - untyped))
-                    param.type = type;
-                untyped = 0;
-            }
-            if (!this.accept(','))
-                break;
-        }
-        this.expect(')');
-        if (untyped > 0 && !typesOptional) {
-            const param = params[params.length - untyped];
-            this.error(`missing type for parameter "${param.name.name}"`, param.start, param.end);
-        }
-        return params;
-    }
-    /** `private`, `readonly` or both before a parameter that is a property of its class. */
-    parsePropertyModifiers(allowed) {
-        let visibility = null;
-        let readonly = false;
-        const start = this.peek().start;
-        // Elsewhere `readonly number` is a parameter named readonly, and `private x number` an error.
-        while (this.check('Identifier') &&
-            (VISIBILITIES.has(this.peek().text) || this.peek().text === 'readonly') &&
-            this.peek(1).kind === 'Identifier' &&
-            (allowed || this.peek(2).kind === 'Identifier')) {
-            const modifier = this.next();
-            if (modifier.text === 'readonly') {
-                if (readonly)
-                    this.error('duplicate "readonly" modifier', modifier.start, modifier.end);
-                readonly = true;
-            }
-            else {
-                if (visibility)
-                    this.error('duplicate visibility modifier', modifier.start, modifier.end);
-                visibility = modifier.text;
-            }
-        }
-        if (visibility === null && !readonly)
-            return null;
-        if (!allowed) {
-            this.error('only the parameters of a constructor can be properties, e.g. constructor(private name string)', start, this.span(start).end);
-        }
-        return { visibility: visibility ?? 'public', ...(readonly ? { readonly: true } : {}) };
-    }
-    /** `...attrs`: the attributes that a component passes on to one of its elements. */
-    parseRestParam(allowed) {
-        const start = this.next().start;
-        const name = this.parseIdentifier('parameter name');
-        if (!allowed) {
-            this.error(`...${name.name} is only for components: it takes the attributes of an element`, start, name.end);
-        }
-        if (this.canStartType() || this.check('=')) {
-            const at = this.peek().start;
-            // After the error, the type and the default are read, so they are not reported again.
-            if (this.canStartType())
-                this.parseType();
-            if (this.accept('='))
-                this.parseExpression();
-            this.error(`...${name.name} has no type and no default: it gets the type of the element it is spread on`, at, this.span(at).end);
-        }
-        // After the error, the rest of the list is skipped up to the `)`.
-        if (this.check(',')) {
-            this.error(`...${name.name} is the last property of a component`, start, name.end);
-            while (!this.check(')') && !this.check('EOF'))
-                this.next();
-        }
-        return {
-            kind: 'Parameter',
-            name,
-            type: null,
-            defaultValue: null,
-            rest: true,
-            ...this.span(start),
-        };
-    }
-    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
-    parseResults() {
-        if (this.accept('('))
-            return this.parseList(')', () => this.parseType());
-        // `{` after the parameters starts the body, so an object result type needs parentheses.
-        if (this.canStartType() && !this.check('{'))
-            return [this.parseType()];
-        return [];
-    }
     /** `comp Name(properties) { ...; return <markup> }`, maybe after decorators. */
     parseComponent(start, exported, htmlTag = null, decorators = []) {
         this.requireMarkup('components are');
@@ -248,7 +144,7 @@ export class DeclarationParser extends JumpParser {
             ...this.span(start),
         };
     }
-    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount`. */
     parseComponentBody() {
         const start = this.expect('{').start;
         const body = [];

package/dist/parser/decorators.d.ts

@@ -6,6 +6,10 @@ export declare abstract class DecoratorParser extends DeclarationParser {
     protected parseDecoratorDeclaration(start: number, exported: boolean): ast.DecoratorDeclaration;
     /** `needs cart, auth` after the parameters: `needs` is a keyword only here. */
     protected parseNeeds(): ast.Identifier[];
+    /** `includes visible(margin), cart` after `needs`: `includes` is a keyword only here. */
+    protected parseIncludes(): ast.DecoratorUse[];
+    /** `visible(margin)` or `cart`: like a decorator before `comp`, without the `@`. */
+    protected parseIncluded(): ast.DecoratorUse;
     /** Like the body of a component, but `state`, `const` and `func` may be `public`. */
     protected parseDecoratorBody(): ast.BlockStatement;
     /** `public` followed by a declaration; `public = 1` assigns a variable named `public`. */
@@ -24,7 +28,7 @@ export declare abstract class DecoratorParser extends DeclarationParser {
     /** `@visible.show`: a member of a decorator; a statement may start with it. */
     protected isDecoratorMember(): boolean;
     protected parseDecoratorMember(): ast.DecoratorMember;
-    /** `get(@visible.shown)`: `get` is special only when its argument starts with `@`. */
+    /** `get(@visible.shown)`, the old way to read a member: reported, and read as the member. */
     protected isDecoratorGet(): boolean;
-    protected parseDecoratorGet(): ast.DecoratorGet;
+    protected parseDecoratorGet(): ast.DecoratorMember;
 }