rooklang 0.3.1 → 0.3.3

package/dist/checker/queues.js

@@ -0,0 +1,24 @@
+import { ChannelChecker } from "./channels.js";
+import { isUntyped } from "./helpers.js";
+import { arrayOf, queueOf, typeToString } from "./types.js";
+// Queues: `queue<number>()` makes an empty one, `queue<number>(items)` one with the values of an
+// array or of another iterable. The members of `queue T` are in types/queue.ts.
+export class QueueChecker extends ChannelChecker {
+    checkQueue(node) {
+        const element = this.resolveType(node.element);
+        if (node.items) {
+            // An array literal gets the type of the values, so that `[]` and `[1, null]` fit.
+            const items = this.checkValue(node.items, arrayOf(element));
+            if (items.kind === 'object' && items.iterates) {
+                this.expectAssignable(items.iterates, element, node.items);
+            }
+            else if (items.kind === 'array' || isUntyped(items)) {
+                this.expectAssignable(items, arrayOf(element), node.items);
+            }
+            else {
+                this.error(`queue<T>(items) takes its first values as an array or another iterable, not ${typeToString(items)}, e.g. queue<number>([1, 2, 3])`, node.items);
+            }
+        }
+        return queueOf(element);
+    }
+}

package/dist/checker/resolution.js

@@ -2,7 +2,7 @@ import { holdsBigInts, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { chanOf } from "./channel.js";
 import { ClassChecker } from "./classes.js";
 import { CONTENT } from "./dom.js";
-import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, substitute, typeToString, union, UNKNOWN, } from "./types.js";
+import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, queueOf, substitute, typeToString, union, UNKNOWN, } from "./types.js";
 // Type annotations as types: names, aliases, generics with their arguments; and the type a variable gets from its value.
 export class TypeResolver extends ClassChecker {
     resolveType(node) {
@@ -15,6 +15,8 @@ export class TypeResolver extends ClassChecker {
             }
             case 'ChanType':
                 return chanOf(this.resolveType(node.element), node.direction);
+            case 'QueueType':
+                return queueOf(this.resolveType(node.element));
             case 'NullableType':
                 return nullable(this.resolveType(node.type));
             case 'FuncType':
@@ -79,7 +81,9 @@ export class TypeResolver extends ClassChecker {
         if (entry === undefined) {
             this.error(this.lookupValue(name.name)
                 ? `"${name.name}" is a value, not a type`
-                : `unknown type "${name.name}"`, name);
+                : name.name === 'queue'
+                    ? 'a queue type is written with the type of its values after it, e.g. "queue number"'
+                    : `unknown type "${name.name}"`, name);
             return UNKNOWN;
         }
         const args = typeArgs.map((arg) => this.resolveType(arg));

package/dist/checker/statements.d.ts

@@ -23,6 +23,11 @@ export declare abstract class StatementChecker extends AssignmentChecker {
     private checkDelete;
     protected checkBlock(statements: readonly ast.Statement[]): void;
     protected checkVariableDeclaration(node: ast.VariableDeclaration): void;
+    /**
+     * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
+     * be null. Variables of `let` may be assigned apart, so only constants are linked.
+     */
+    private linkError;
     /** The types of the variables of a declaration: the written one, or those of their values. */
     private initializerTypes;
 }

package/dist/checker/statements.js

@@ -1,3 +1,4 @@
+import { guardedByError } from "./error-results.js";
 import { AssignmentChecker } from "./assignments.js";
 import { isUntyped, isNumeric, ownStatements } from "./helpers.js";
 import { func, hasZeroValue, isNullable, nonNull, nullable, typeToString, UNKNOWN, } from "./types.js";
@@ -182,8 +183,26 @@ export class StatementChecker extends AssignmentChecker {
                     this.flow.set(binding, nonNull(type));
                 }
             });
+            if (node.keyword === 'const' && !declared)
+                this.linkError(node, bindings);
         });
     }
