rooklang 0.3.1 → 0.3.3

package/dist/codegen/go-helpers.js

@@ -1,307 +0,0 @@
-// The helpers of `go`: the pool of workers of the program, and the side of the worker. They work
-// with Web Workers and with the worker threads of Node, whose API differs: `on("message")` instead
-// of `onmessage`, and `unref()`, so that idle workers do not keep the program running.
-export const GO_HELPERS = {
-    /** `go` in a module: a call in a worker of the pool, started by $$startWorker of the module. */
-    go: [
-        'function $$go(name, args) {',
-        '  return (globalThis[Symbol.for("rook.goroutines")] ??= $$pool()).call(',
-        '    $$startWorker,',
-        '    name,',
-        '    $$copy(args, true),',
-        '  );',
-        '}',
-        '',
-        '// The workers of the program, shared by its modules: up to one per processor. Each runs the worker',
-        '// module of one module, `start`. Calls wait in one queue and go to a worker of their module that is',
-        '// free: one whose thread is not running code, though its earlier calls may wait in `await`. A',
-        '// worker that is still busy keeps its calls for later; an idle worker of another module makes room',
-        '// for a new one, unless it keeps channels.',
-        'function $$pool() {',
-        '  const size = globalThis.navigator?.hardwareConcurrency ?? 4;',
-        '  const registry = $$registry();',
-        '  const workers = [];',
-        '  const queue = [];',
-        '  const calls = new Map();',
-        '  let ids = 0;',
-        '  // A worker without calls lets the program end, unless something here waits for it.',
-        '  const unref = (worker) => {',
-        '    if (worker.calls === 0 && !(registry.pins.get(worker.key) > 0)) worker.thread.unref?.();',
-        '  };',
-        '  registry.idle = (key) => {',
-        '    const worker = workers.find((each) => each.key === key);',
-        '    if (worker) unref(worker);',
-        '  };',
-        '  const send = (worker, call) => {',
-        '    worker.busy = true;',
-        '    worker.calls++;',
-        '    worker.thread.ref?.();',
-        '    call.worker = worker;',
-        '    calls.set(call.id, call);',
-        '    $$post(worker.key, { call: call.id, name: call.name, args: call.args });',
-        '    call.args = null;',
-        '  };',
-        '  const dispatch = () => {',
-        '    const starting = new Map();',
-        '    for (const worker of workers) {',
-        '      if (!worker.key) starting.set(worker.start, (starting.get(worker.start) ?? 0) + 1);',
-        '    }',
-        '    for (let i = 0; i < queue.length; i++) {',
-        '      const call = queue[i];',
-        '      let free = null;',
-        '      for (const worker of workers) {',
-        '        if (worker.start !== call.start || !worker.key || worker.busy) continue;',
-        '        if (!free || worker.calls < free.calls) free = worker;',
-        '      }',
-        '      // A free worker without calls; else a new worker; else one whose calls wait in await.',
-        '      if (free?.calls === 0 || (free && workers.length >= size)) {',
-        '        queue.splice(i--, 1);',
-        '        send(free, call);',
-        '      } else if (starting.get(call.start) > 0) {',
-        '        starting.set(call.start, starting.get(call.start) - 1);',
-        '      } else if (workers.length < size || retire(call.start)) {',
-        '        add(call.start);',
-        '      } else {',
-        '        // It waits for a busy worker of its module, which may have let go of the program when',
-        '        // its last call returned: the program runs on until that worker is free and takes it.',
-        '        for (const worker of workers) if (worker.start === call.start && worker.key) worker.thread.ref?.();',
-        '      }',
-        '    }',
-        '  };',
-        '  const retire = (start) => {',
-        '    const idle = workers.find(',
-        '      (worker) => worker.key && worker.start !== start && !worker.busy && worker.calls === 0 && !worker.owns,',
-        '    );',
-        '    if (!idle) return false;',
-        '    idle.thread.terminate();',
-        '    remove(idle, null);',
-        '    return true;',
-        '  };',
-        '  // A worker that stopped: its calls fail, and the threads that talked to it forget it.',
-        '  const remove = (worker, error) => {',
-        '    workers.splice(workers.indexOf(worker), 1);',
-        '    for (const [id, call] of calls) {',
-        '      if (call.worker !== worker) continue;',
-        '      calls.delete(id);',
-        '      call.reject(error);',
-        '    }',
-        '    if (worker.key) {',
-        '      $$gone(worker.key);',
-        '      for (const other of workers) other.key && other.thread.postMessage({ gone: worker.key });',
-        '    }',
-        '  };',
-        '  const fail = (worker, error) => {',
-        '    remove(worker, error);',
-        '    dispatch();',
-        '  };',
-        '  const receive = (worker, data) => {',
-        '    if ("op" in data || "answer" in data) return $$incoming(worker.key, data);',
-        '    if ("hello" in data) {',
-        '      worker.key = data.hello;',
-        '      $$connect(worker.key, worker.thread, false);',
-        '      worker.thread.postMessage({ init: registry.key });',
-        '      // Workers talk to each other through ports of their own, also while this thread is busy.',
-        '      for (const other of workers) {',
-        '        if (other === worker || !other.key) continue;',
-        '        const { port1, port2 } = new MessageChannel();',
-        '        worker.thread.postMessage({ port: other.key, through: port1 }, [port1]);',
-        '        other.thread.postMessage({ port: worker.key, through: port2 }, [port2]);',
-        '      }',
-        '      worker.busy = false;',
-        '      unref(worker);',
-        '    } else if ("free" in data) {',
-        '      worker.busy = false;',
-        '      worker.owns = data.owns;',
-        '    } else if ("returned" in data) {',
-        '      $$adopt(data);',
-        '      const call = calls.get(data.returned);',
-        '      calls.delete(data.returned);',
-        '      worker.owns = data.owns;',
-        '      worker.calls--;',
-        '      unref(worker);',
-        '      if ("error" in data) call?.reject(data.error);',
-        '      else call?.resolve(data.value);',
-        '    }',
-        '    dispatch();',
-        '    // A worker that a waiting call held on to, now free and without a call, lets go again.',
-        '    if ("free" in data) unref(worker);',
-        '  };',
-        '  const add = (start) => {',
-        '    const worker = { start, key: null, thread: null, busy: true, calls: 0, owns: false };',
-        '    workers.push(worker);',
-        '    start().then(',
-        '      (thread) => {',
-        '        worker.thread = thread;',
-        '        if (thread.on) {',
-        '          thread.on("message", (data) => receive(worker, data));',
-        '          thread.on("error", (error) => fail(worker, error));',
-        '        } else {',
-        '          thread.onmessage = (event) => receive(worker, event.data);',
-        '          thread.onerror = (event) => fail(worker, new Error(event.message ?? "a worker failed"));',
-        '        }',
-        '      },',
-        '      (error) => {',
-        '        remove(worker, error);',
-        '        for (const call of queue.filter((each) => each.start === start)) {',
-        '          queue.splice(queue.indexOf(call), 1);',
-        '          call.reject(error);',
-        '        }',
-        '      },',
-        '    );',
-        '  };',
-        '  const tasks = new WeakMap();',
-        '  return {',
-        '    call: (start, name, args) => {',
-        '      const call = { id: ids++, start, name, args, resolve: null, reject: null, worker: null };',
-        '      const task = new Promise((resolve, reject) => Object.assign(call, { resolve, reject }));',
-        '      tasks.set(task, call);',
-        '      queue.push(call);',
-        '      dispatch();',
-        '      return task;',
-        '    },',
-        '    // A call that waits leaves the queue; a worker cannot stop a call, so the worker stops, and',
-        '    // the other calls in it fail too.',
-        '    cancel: (task) => {',
-        '      const call = tasks.get(task);',
-        '      tasks.delete(task);',
-        '      if (!call || (!queue.includes(call) && !calls.has(call.id))) return;',
-        '      task.catch(() => {});',
-        '      if (queue.includes(call)) {',
-        '        queue.splice(queue.indexOf(call), 1);',
-        '        return call.reject(new Error("goroutine cancelled"));',
-        '      }',
-        '      calls.delete(call.id);',
-        '      call.reject(new Error("goroutine cancelled"));',
-        '      call.worker.thread.terminate();',
-        '      remove(call.worker, new Error("the worker of the goroutine stopped: another goroutine in it was cancelled"));',
-        '      dispatch();',
-        '    },',
-        '  };',
-        '}',
-    ],
-    /** `go` inside a goroutine: the function runs in the same worker, with copies of the arguments. */
-    goLocal: [
-        'function $$go(fn, args) {',
-        '  const copies = $$copy(args);',
-        '  const run = typeof fn === "function" ? fn : $$goroutines[fn];',
-        '  let cancel;',
-        '  const cancelled = new Promise((_, reject) => (cancel = reject));',
-        '  const task = Promise.race([cancelled, Promise.resolve().then(() => cancel && run(...copies))]);',
-        '  $$registry().cancels.set(task, () => {',
-        '    task.catch(() => {});',
-        '    cancel(new Error("goroutine cancelled"));',
-        '    cancel = null;',
-        '  });',
-        '  return task;',
-        '}',
-    ],
-    goFor: [
-        '// `go for`: the array is split into parts, one per processor, each part runs as a goroutine, and',
-        '// the loop waits for all of them. A typed array on a SharedArrayBuffer is shared with the workers,',
-        '// which write into it; other parts are copies, moved to the workers and back into the array.',
-        'async function $$goFor(name, items, ...captured) {',
-        '  const count = Math.min(globalThis.navigator?.hardwareConcurrency ?? 4, items.length);',
-        '  const shared =',
-        '    typeof SharedArrayBuffer === "function" && items.buffer instanceof SharedArrayBuffer;',
-        '  const parts = [];',
-        '  for (let k = 0; k < count; k++) {',
-        '    const from = Math.floor((items.length * k) / count);',
-        '    const to = Math.floor((items.length * (k + 1)) / count);',
-        '    const part = shared ? items.subarray(from, to) : items.slice(from, to);',
-        '    if (ArrayBuffer.isView(part) && !shared) $$transfer(part);',
-        '    parts.push(',
-        '      $$go(name, [part, from, ...captured]).then((written) => {',
-        '        if (written === undefined || shared) return;',
-        '        if (ArrayBuffer.isView(items)) items.set(written, from);',
-        '        else for (let i = 0; i < written.length; i++) items[from + i] = written[i];',
-        '      }),',
-        '    );',
-        '  }',
-        '  await Promise.all(parts);',
-        '}',
-    ],
-    shared: [
-        '// `make([]T, n, shared)`: the memory of a typed array that the workers of `go for` write into,',
-        '// without copies. A page has SharedArrayBuffer only with cross-origin isolation.',
-        'function $$shared(bytes) {',
-        '  if (typeof SharedArrayBuffer !== "function") {',
-        '    throw new Error(',
-        '      "make(..., shared) needs SharedArrayBuffer, which a page has only with cross-origin isolation: the headers Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp",',
-        '    );',
-        '  }',
-        '  return new SharedArrayBuffer(bytes);',
-        '}',
-    ],
-    serve: [
-        '// The worker: runs the calls that the pool sends and sends back their results or errors. Once the',
-        '// thread is free again, it says so, and the pool may send another call.',
-        'async function $$serve(functions) {',
-        '  const threads = "node:worker_threads";',
-        '  const port =',
-        '    typeof postMessage === "function"',
-        '      ? globalThis',
-        '      : (await import(/* @vite-ignore */ threads)).parentPort;',
-        '  const registry = $$registry();',
-        '  // The port to the main thread keeps the worker running.',
-        '  registry.idle = (key) => key !== registry.main && registry.ports.get(key)?.unref?.();',
-        '  port.postMessage({ hello: registry.key });',
-        '  const free = () => port.postMessage({ free: true, owns: registry.states.size > 0 });',
-        '  const receive = async (data) => {',
-        '    if ("op" in data || "answer" in data) return $$incoming(registry.main, data);',
-        '    if ("init" in data) {',
-        '      registry.main = data.init;',
-        '      return $$connect(data.init, port, false);',
-        '    }',
-        '    if ("port" in data) return $$connect(data.port, data.through, true);',
-        '    if ("gone" in data) return $$gone(data.gone);',
-        '    setTimeout(free);',
-        '    $$adopt(data.args);',
-        '    const { main } = registry;',
-        '    try {',
-        '      const value = await functions[data.name](...data.args);',
-        '      $$post(main, { returned: data.call, value, owns: registry.states.size > 0 });',
-        '    } catch (error) {',
-        '      try {',
-        '        $$post(main, { returned: data.call, error, owns: registry.states.size > 0 });',
-        '      } catch {',
-        '        $$post(main, { returned: data.call, error: new Error(String(error)), owns: true });',
-        '      }',
-        '    }',
-        '  };',
-        '  if (port.on) port.on("message", receive);',
-        '  else port.onmessage = (event) => receive(event.data);',
-        '}',
-    ],
-    cancel: [
-        '// `cancel(task)`: stops a goroutine of `go`, whose Promise fails with "goroutine cancelled". A call',
-        '// in a worker stops with its worker; inside a goroutine, `go` runs in the same worker, so its',
-        '// Promise fails but code that has started goes on.',
-        'function $$cancel(task) {',
-        '  globalThis[Symbol.for("rook.goroutines")]?.cancel(task);',
-        '  $$registry().cancels.get(task)?.();',
-        '}',
-    ],
-};
-/**
- * The start of a worker of a module: a Web Worker, or a worker thread of Node. Node takes only the
- * path of a `file:` URL, without the query of `app.rk?goroutines`, so its worker starts with a
- * module that imports the whole URL. An absolute URL, such as the Blob of the playground, is used
- * as it is.
- */
-export function startWorker(url) {
-    const base = /^[a-z][a-z\d+.-]*:/i.test(url) ? '' : ', import.meta.url';
-    const workerUrl = `new URL(${JSON.stringify(url)}${base})`;
-    return [
-        'async function $$startWorker() {',
-        '  if (typeof Worker === "function") {',
-        `    return new Worker(${workerUrl}, { type: "module" });`,
-        '  }',
-        '  const threads = "node:worker_threads";',
-        '  const { Worker: NodeWorker } = await import(/* @vite-ignore */ threads);',
-        // Vite bundles the Web Worker; this URL is only for Node.
-        `  const url = new URL(/* @vite-ignore */ ${JSON.stringify(url)}${base});`,
-        '  const code = `import ${JSON.stringify(url.href)};`;',
-        '  return new NodeWorker(new URL(`data:text/javascript,${encodeURIComponent(code)}`));',
-        '}',
-    ];
-}