+    /**
+     * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
+     * be null. Variables of `let` may be assigned apart, so only constants are linked.
+     */
+    linkError(node, bindings) {
+        const results = node.values.length === 1 ? this.typeOfChecked(node.values[0]) : null;
+        const error = bindings.at(-1);
+        if (results?.kind !== 'tuple' || results.types.length !== bindings.length || !error)
+            return;
+        const guarded = guardedByError(results.types).flatMap((i) => bindings[i] ?? []);
+        if (guarded.length === 0)
+            return;
+        error.guards = guarded;
+        for (const binding of guarded)
+            binding.guardedBy = error;
+    }
     /** The types of the variables of a declaration: the written one, or those of their values. */
     initializerTypes(node, declared) {
         const { names, values } = node;

package/dist/checker/transfer.js

@@ -1,4 +1,4 @@
-import { memberNames, typeToString } from "./types.js";
+import { isQueue, memberNames, queueElement, typeToString } from "./types.js";
 // What can go to a worker and back: a worker gets a copy of each value (the structured clone of
 // postMessage), and a copy has the data of a value but not its methods.
 /** Buffers and their views: copied whole, or moved by `transfer(x)` (channels.ts). */
@@ -66,6 +66,9 @@ export function notCopied(type, seen = new Set()) {
                 ? null
                 : `a copy of ${typeToString(type)} would lose its class and methods`;
         case 'object': {
+            // A queue goes as its values, and the other thread makes a queue of them (src/runtime/threads.js).
+            if (isQueue(type))
+                return inner([queueElement(type)]);
             const name = type.instanceOf?.template.name ?? type.name;
             if (name !== null && COPIED.has(name))
                 return inner(type.instanceOf?.args ?? []);

package/dist/checker/types/printing.js

@@ -1,6 +1,7 @@
 import { TYPED_ARRAYS, typedArrayName } from "../../typed-arrays.js";
 import { ERROR_CLASS } from "./classes.js";
 import { nullable } from "./constructors.js";
+import { isQueue, queueElement } from "./queue.js";
 // Types as text, for messages.
 /** How deep object types without a name are printed with their members. */
 const MAX_OBJECT_DEPTH = 3;
@@ -58,6 +59,12 @@ export function typeToString(type) {
                 (type.name === 'chan' || type.name === 'chan<-' || type.name === '<-chan')) {
                 return `${type.name} ${typeToString(type.instanceOf.args[0])}`;
             }
+            // `queue (string | number)`: the parentheses that the type is written with.
+            if (isQueue(type)) {
+                const element = queueElement(type);
+                const text = typeToString(element);
+                return `queue ${element.kind === 'union' && !element.name ? `(${text})` : text}`;
+            }
             if (type.instanceOf && type.name !== null) {
                 return `${type.name}<${type.instanceOf.args.map(typeToString).join(', ')}>`;
             }

package/dist/checker/types/queue.d.ts

@@ -0,0 +1,6 @@
+import { type ObjectType, type Type } from './model.ts';
+export declare function queueOf(element: Type): ObjectType;
+/** Whether a type is `queue T`. */
+export declare function isQueue(type: Type): boolean;
+/** The type of the values of a queue type. */
+export declare function queueElement(queue: Type): Type;

package/dist/checker/types/queue.js

@@ -0,0 +1,42 @@
+import { func, method, nullable, property } from "./constructors.js";
+import { instantiate } from "./generics.js";
+import { NUMBER } from "./model.js";
+// `queue T`, made by `queue<T>()`: values that go in and out at both ends without moving the
+// others, as an array moves them on `shift()`. A queue type is an instance of a generic object
+// with the members of an array that a queue keeps, and only a queue is assignable to it
+// (relations.ts). The template is made on first use, since the modules of types import each other.
+let template = null;
+function queueTemplate() {
+    if (template)
+        return template;
+    const T = { kind: 'param', name: 'T' };
+    template = {
+        kind: 'object',
+        name: 'queue',
+        members: new Map([
+            ['length', property(NUMBER)],
+            ['push', method(func([], [NUMBER], { rest: T }))],
+            ['unshift', method(func([], [NUMBER], { rest: T }))],
+            // An empty queue gives null, as `pop()` of an empty array gives undefined.
+            ['shift', method(func([], [nullable(T)]))],
+            ['pop', method(func([], [nullable(T)]))],
+            ['at', method(func([NUMBER], [nullable(T)]))],
+            ['clear', method(func([], []))],
+        ]),
+        call: null,
+        iterates: T,
+        typeParams: [T],
+    };
+    return template;
+}
+export function queueOf(element) {
+    return instantiate(queueTemplate(), [element]);
+}
+/** Whether a type is `queue T`. */
+export function isQueue(type) {
+    return type.kind === 'object' && template !== null && type.instanceOf?.template === template;
+}
+/** The type of the values of a queue type. */
+export function queueElement(queue) {
+    return queue.instanceOf.args[0];
+}

package/dist/checker/types/relations.js

@@ -3,6 +3,7 @@ import { memberNames } from "./lazy.js";
 import { isNullable, literalBase, nonNull, union } from "./constructors.js";
 import { UNKNOWN, VOID, } from "./model.js";
 import { typedArrayOf, typeToString } from "./printing.js";
+import { isQueue, queueElement } from "./queue.js";
 // Relations between types: assignability, comparison, equality, common types.
 /** Whether a value of type `source` can be used where `target` is expected. */
 export function isAssignable(source, target) {
@@ -75,6 +76,10 @@ export function assignable(source, target, assuming) {
             return missingMember(source, members, nested) === null;
         }
         case 'object': {
+            // Only a queue is a queue, as only an array is an array, and its values are checked as theirs.
+            if (isQueue(target)) {
+                return isQueue(source) && assignable(queueElement(source), queueElement(target), nested);
+            }
             // A channel both takes and gives values, so `chan number` is not a `chan ?number`, as in Go;
             // `chan any` is any channel, for `close(ch)`. A `chan T` is also a channel of one
             // direction, `chan<- T` or `<-chan T`, but not the other way round.
@@ -201,10 +206,13 @@ function missingMember(source, members, assuming) {
 }
 /** Why `source` is not assignable to an object or class `target`, e.g. `missing field "y"`. */
 export function explainMismatch(source, target) {
-    // `Stack<number>` and `Stack<string>`: the type arguments already say what differs.
+    // `Stack<number>` and `Stack<string>`: the type arguments already say what differs; only a queue
+    // is a queue.
     if (source.kind === 'class' && target.kind === 'class' && source.info === target.info) {
         return null;
     }
+    if (isQueue(target))
+        return null;
     const members = target.kind === 'object'
         ? target.members
         : target.kind === 'class'
@@ -288,6 +296,9 @@ export function hasZeroValue(type) {
         case 'any':
         case 'unknown':
             return true;
+        // An empty queue, as `[]` is the zero value of an array.
+        case 'object':
+            return isQueue(type);
         default:
             return false;
     }

package/dist/checker/types.d.ts

@@ -7,3 +7,4 @@ export * from './types/relations.ts';
 export * from './types/params.ts';
 export * from './types/printing.ts';
 export * from './types/bytes.ts';
+export * from './types/queue.ts';

package/dist/checker/types.js

@@ -8,3 +8,4 @@ export * from "./types/relations.js";
 export * from "./types/params.js";
 export * from "./types/printing.js";
 export * from "./types/bytes.js";
+export * from "./types/queue.js";

package/dist/checker/untyped-globals.d.ts

@@ -0,0 +1 @@
+export declare const UNTYPED_GLOBALS: readonly string[];

package/dist/checker/untyped-globals.js

@@ -0,0 +1,47 @@
+// JS globals that the checker knows by name only, without types: everything about them is `any`.
+// With TypeScript's lib files (in Node) the library types them; the browser compiler of the
+// playground has only these names.
+export const UNTYPED_GLOBALS = [
+    'Object',
+    'Array',
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Symbol',
+    'Reflect',
+    'Proxy',
+    'Intl',
+    'globalThis',
+    'process',
+    'Buffer',
+    'URL',
+    'URLSearchParams',
+    'TextEncoder',
+    'TextDecoder',
+    // Streams, and what makes them: chan(stream) and stream(ch) work with them.
+    'ReadableStream',
+    'WritableStream',
+    'TransformStream',
+    'TextEncoderStream',
+    'TextDecoderStream',
+    'Blob',
+    'Response',
+    'Request',
+    'Headers',
+    'AbortController',
+    'fetch',
+    'structuredClone',
+    'queueMicrotask',
+    'window',
+    'document',
+    'navigator',
+    'location',
+    'localStorage',
+    'sessionStorage',
+    'crypto',
+    'performance',
+];

package/dist/codegen/attributes.js

@@ -88,7 +88,6 @@ export class AttributeEmitter extends UpdateEmitter {
             this.setLive(live, value, (text) => `${element}.setAttribute(${quoted}, ${text});`);
         }
         else if (live && live.dependencies(value).size > 0) {
-            this.helpers.add('attribute');
             this.setLive(live, value, (text) => `$$attribute(${element}, ${quoted}, ${text});`);
         }
         else {

package/dist/codegen/calls.d.ts

@@ -19,4 +19,13 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
      */
     protected make(node: ast.MakeExpression): string;
     protected conversion(node: ast.ConversionExpression): string;
+    /** `chan<number>(10)`: the channel keeps the zero value that a closed one gives. */
+    protected chan(node: ast.ChanExpression): string;
+    /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
+    protected queue(node: ast.QueueExpression): string;
+    /**
+     * `chan(stream, size)`: the channel keeps the zero value of its values, as `chan<T>(size)` does,
+     * from the type of the stream that the checker found; without it, null.
+     */
+    protected streamChan(node: ast.StreamChanExpression): string;
 }

package/dist/codegen/calls.js

@@ -97,10 +97,50 @@ export class CallEmitter extends ExpressionEmitter {
         const bytes = size === 1
             ? this.expression(node.length, ARROW)
             : `${size} * ${this.expression(node.length, BINARY['*'] + 1)}`;
-        this.helpers.add('shared');
         return `new ${typed}($$shared(${bytes}))`;
     }
     conversion(node) {
         return `new TextEncoder().encode(${this.expression(node.argument, 0)})`;
     }
+    /** `chan<number>(10)`: the channel keeps the zero value that a closed one gives. */
+    chan(node) {
+        const size = node.size ? this.expression(node.size, ARROW) : '0';
+        return `$$chan(${size}, ${this.zeroValue(node.element) ?? 'null'})`;
+    }
+    /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
+    queue(node) {
+        return `new $$Queue(${node.items ? this.expression(node.items, ARROW) : ''})`;
+    }
+    /**
+     * `chan(stream, size)`: the channel keeps the zero value of its values, as `chan<T>(size)` does,
+     * from the type of the stream that the checker found; without it, null.
+     */
+    streamChan(node) {
+        const stream = this.expression(node.stream, ARROW);
+        const size = node.size ? this.expression(node.size, ARROW) : '0';
+        const type = this.options.types?.get(node);
+        const channel = type?.kind === 'tuple' ? type.types[0] : undefined;
+        const element = channel?.kind === 'object' ? channel.instanceOf?.args[0] : undefined;
+        return `$$fromStream(${stream}, ${size}, ${element ? zeroOf(element) : 'null'})`;
+    }
+}
+/** The zero value of a type, as zeroValue gives for a type as written. */
+function zeroOf(type) {
+    const typed = typedArrayOf(type);
+    if (typed !== null)
+        return `new ${typed}()`;
+    switch (type.kind) {
+        case 'number':
+            return '0';
+        case 'bigint':
+            return '0n';
+        case 'string':
+            return '""';
+        case 'bool':
+            return 'false';
+        case 'array':
+            return '[]';
+        default:
+            return 'null';
+    }
 }

package/dist/codegen/component-values.js

@@ -52,7 +52,6 @@ export class ComponentValueEmitter extends ComponentPropsEmitter {
         finally {
             this.fixedComponents.delete(node);
         }
-        this.helpers.add('dynamic');
         this.line(`const [${name}, ${update}] = $$dynamic(${this.liveFunction(value)}, ${create});`);
         live.depend(live.dependencies(node), `${update}();`);
         return name;

package/dist/codegen/components.js

@@ -78,7 +78,6 @@ export class ComponentEmitter extends StyleEmitter {
      * it changes updates the markup.
      */
     mountStatement(node) {
-        this.helpers.add('mount');
         this.inHandler++;
         try {
             const [, body] = this.withRendering(0, () => this.func([], node.body));

package/dist/codegen/control-flow.js

@@ -26,19 +26,16 @@ export class ControlFlowEmitter extends ElementEmitter {
                 const [choose, blocks] = statement.kind === 'IfStatement'
                     ? this.ifBranches(statement, live)
                     : this.switchBranches(statement, live);
-                this.helpers.add('branches');
                 call = `$$branches(${choose}, [${blocks.join(', ')}])`;
                 break;
             }
             case 'ForInStatement': {
-                this.helpers.add('list');
                 const items = this.liveFunction(statement.iterable);
                 call = `$$list(${items}, ${this.blockCreator(statement.body.body, live, statement)})`;
                 break;
             }
             case 'ForStatement':
                 // Without items to find the blocks by, the loop runs again and creates new content.
-                this.helpers.add('content');
                 call = `$$content(${this.loopContent(statement)})`;
                 break;
         }

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

@@ -1,6 +1,5 @@
 import type * as ast from '../ast.ts';
 import { SimpleStatementEmitter } from './simple-statements.ts';
-/** if, for, switch and try. */
 export declare abstract class ControlStatementEmitter extends SimpleStatementEmitter {
     protected ifStatement(node: ast.IfStatement): string;
     protected loopBody(body: ast.BlockStatement): string;
@@ -12,6 +11,15 @@ export declare abstract class ControlStatementEmitter extends SimpleStatementEmi
      * `for i, x in xs` iterates `xs.entries()`, which gives the keys and values of a Map too.
      */
     protected forInStatement(node: ast.ForInStatement): void;
+    /** `[i, v]` of a loop over pairs; `_` leaves its place empty. */
+    private pair;
+    /**
+     * `for i, v in items` over an array or a typed array: a loop over the indexes, which runs faster
+     * than one over the pairs of `entries()`. The variables of the loop cannot be assigned, so `i` is
+     * the counter itself. The array is read once, as `entries()` reads it, into `$$items` unless it is
+     * a name that cannot change.
+     */
+    private indexLoop;
     /** Each `case` ends with an implicit `break`; a case with declarations gets its own block. */
     protected switchStatement(node: ast.SwitchStatement, discriminant: ast.Expression): void;
     /**

package/dist/codegen/control-statements.js

@@ -1,10 +1,14 @@
 import { isChan } from "../checker/channel.js";
 import { isMap } from "../checker/iterables.js";
+import { typedArrayOf } from "../checker/types.js";
+import { declaredIn } from "../names.js";
 import { containsBreak } from "../walk.js";
 import { declarationsOf, endsWithJump } from "./analysis.js";
 import { SimpleStatementEmitter } from "./simple-statements.js";
 import { ARROW, BINARY, POSTFIX } from "./syntax.js";
 /** if, for, switch and try. */
+/** Names that keep their value, so a loop over the indexes may read the array through them. */
+const FIXED = new Set(['const', 'import', 'loop']);
 export class ControlStatementEmitter extends SimpleStatementEmitter {
     ifStatement(node) {
         let text = `if (${this.expression(node.condition, 0)}) ${this.blockStatement(node.consequent)}`;
@@ -53,7 +57,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             case 'ExpressionStatement':
                 return this.expression(node.expression, 0);
             case 'SendStatement':
-                this.helpers.add('chan');
                 return `await $$send(${this.expression(node.channel, ARROW)}, ${this.expression(node.value, ARROW)})`;
         }
     }
@@ -71,7 +74,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             let head;
             // A channel gives its values as they come, until it is closed.
             if (iterable && isChan(iterable)) {
-                this.helpers.add('chan');
                 this.line(`for await (const ${value} of $$range(${this.expression(node.iterable, ARROW)})) ${this.loopBody(node.body)}`);
                 return;
             }
@@ -92,19 +94,62 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 if (iterable && isMap(iterable))
                     values += '.values()';
                 else if (untyped) {
-                    this.helpers.add('values');
                     values = `$$values(${values})`;
                 }
                 head = `const ${value} of ${values}`;
             }
+            else if (iterable &&
+                (iterable.kind === 'array' || iterable.kind === 'string' || typedArrayOf(iterable) !== null)) {
+                // Without the index, the loop goes over the values.
+                if (node.key.name === '_' && node.value.name !== '_') {
+                    head = `const ${value} of ${this.expression(node.iterable, POSTFIX)}`;
+                }
+                else if (iterable.kind === 'string') {
+                    // A string has no entries(): its characters, as `for...of` gives them, are numbered.
+                    const pair = this.pair(node.key, node.value);
+                    head = `const ${pair} of Array.from(${this.expression(node.iterable, ARROW)}).entries()`;
+                }
+                else {
+                    this.indexLoop(node, node.key);
+                    return;
+                }
+            }
             else {
-                const key = node.key.name === '_' ? '' : this.name(node.key.name);
-                const pair = node.value.name === '_' ? `[${key}]` : `[${key}, ${value}]`;
-                head = `const ${pair} of ${this.expression(node.iterable, POSTFIX)}.entries()`;
+                head = `const ${this.pair(node.key, node.value)} of ${this.expression(node.iterable, POSTFIX)}.entries()`;
             }
             this.line(`for (${head}) ${this.loopBody(node.body)}`);
         });
     }
+    /** `[i, v]` of a loop over pairs; `_` leaves its place empty. */
+    pair(key, value) {
+        const name = key.name === '_' ? '' : this.name(key.name);
+        return value.name === '_' ? `[${name}]` : `[${name}, ${this.name(value.name)}]`;
+    }
+    /**
+     * `for i, v in items` over an array or a typed array: a loop over the indexes, which runs faster
+     * than one over the pairs of `entries()`. The variables of the loop cannot be assigned, so `i` is
+     * the counter itself. The array is read once, as `entries()` reads it, into `$$items` unless it is
+     * a name that cannot change.
+     */
+    indexLoop(node, keyNode) {
+        const key = keyNode.name === '_' ? '$$i' : this.name(keyNode.name);
+        const value = node.value.name === '_' ? null : this.name(node.value.name);
+        const { iterable } = node;
+        const fixed = iterable.kind === 'Identifier' && FIXED.has(this.lookup(iterable.name) ?? 'let');
+        const items = fixed ? this.expression(iterable, POSTFIX) : '$$items';
+        const init = fixed ? '' : `, $$items = ${this.expression(iterable, ARROW)}`;
+        // A declaration of the same name in the body would clash with the element's in one block.
+        const hidden = declaredIn(node.body.body).some((name) => name === keyNode.name || name === node.value.name);
+        const body = this.withBreakTarget(null, () => this.block(() => {
+            if (value !== null)
+                this.line(`const ${value} = ${items}[${key}];`);
+            if (hidden)
+                this.line(this.blockStatement(node.body));
+            else
+                this.blockStatements(node.body.body);
+        }));
+        this.line(`for (let ${key} = 0${init}; ${key} < ${items}.length; ${key}++) ${body}`);
+    }
     /** Each `case` ends with an implicit `break`; a case with declarations gets its own block. */
     switchStatement(node, discriminant) {
         const head = `switch (${this.expression(discriminant, 0)})`;
@@ -140,7 +185,6 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
      * switch runs the case; a `break` inside it leaves the select, as in Go. `default` is -1.
      */
     selectStatement(node) {
-        this.helpers.add('chan');
         const operations = node.cases.flatMap(({ operation }) => {
             if (operation === null)
                 return [];

package/dist/codegen/creation.d.ts

@@ -2,11 +2,11 @@ import type * as ast from '../ast.ts';
 import { AttributeEmitter } from './attributes.ts';
 import type { Live } from './reactive.ts';
 /**
- * The creation of elements. In a module that creates many of them (see ELEMENT_HELPER_LIMIT in
- * js.ts) an element is created by a helper together with the attributes it has from the start:
- * `$$element("a", { href: "/", className: "link" }, { "aria-label": label })` takes the place of
- * a `createElement` and a statement for each attribute. The first object holds properties, the
- * second attributes set with setAttribute; an SVG element has only attributes.
+ * The creation of elements. An element is created by a function of the runtime together with the
+ * attributes it has from the start: `$$element("a", { href: "/", className: "link" },
+ * { "aria-label": label })` takes the place of a `createElement` and a statement for each
+ * attribute. The first object holds properties, the second attributes set with setAttribute; an
+ * SVG element has only attributes.
  */
 /** Attributes given to the helper that creates an element, which need no statements of their own. */
 export interface Creation {
@@ -15,10 +15,8 @@ export interface Creation {
     scoped: boolean;
 }
 export declare abstract class CreationEmitter extends AttributeEmitter {
-    /** The elements the code creates, counted where it creates them, not as often as it runs. */
-    createdElements: number;
     /**
-     * Writes `declaration = <a new element>`. With the helper it is given the attributes before the
+     * Writes `declaration = <a new element>`. It is given the attributes before the
      * first spread, which may override them, except those that need more than a value: handlers,
      * `bind:`, styles, properties of web components and attributes that may be null. `scopeClass`
      * is the class of the style for an element without a class attribute.

package/dist/codegen/creation.js

@@ -2,21 +2,14 @@ import { domProperty } from "../checker/dom.js";
 import { AttributeEmitter } from "./attributes.js";
 import { ARROW } from "./syntax.js";
 export class CreationEmitter extends AttributeEmitter {
-    /** The elements the code creates, counted where it creates them, not as often as it runs. */
-    createdElements = 0;
     /**
-     * Writes `declaration = <a new element>`. With the helper it is given the attributes before the
+     * Writes `declaration = <a new element>`. It is given the attributes before the
      * first spread, which may override them, except those that need more than a value: handlers,
      * `bind:`, styles, properties of web components and attributes that may be null. `scopeClass`
      * is the class of the style for an element without a class attribute.
      */
     createWith(declaration, element, tag, svg, attributes, live, scope, scopeClass) {
         const covered = new Set();
-        this.createdElements++;
-        if (!this.options.elementHelper) {
-            this.line(`${declaration} = ${this.createElement(tag, svg)};`);
-            return { covered, scoped: false };
-        }
         const entries = [];
         for (const attribute of attributes) {
             if (attribute.kind === 'JsxSpreadAttribute')
@@ -48,13 +41,11 @@ export class CreationEmitter extends AttributeEmitter {
         const attributesObject = object(true);
         const args = [JSON.stringify(tag)];
         if (svg) {
-            this.helpers.add('svgElement');
             if (attributesObject)
                 args.push(attributesObject);
             this.line(`${declaration} = $$svgElement(${args.join(', ')});`);
         }
         else {
-            this.helpers.add('element');
             if (properties || attributesObject)
                 args.push(properties ?? '{}');
             if (attributesObject)

package/dist/codegen/early-returns.js

@@ -94,7 +94,6 @@ export class EarlyReturnEmitter extends ComponentValueEmitter {
             this.line(`${effect.name}();`);
             if (effect.cleanups === null)
                 continue;
-            this.helpers.add('owner');
             this.line(`$$onRemove(() => $$runDeferred(${effect.cleanups}.splice(0)));`);
         }
     }

package/dist/codegen/elements.js

@@ -93,7 +93,6 @@ export class ElementEmitter extends CreationEmitter {
                 this.line(`${target} = document.createDocumentFragment();`);
             }
             else if (preset) {
-                this.createdElements++;
                 this.line(`${target} = ${preset.name} ?? ${this.createElement(tag, svg)};`);
             }
             else {
@@ -217,7 +216,6 @@ export class ElementEmitter extends CreationEmitter {
                         }
                         case 'unknown':
                             flush();
-                            this.helpers.add('append');
                             this.line(`$$append(${element}, ${this.expression(expression, ARROW)});`);
                             break;
                     }
@@ -258,7 +256,6 @@ export class ElementEmitter extends CreationEmitter {
         }
         const name = `$$content${id}`;
         const update = `$$updateContent${id}`;
-        this.helpers.add('content');
         this.line(`const [${name}, ${update}] = $$content(${this.liveFunction(expression)});`);
         live.depend(sources, `${update}();`);
         return name;