package/dist/codegen/helpers.d.ts

@@ -1,10 +0,0 @@
-import { type ChanHelper } from './chan-helpers.ts';
-import { type GoHelper } from './go-helpers.ts';
-import { type SelectHelper } from './select-helpers.ts';
-import { type ThreadHelper } from './thread-helpers.ts';
-export type Helper = GoHelper | ChanHelper | SelectHelper | ThreadHelper | 'runDeferred' | 'values' | 'append' | 'attribute' | 'content' | 'branches' | 'dynamic' | 'list' | 'owner' | 'mount' | 'style' | 'element' | 'svgElement';
-/** Predeclared functions of goroutines and channels, by the helpers that define them. */
-export declare const PREDECLARED: Readonly<Record<string, Helper>>;
-/** Helpers that use other helpers. */
-export declare const HELPER_NEEDS: Readonly<Partial<Record<Helper, readonly Helper[]>>>;
-export declare const HELPERS: Readonly<Record<Helper, readonly string[]>>;

package/dist/codegen/helpers.js

@@ -1,356 +0,0 @@
-import { CHAN_HELPERS } from "./chan-helpers.js";
-import { GO_HELPERS } from "./go-helpers.js";
-import { SELECT_HELPERS } from "./select-helpers.js";
-import { THREAD_HELPERS } from "./thread-helpers.js";
-/** Predeclared functions of goroutines and channels, by the helpers that define them. */
-export const PREDECLARED = {
-    close: 'chan',
-    transfer: 'threads',
-    after: 'timers',
-    tick: 'timers',
-    cancel: 'cancel',
-};
-/** Helpers that use other helpers. */
-export const HELPER_NEEDS = {
-    go: ['threads'],
-    goFor: ['threads'],
-    goLocal: ['threads'],
-    serve: ['threads'],
-    chan: ['threads', 'select'],
-    timers: ['chan'],
-    cancel: ['threads'],
-    select: ['chan'],
-    owner: ['runDeferred'],
-    mount: ['owner'],
-    content: ['owner'],
-    branches: ['owner'],
-    dynamic: ['owner'],
-    list: ['owner'],
-};
-export const HELPERS = {
-    ...GO_HELPERS,
-    ...CHAN_HELPERS,
-    ...SELECT_HELPERS,
-    ...THREAD_HELPERS,
-    /** `for v in x` over an untyped value: a Map gives its values, as a typed one does. */
-    values: [
-        'function $$values(iterable) {',
-        "  if (typeof iterable === 'function') return iterable();",
-        '  return iterable instanceof Map ? iterable.values() : iterable;',
-        '}',
-    ],
-    /** Runs deferred calls in reverse order; every call runs even if an earlier one throws. */
-    runDeferred: [
-        'function $$runDeferred(deferred) {',
-        '  let failure;',
-        '  for (let i = deferred.length - 1; i >= 0; i--) {',
-        '    try {',
-        '      deferred[i]();',
-        '    } catch (error) {',
-        '      failure = { error };',
-        '    }',
-        '  }',
-        '  if (failure) throw failure.error;',
-        '}',
-    ],
-    /**
-     * Owners of markup that `{if}`, `{switch}` and `{for}` may remove: the functions returned by the
-     * `mount()` of its components, and the removal of the blocks inside it, run when it is removed.
-     * The current owner is shared by the modules of a page, since the blocks of one module may hold
-     * the components of another.
-     */
-    owner: [
-        'const $$owner = Symbol.for("rook.owner");',
-        '',
-        'function $$owned(create) {',
-        '  const owner = { removed: false, cleanups: [] };',
-        '  const parent = globalThis[$$owner];',
-        '  globalThis[$$owner] = owner;',
-        '  let result;',
-        '  try {',
-        '    result = create();',
-        '  } finally {',
-        '    globalThis[$$owner] = parent;',
-        '  }',
-        '  const remove = () => {',
-        '    if (owner.removed) return;',
-        '    owner.removed = true;',
-        '    $$runDeferred(owner.cleanups);',
-        '  };',
-        '  return [result, remove];',
-        '}',
-        '',
-        'function $$onRemove(cleanup) {',
-        '  globalThis[$$owner]?.cleanups.push(cleanup);',
-        '}',
-    ],
-    /**
-     * `mount() { ... }` of a component: runs when its markup is in the document. That is checked
-     * after the code that creates the component; markup that is not in the document yet is waited
-     * for with a MutationObserver, which watches only while some markup waits. Markup that its
-     * owner removes before that never mounts. The function `mount` returns runs when the owner is
-     * removed.
-     */
-    mount: [
-        'const $$waiting = new Set();',
-        'let $$observer = null;',
-        '',
-        'function $$mount(node, mount) {',
-        '  const entry = { node, mount, owner: globalThis[$$owner] };',
-        '  entry.owner?.cleanups.push(() => $$waiting.delete(entry));',
-        '  queueMicrotask(() => $$tryMount(entry));',
-        '}',
-        '',
-        'function $$tryMount(entry) {',
-        '  if (entry.owner?.removed) return;',
-        '  const node = entry.node();',
-        '  if (node != null && !node.isConnected) {',
-        '    $$waiting.add(entry);',
-        '    if (!$$observer) {',
-        '      $$observer = new MutationObserver($$mountWaiting);',
-        '      $$observer.observe(node.ownerDocument ?? document, { childList: true, subtree: true });',
-        '    }',
-        '    return;',
-        '  }',
-        '  const cleanup = entry.mount();',
-        '  if (typeof cleanup === "function") entry.owner?.cleanups.push(cleanup);',
-        '}',
-        '',
-        'function $$mountWaiting() {',
-        '  for (const entry of $$waiting) {',
-        '    if (!entry.node().isConnected) continue;',
-        '    $$waiting.delete(entry);',
-        '    $$tryMount(entry);',
-        '  }',
-        '  if ($$waiting.size === 0) {',
-        '    $$observer.disconnect();',
-        '    $$observer = null;',
-        '  }',
-        '}',
-    ],
-    /** Appends element content whose type is not known: null adds nothing, arrays add each item. */
-    append: [
-        'function $$append(parent, value) {',
-        '  if (value == null || value === false) return;',
-        '  if (Array.isArray(value)) {',
-        '    for (const item of value) $$append(parent, item);',
-        '  } else {',
-        '    parent.append(value);',
-        '  }',
-        '}',
-    ],
-    /**
-     * Nodes of markup that change, `{list}` or `{ok ? <b /> : null}`: they are kept before an end
-     * marker. Nodes that stay are moved rather than created again. Returns the markers with the
-     * first nodes, to be inserted, and the update.
-     */
-    content: [
-        'function $$content(value) {',
-        '  const end = document.createTextNode("");',
-        '  const fragment = document.createDocumentFragment();',
-        '  fragment.append(end);',
-        '  let nodes = [];',
-        '  let remove;',
-        '  const update = () => {',
-        '    const next = [];',
-        '    const add = (item) => {',
-        '      if (item == null || item === false) return;',
-        '      if (Array.isArray(item)) {',
-        '        for (const each of item) add(each);',
-        '      } else if (item.nodeType === 11) {',
-        '        next.push(...item.childNodes);',
-        '      } else {',
-        '        next.push(typeof item === "object" ? item : document.createTextNode(String(item)));',
-        '      }',
-        '    };',
-        '    const [created, removeCreated] = $$owned(value);',
-        '    add(created);',
-        '    remove?.();',
-        '    remove = removeCreated;',
-        '    const kept = new Set(next);',
-        '    for (const node of nodes) if (!kept.has(node)) node.remove();',
-        '    end.before(...next);',
-        '    nodes = next;',
-        '  };',
-        '  update();',
-        '  $$onRemove(() => remove?.());',
-        '  return [fragment, update];',
-        '}',
-    ],
-    /**
-     * `{if ...}` and `{switch ...}` in markup: shows the block that `choose` picks (-1 for none)
-     * between two markers. The block is created again only when the choice changes; otherwise it is
-     * updated.
-     */
-    branches: [
-        'function $$branches(choose, blocks) {',
-        '  const start = document.createTextNode("");',
-        '  const end = document.createTextNode("");',
-        '  const fragment = document.createDocumentFragment();',
-        '  fragment.append(start, end);',
-        '  let current = null;',
-        '  let update;',
-        '  let remove;',
-        '  const render = () => {',
-        '    const next = choose();',
-        '    if (next === current) {',
-        '      update?.();',
-        '      return;',
-        '    }',
-        '    current = next;',
-        '    remove?.();',
-        '    while (start.nextSibling !== end) start.nextSibling.remove();',
-        '    update = undefined;',
-        '    remove = undefined;',
-        '    if (next >= 0) {',
-        '      const [[content, blockUpdate], removeBlock] = $$owned(blocks[next]);',
-        '      end.before(content);',
-        '      update = blockUpdate;',
-        '      remove = removeBlock;',
-        '    }',
-        '  };',
-        '  render();',
-        '  $$onRemove(() => remove?.());',
-        '  return [fragment, render];',
-        '}',
-    ],
-    /**
-     * `<Page />` whose component is a value that changes: when it does, the block that `create`
-     * makes with it is created again between two markers; otherwise the block is updated.
-     */
-    dynamic: [
-        'function $$dynamic(component, create) {',
-        '  const start = document.createTextNode("");',
-        '  const end = document.createTextNode("");',
-        '  const fragment = document.createDocumentFragment();',
-        '  fragment.append(start, end);',
-        '  let current;',
-        '  let update;',
-        '  let remove;',
-        '  const render = () => {',
-        '    const next = component();',
-        '    if (remove && next === current) {',
-        '      update?.();',
-        '      return;',
-        '    }',
-        '    current = next;',
-        '    remove?.();',
-        '    while (start.nextSibling !== end) start.nextSibling.remove();',
-        '    const [[content, blockUpdate], removeBlock] = $$owned(() => create(next));',
-        '    end.before(content);',
-        '    update = blockUpdate;',
-        '    remove = removeBlock;',
-        '  };',
-        '  render();',
-        '  $$onRemove(() => remove?.());',
-        '  return [fragment, render];',
-        '}',
-    ],
-    /**
-     * `{for item in items { ... }}` in markup: a block for each item, between its own markers. On
-     * updates the blocks are found again by the item itself: blocks of items that stay are updated
-     * and moved into place, others are created or removed.
-     */
-    list: [
-        'function $$list(items, create) {',
-        '  const end = document.createTextNode("");',
-        '  const fragment = document.createDocumentFragment();',
-        '  fragment.append(end);',
-        '  let blocks = [];',
-        '  const nodesOf = (block) => {',
-        '    const nodes = [];',
-        '    for (let node = block.start; node !== block.end; node = node.nextSibling) nodes.push(node);',
-        '    nodes.push(block.end);',
-        '    return nodes;',
-        '  };',
-        '  const update = () => {',
-        '    const old = new Map();',
-        '    for (const block of blocks) {',
-        '      const same = old.get(block.item);',
-        '      if (same) same.push(block);',
-        '      else old.set(block.item, [block]);',
-        '    }',
-        '    const next = [];',
-        '    let index = 0;',
-        '    for (const item of items()) {',
-        '      let block = old.get(item)?.shift();',
-        '      if (block) {',
-        '        block.update?.(index);',
-        '      } else {',
-        '        const [[content, blockUpdate], remove] = $$owned(() => create(item, index));',
-        '        block = { item, start: document.createTextNode(""), end: document.createTextNode("") };',
-        '        block.update = blockUpdate;',
-        '        block.remove = remove;',
-        '        block.content = document.createDocumentFragment();',
-        '        block.content.append(block.start, content, block.end);',
-        '      }',
-        '      next.push(block);',
-        '      index++;',
-        '    }',
-        '    for (const same of old.values()) {',
-        '      for (const block of same) {',
-        '        block.remove();',
-        '        for (const node of nodesOf(block)) node.remove();',
-        '      }',
-        '    }',
-        '    let before = end;',
-        '    for (let i = next.length - 1; i >= 0; i--) {',
-        '      const block = next[i];',
-        '      if (block.content) {',
-        '        before.before(block.content);',
-        '        block.content = null;',
-        '      } else if (block.end.nextSibling !== before) {',
-        '        before.before(...nodesOf(block));',
-        '      }',
-        '      before = block.start;',
-        '    }',
-        '    blocks = next;',
-        '  };',
-        '  update();',
-        '  $$onRemove(() => {',
-        '    for (const block of blocks) block.remove();',
-        '  });',
-        '  return [fragment, update];',
-        '}',
-    ],
-    /** Creates an element with its properties and the attributes that are set with setAttribute. */
-    element: [
-        'function $$element(tag, properties, attributes) {',
-        '  const element = Object.assign(document.createElement(tag), properties);',
-        '  for (const name in attributes) element.setAttribute(name, attributes[name]);',
-        '  return element;',
-        '}',
-    ],
-    /** Creates an SVG element with its attributes. */
-    svgElement: [
-        'function $$svgElement(tag, attributes) {',
-        '  const element = document.createElementNS("http://www.w3.org/2000/svg", tag);',
-        '  for (const name in attributes) element.setAttribute(name, attributes[name]);',
-        '  return element;',
-        '}',
-    ],
-    /** Sets an attribute whose value may be null: then the attribute is removed. */
-    attribute: [
-        'function $$attribute(element, name, value) {',
-        '  if (value == null) element.removeAttribute(name);',
-        '  else element.setAttribute(name, value);',
-        '}',
-    ],
-    /**
-     * Adds the CSS of a component to the page once: modules that inline the same component add it
-     * with the same id. `$$styles` keeps the CSS of the module for the shadow roots of its web
-     * components, which the page's styles do not reach.
-     */
-    style: [
-        'const $$styles = [];',
-        '',
-        'function $$style(id, css) {',
-        '  $$styles.push(css);',
-        '  if (document.getElementById(id)) return;',
-        '  const style = document.createElement("style");',
-        '  style.id = id;',
-        '  style.textContent = css;',
-        '  document.head.append(style);',
-        '}',
-    ],
-};