tutuca 0.11.0 → 0.11.2

package/skill/tutuca-source/tutuca.ext.js

@@ -1,4235 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// src/collection.js
-var isPlainObject = (value) => {
-  if (value === null || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var seqSize = (seq) => {
-  if (seq == null) return 0;
-  if (typeof seq.length === "number") return seq.length;
-  if (typeof seq.size === "number") return seq.size;
-  return isPlainObject(seq) ? Object.keys(seq).length : 0;
-};
-var seqGet = (seq, key, dval = null) => {
-  if (seq == null) return dval;
-  if (seq instanceof Map) return seq.has(key) ? seq.get(key) : dval;
-  if (seq instanceof Set) return seq.has(key) ? key : dval;
-  if (Object.hasOwn(seq, key)) return seq[key];
-  if (typeof seq.get === "function") return seq.get(key, dval);
-  return dval;
-};
-var isIndexedSeq = (seq) => Array.isArray(seq);
-var isKeyedSeq = (seq) => seq instanceof Map || isPlainObject(seq);
-var isSetSeq = (seq) => seq instanceof Set;
-function* seqEntries(seq) {
-  if (seq instanceof Map) yield* seq.entries();
-  else if (seq instanceof Set) for (const value of seq) yield [value, value];
-  else if (isPlainObject(seq)) yield* Object.entries(seq);
-  else if (Array.isArray(seq)) for (let i = 0; i < seq.length; i++) yield [i, seq[i]];
-}
-
-// src/immer.js
-var immer_exports = {};
-__reExport(immer_exports, immer_star);
-import { enableMapSet } from "immer";
-import * as immer_star from "immer";
-enableMapSet();
-
-// src/path.js
-var NONE = /* @__PURE__ */ Symbol("NONE");
-var readKey = (value, key, dval = null) => {
-  if (value == null) return dval;
-  if (value instanceof Map) return value.has(key) ? value.get(key) : dval;
-  if (value instanceof Set) return value.has(key) ? key : dval;
-  return Object.hasOwn(value, key) ? value[key] : dval;
-};
-var writeKey = (value, key, next) => {
-  if (value instanceof Map) value.set(key, next);
-  else if (value instanceof Set) {
-    value.delete(key);
-    value.add(next);
-  } else value[key] = next;
-};
-var readSeqKey = (value, key, dval = null) => {
-  const direct = readKey(value, key, NONE);
-  if (direct !== NONE) return direct;
-  return typeof value?.get === "function" ? value.get(key, dval) : dval;
-};
-var writeSeqKey = (value, key, next) => {
-  if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
-    writeKey(value, key, next);
-  else if (typeof value?.set === "function") value.set(key, next);
-  else writeKey(value, key, next);
-};
-var Step = class {
-  lookup(_v, dval = null) {
-    return dval;
-  }
-  setValue(root, _v) {
-    return root;
-  }
-  setDraftValue(_root, _v) {
-  }
-  enterFrame(stack, _prev, next) {
-    return stack.enter(next, {}, true);
-  }
-  toAbstractPathStep() {
-    return this;
-  }
-  // Freeze any field-resolved key against the value `v` entering this step (see
-  // `Path.pinKeys`). Most steps carry no live key and pin to themselves.
-  pinKey(_v) {
-    return this;
-  }
-  // A generic `{ field, key? }` descriptor for this step, or null for frame-only
-  // steps (binds) that address no field. Used by `Path.toKeys()` so tooling can
-  // introspect a path without reaching into Step subclasses.
-  toKey() {
-    return null;
-  }
-};
-var BindStep = class _BindStep extends Step {
-  constructor(binds) {
-    super();
-    this.binds = binds;
-  }
-  lookup(v, _dval) {
-    return v;
-  }
-  setValue(_root, v) {
-    return v;
-  }
-  enterFrame(stack, _prev, next) {
-    return stack.enter(next, { ...this.binds }, false);
-  }
-  withIndex(i) {
-    return new _BindStep({ ...this.binds, key: i });
-  }
-  withKey(key) {
-    return new _BindStep({ ...this.binds, key });
-  }
-  toAbstractPathStep() {
-    return null;
-  }
-};
-var ScopeBindStep = class _ScopeBindStep extends BindStep {
-  constructor(val, binds = {}) {
-    super(binds);
-    this.val = val;
-  }
-  enterFrame(stack, _prev, next) {
-    const dyn = this.val.evalAsHandler(stack)?.call(stack.it) ?? {};
-    return stack.enter(next, { ...this.binds, ...dyn }, false);
-  }
-  withIndex(i) {
-    return new _ScopeBindStep(this.val, { ...this.binds, key: i });
-  }
-  withKey(key) {
-    return new _ScopeBindStep(this.val, { ...this.binds, key });
-  }
-};
-var FieldStep = class extends Step {
-  constructor(field) {
-    super();
-    this.field = field;
-  }
-  lookup(v, dval = null) {
-    return readKey(v, this.field, dval);
-  }
-  setValue(root, v) {
-    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
-  }
-  setDraftValue(root, v) {
-    writeKey(root, this.field, v);
-  }
-  withIndex(i) {
-    return new SeqStep(this.field, i);
-  }
-  withKey(k) {
-    return new SeqStep(this.field, k);
-  }
-  toKey() {
-    return { field: this.field };
-  }
-};
-var SeqStep = class extends Step {
-  constructor(field, key) {
-    super();
-    this.field = field;
-    this.key = key;
-  }
-  lookup(v, dval = null) {
-    return readSeqKey(readKey(v, this.field, null), this.key, dval);
-  }
-  setValue(root, v) {
-    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
-  }
-  setDraftValue(root, v) {
-    const seq = readKey(root, this.field, null);
-    if (seq != null) writeSeqKey(seq, this.key, v);
-  }
-  enterFrame(stack, _prev, next) {
-    return stack.enter(next, { key: this.key }, true);
-  }
-  toKey() {
-    return { field: this.field, key: this.key };
-  }
-};
-var SeqAccessStep = class extends Step {
-  constructor(seqField, keyField) {
-    super();
-    this.seqField = seqField;
-    this.keyField = keyField;
-  }
-  lookup(v, dval = null) {
-    const seq = readKey(v, this.seqField, NONE);
-    const key = readKey(v, this.keyField, NONE);
-    return key !== NONE && seq !== NONE ? readSeqKey(seq, key, dval) : dval;
-  }
-  setValue(root, v) {
-    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
-  }
-  setDraftValue(root, v) {
-    const seq = readKey(root, this.seqField, NONE);
-    const key = readKey(root, this.keyField, NONE);
-    if (seq !== NONE && key !== NONE) writeSeqKey(seq, key, v);
-  }
-  // Resolve `keyField` against `v` now and freeze it as a literal-key `SeqStep`, so a
-  // later lookup/setValue lands on this same item even if `keyField` changes meanwhile.
-  pinKey(v) {
-    const key = readKey(v, this.keyField, NONE);
-    return key === NONE ? this : new SeqStep(this.seqField, key);
-  }
-  // The key is a *field reference* resolved live, so it is unknown without a value;
-  // report the seq field (no key) rather than dropping the step, which would shift
-  // the indices of later keys. Call `Path.pinKeys(root)` first to get a concrete key.
-  toKey() {
-    return { field: this.seqField };
-  }
-};
-var EachBindStep = class extends Step {
-  constructor(iterInfo, key) {
-    super();
-    this.iterInfo = iterInfo;
-    this.key = key;
-  }
-  lookup(v, _dval) {
-    return v;
-  }
-  setValue(_root, v) {
-    return v;
-  }
-  // Replay the renderer's per-item binds (key, value + any @enrich-with binds)
-  // so a rebuilt stack matches the one @each rendered with.
-  enterFrame(stack, _prev, next) {
-    return stack.enter(next, this.iterInfo.enrichBinds(stack, this.key), false);
-  }
-  toAbstractPathStep() {
-    return null;
-  }
-};
-var EachRenderItStep = class extends SeqStep {
-  enterFrame(stack, _prev, next) {
-    return stack.enter(next, { key: this.key, value: next }, false).enter(next, {}, true);
-  }
-  toAbstractPathStep() {
-    return new SeqStep(this.field, this.key);
-  }
-};
-function warnRawDynStep(op, step) {
-  console.warn(`Path.${op} reached a DynStep: call toTransactionPath() first`, step);
-}
-var DynStep = class extends Step {
-  constructor(producerCompId, producerSteps) {
-    super();
-    this.producerCompId = producerCompId;
-    this.producerSteps = producerSteps;
-    this.interiorCids = /* @__PURE__ */ new Set();
-  }
-  // Steps spliced into the transaction path in place of this marker.
-  teleportSteps() {
-    return this.producerSteps;
-  }
-  lookup(_v, dval = null) {
-    warnRawDynStep("lookup", this);
-    return dval;
-  }
-  setValue(root, _v) {
-    warnRawDynStep("setValue", this);
-    return root;
-  }
-  enterFrame(stack, _prev, _next) {
-    warnRawDynStep("enterFrame", this);
-    return stack;
-  }
-};
-var DynEachStep = class extends DynStep {
-  constructor(producerCompId, producerSteps, key) {
-    super(producerCompId, producerSteps);
-    this.key = key;
-  }
-  teleportSteps() {
-    const { producerSteps, key } = this;
-    if (producerSteps.length === 0) return producerSteps;
-    const last = producerSteps[producerSteps.length - 1];
-    if (!(last instanceof FieldStep)) {
-      console.warn("DynEachStep: seq-access dynamic cannot be iterated", this);
-      return producerSteps;
-    }
-    return producerSteps.slice(0, -1).concat(new SeqStep(last.field, key));
-  }
-};
-var Path = class _Path {
-  constructor(steps = []) {
-    this.steps = steps;
-  }
-  concat(steps) {
-    return new _Path(this.steps.concat(steps));
-  }
-  popStep() {
-    return new _Path(this.steps.slice(0, -1));
-  }
-  // The dispatch path: frame-only steps removed, one step per crossed component
-  // (DynStep included). `popStep` over it bubbles through every component.
-  compact() {
-    const out = [];
-    for (const step of this.steps) {
-      const s = step.toAbstractPathStep();
-      if (s !== null) {
-        if (s !== step) s._originCid = step._originCid;
-        out.push(s);
-      }
-    }
-    return new _Path(out);
-  }
-  // The abstract path used to apply a transaction: every DynStep is teleported —
-  // the steps interior to its producer..consumer span are dropped and the
-  // producer's own path spliced in — so a mutation lands on the data's real
-  // location. A path with no DynStep is returned unchanged.
-  toTransactionPath() {
-    let hasDyn = false;
-    for (const step of this.steps)
-      if (step instanceof DynStep) {
-        hasDyn = true;
-        break;
-      }
-    if (!hasDyn) return this;
-    const out = [];
-    for (const step of this.steps) {
-      if (step instanceof DynStep) {
-        while (out.length > 0 && step.interiorCids.has(out[out.length - 1]._originCid)) out.pop();
-        for (const ts of step.teleportSteps()) {
-          ts._originCid = step.producerCompId;
-          out.push(ts);
-        }
-      } else out.push(step);
-    }
-    return new _Path(out);
-  }
-  // Resolve every field-keyed step (e.g. `SeqAccessStep`) against `root`, freezing the
-  // key as it is *now* so a later lookup/setValue lands on the same item even if the
-  // keyField changed meanwhile (e.g. the selected tab moved while a request was in
-  // flight). Returns a new Path with those steps replaced; `this` if nothing pinned.
-  // Must be called on a transaction path (no DynSteps — call toTransactionPath first).
-  pinKeys(root) {
-    let curVal = root;
-    let out = null;
-    for (let i = 0; i < this.steps.length; i++) {
-      const step = this.steps[i];
-      const pinned = step.pinKey(curVal);
-      if (pinned !== step) (out ??= this.steps.slice())[i] = pinned;
-      curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE) break;
-    }
-    return out ? new _Path(out) : this;
-  }
-  lookup(v, dval = null) {
-    let curVal = v;
-    for (const step of this.steps) {
-      curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE) return dval;
-    }
-    return curVal;
-  }
-  // The values entered along the path, root→leaf (root included): index 0 is `root`,
-  // the last entry is the leaf this path resolves to. Stops early at the first
-  // unresolvable step. Call on a transaction path (no DynSteps). Used to walk the
-  // component instances on a dispatch path (filter via Components.getCompFor).
-  resolveChain(root) {
-    const out = [root];
-    let curVal = root;
-    for (const step of this.steps) {
-      curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE) break;
-      out.push(curVal);
-    }
-    return out;
-  }
-  // A flat `[{ field, key? }]` list of the addressing steps, skipping frame-only
-  // steps (binds). Generic path introspection so tooling (e.g. the storybook
-  // activity log) can identify which subtree a transaction touched without
-  // depending on Step internals. Call on a transaction path (no DynSteps).
-  toKeys() {
-    const out = [];
-    for (const step of this.steps) {
-      const k = step.toKey();
-      if (k !== null) out.push(k);
-    }
-    return out;
-  }
-  setValue(root, v) {
-    if (this.steps.length === 0) return v;
-    return (0, immer_exports.produce)(root, (draft) => {
-      let parent = draft;
-      for (let i = 0; i < this.steps.length - 1; i++) {
-        parent = this.steps[i].lookup(parent, NONE);
-        if (parent === NONE) return;
-      }
-      this.steps.at(-1).setDraftValue(parent, v);
-    });
-  }
-  buildStack(stack) {
-    let prev = stack.it;
-    for (const step of this.steps) {
-      const next = step.lookup(prev, NONE);
-      if (next === NONE) {
-        console.warn("bad PathItem", { root: stack.it, step, path: this });
-        return null;
-      }
-      stack = step.enterFrame(stack, prev, next);
-      prev = next;
-    }
-    return stack;
-  }
-  static fromNodeAndEventName(node, eventName, rootNode, maxDepth, comps, stopOnNoEvent = true) {
-    const pathSteps = [];
-    const pendingDyns = [];
-    const bubbles = BUBBLING_EVENTS.has(eventName);
-    let depth = 0;
-    let eventIds = [];
-    let handlers = null;
-    let nodeIds = [];
-    let isLeafComponent = true;
-    const crossComponent = (cidNum, vid) => {
-      const comp = comps.getComponentForId(cidNum);
-      let pushStep = true;
-      if (handlers === null && (isLeafComponent || bubbles)) {
-        handlers = findHandlers(comp, eventIds, vid, eventName);
-        if (handlers === null) {
-          if (isLeafComponent && stopOnNoEvent && !bubbles) return false;
-        } else if (!isLeafComponent) {
-          pathSteps.length = 0;
-          pendingDyns.length = 0;
-          pushStep = false;
-        }
-      }
-      isLeafComponent = false;
-      for (const dyn of pendingDyns) dyn.interiorCids.add(cidNum);
-      if (pushStep) {
-        const step = resolvePathStep(comp, nodeIds, vid);
-        if (step) {
-          step._originCid = cidNum;
-          pathSteps.push(step);
-          if (step instanceof DynStep) {
-            step.interiorCids.add(cidNum);
-            pendingDyns.push(step);
-          }
-        }
-      }
-      for (let i = pendingDyns.length - 1; i >= 0; i--)
-        if (pendingDyns[i].producerCompId === cidNum) pendingDyns.splice(i, 1);
-      eventIds = [];
-      nodeIds = [];
-      return true;
-    };
-    while (node && node !== rootNode && depth < maxDepth) {
-      if (node?.dataset) {
-        const { eid, cid, vid } = node.dataset;
-        if (eid !== void 0) eventIds.push(eid);
-        const metas = metaChain(node.previousSibling);
-        let sawComp = false;
-        for (const m of metas) {
-          if (m.$ === "Comp") {
-            sawComp = true;
-            if (!crossComponent(m.cid, m.vid)) return NO_EVENT_INFO;
-            nodeIds.push({ nid: m.nid });
-          } else {
-            nodeIds.push({ nid: m.nid, si: m.si, sk: m.sk });
-          }
-        }
-        if (!sawComp && cid !== void 0 && !crossComponent(+cid, vid)) return NO_EVENT_INFO;
-      }
-      depth += 1;
-      node = node.parentNode;
-    }
-    if (pendingDyns.length > 0)
-      console.warn("event reconstruction: dynamic-var producer not found", pendingDyns);
-    return [new _Path(pathSteps.reverse()), handlers];
-  }
-  static fromEvent(e, rNode, maxDepth, comps, stopOnNoEvent = true) {
-    const { type, target } = e;
-    return _Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
-  }
-};
-function metaChain(n) {
-  const out = [];
-  while (n?.nodeType === 8 && n.textContent[0] === "§") {
-    try {
-      out.push(JSON.parse(n.textContent.slice(1, -1)));
-    } catch (err) {
-      console.warn(err, n);
-    }
-    n = n.previousSibling;
-  }
-  return out;
-}
-function findHandlers(comp, eventIds, vid, eventName) {
-  for (const eid of eventIds) {
-    const handlers = comp.getEventForId(+eid, vid).getHandlersFor(eventName);
-    if (handlers !== null) return handlers;
-  }
-  return null;
-}
-var StepCtx = class _StepCtx {
-  constructor(comp, nodeIds, idx, vid) {
-    this.comp = comp;
-    this.nodeIds = nodeIds;
-    this.idx = idx;
-    this.vid = vid;
-  }
-  get meta() {
-    return this.nodeIds[this.idx];
-  }
-  get key() {
-    const m = this.meta;
-    return m.si !== void 0 ? +m.si : m.sk;
-  }
-  get hasKey() {
-    const m = this.meta;
-    return m.si !== void 0 || m.sk !== void 0;
-  }
-  next() {
-    const { idx, nodeIds } = this;
-    return idx + 1 < nodeIds.length ? new _StepCtx(this.comp, nodeIds, idx + 1, this.vid) : null;
-  }
-  resolveNode() {
-    return this.comp.getNodeForId(+this.meta.nid, this.vid);
-  }
-  applyKey(pi) {
-    if (pi === null) return null;
-    const m = this.meta;
-    if (m.si !== void 0) return pi.withIndex(+m.si);
-    if (m.sk !== void 0) return pi.withKey(m.sk);
-    return pi;
-  }
-};
-function resolvePathStep(comp, nodeIds, vid) {
-  for (let i = 0; i < nodeIds.length; i++) {
-    const ctx = new StepCtx(comp, nodeIds, i, vid);
-    const step = ctx.resolveNode().toPathStep(ctx);
-    if (step !== null) return step;
-  }
-  return null;
-}
-var NO_EVENT_INFO = [null, null];
-var BUBBLING_EVENTS = /* @__PURE__ */ new Set(["drop"]);
-var PathBuilder = class {
-  constructor() {
-    this.pathChanges = [];
-  }
-  add(pathChange) {
-    this.pathChanges.push(pathChange);
-    return this;
-  }
-  field(name) {
-    return this.add(new FieldStep(name));
-  }
-  index(name, index) {
-    return this.add(new SeqStep(name, index));
-  }
-  key(name, key) {
-    return this.add(new SeqStep(name, key));
-  }
-};
-
-// src/value.js
-var VALID_VAL_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*\??$/;
-var isValidValId = (name) => VALID_VAL_ID_RE.test(name);
-var VALID_FLOAT_RE = /^-?[0-9]+(\.[0-9]+)?$/;
-var STR_TPL_SPLIT_RE = /(\{[^}]+\})/g;
-var mkVal = (name, Cls) => isValidValId(name) ? new Cls(name) : null;
-var VAL_TOKEN_RE = /\$'(?:[^'\\]|\\.)*'|'(?:[^'\\]|\\.)*'|\S+/g;
-var tokenizeValue = (s) => s.match(VAL_TOKEN_RE) ?? [];
-var unescapeStr = (s) => s.replace(/\\(['\\])/g, "$1");
-var K_CONST = 1;
-var K_STRTPL = 2;
-var K_FIELD = 4;
-var K_BIND = 8;
-var K_DYN = 16;
-var K_NAME = 32;
-var K_TYPE = 64;
-var K_SEQ = 256;
-var K_METHOD = 1024;
-var G_BOOL = K_FIELD | K_METHOD | K_BIND | K_DYN | K_CONST;
-var G_TEXT = G_BOOL | K_STRTPL;
-var G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
-var G_SEQUENCE = K_FIELD | K_DYN;
-var G_PROVIDE = K_FIELD | K_SEQ;
-var G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
-var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
-var G_ALL = G_VALUE | K_STRTPL | K_SEQ;
-function sizeOf(v) {
-  if (v == null) return null;
-  const s = v.size;
-  if (typeof s === "number") return s;
-  const l = v.length;
-  if (typeof l === "number") return l;
-  return isPlainObject(v) ? Object.keys(v).length : null;
-}
-var predTruthy = (v) => {
-  const n = sizeOf(v);
-  return n === null ? !!v : n > 0;
-};
-var PREDICATES = {
-  "empty?": { name: "empty?", arity: 1, fn: (v) => v == null || sizeOf(v) === 0 },
-  "truthy?": { name: "truthy?", arity: 1, fn: predTruthy },
-  "falsy?": { name: "falsy?", arity: 1, fn: (v) => !predTruthy(v) },
-  "null?": { name: "null?", arity: 1, fn: (v) => v == null },
-  "equals?": { name: "equals?", arity: 2, fn: (a, b) => Object.is(a, b) }
-};
-function parseToken(s, px) {
-  const c0 = s.charCodeAt(0);
-  if (c0 === 39)
-    return s.length >= 2 && s.charCodeAt(s.length - 1) === 39 ? new ConstVal(unescapeStr(s.slice(1, -1))) : null;
-  if (c0 === 36 && s.charCodeAt(1) === 39)
-    return s.length >= 3 && s.charCodeAt(s.length - 1) === 39 ? StrTplVal.parse(s.slice(2, -1), px) : null;
-  if (s.indexOf("[") !== -1 || s.indexOf("]") !== -1) return _parseSeqAccess(s, px);
-  if (s.indexOf("{") !== -1 || s.indexOf("}") !== -1) return null;
-  switch (c0) {
-    case 94: {
-      const name = s.slice(1);
-      const newS = px.frame.macroVars?.[name];
-      if (newS !== void 0) {
-        const tokens = tokenizeValue(newS.trim());
-        if (tokens.length !== 1) return null;
-        const val = parseToken(tokens[0], px);
-        if (val instanceof ConstVal) val.fromMacroVar = true;
-        return val;
-      }
-      px.onParseIssue("bad-value", { role: "macro-var", name, value: s });
-      return null;
-    }
-    case 36:
-      return mkVal(s.slice(1), MethodVal);
-    case 64: {
-      const dot = s.indexOf(".", 1);
-      if (dot === -1) return mkVal(s.slice(1), BindVal);
-      const name = s.slice(1, dot);
-      const member = s.slice(dot + 1);
-      return isValidValId(name) && isValidValId(member) ? new BindMemberVal(name, member) : null;
-    }
-    case 42:
-      return mkVal(s.slice(1), DynVal);
-    case 46:
-      return mkVal(s.slice(1), FieldVal);
-  }
-  const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
-  if (Number.isFinite(num)) return new ConstVal(num);
-  if (s === "true" || s === "false") return new ConstVal(s === "true");
-  if (c0 >= 97 && c0 <= 122) return mkVal(s, NameVal);
-  if (c0 >= 65 && c0 <= 90) return mkVal(s, TypeVal);
-  return null;
-}
-function _parseSeqAccess(s, px) {
-  const open = s.indexOf("[");
-  const close = s.indexOf("]");
-  if (open < 1 || close !== s.length - 1 || close < open || s.indexOf("[", open + 1) !== -1)
-    return null;
-  const left = parseToken(s.slice(0, open), px);
-  const right = parseToken(s.slice(open + 1, close), px);
-  return left instanceof FieldVal && right instanceof FieldVal ? new SeqAccessVal(left, right) : null;
-}
-function _parseSingle(s, px, group) {
-  const tokens = tokenizeValue(s.trim());
-  if (tokens.length !== 1) return null;
-  const val = parseToken(tokens[0], px);
-  return val !== null && kindOf(val) & group ? val : null;
-}
-function parseBool(s, px) {
-  const t = s.trim();
-  const tokens = tokenizeValue(t);
-  if (tokens.length !== 1) return tokens.length === 0 ? null : _parsePredicate(t, tokens, px);
-  const val = parseToken(tokens[0], px);
-  return val !== null && kindOf(val) & G_BOOL ? val : null;
-}
-function parseText(s, px) {
-  return _parseSingle(s, px, G_TEXT);
-}
-function parseComponent(s, px) {
-  return _parseSingle(s, px, G_COMPONENT);
-}
-function parseSequence(s, px) {
-  return _parseSingle(s, px, G_SEQUENCE);
-}
-function parseField(s, px) {
-  return _parseSingle(s, px, G_FIELD);
-}
-function parseProvide(s, px) {
-  return _parseSingle(s, px, G_PROVIDE);
-}
-function parseMacroAttr(s, px) {
-  return _parseSingle(s, px, G_ALL);
-}
-function parseReceiveHandler(s, px) {
-  return _parseHandler(s, px, "receive", true, true, false);
-}
-function parseAlterHandler(s, px) {
-  const r = _parseHandler(s, px, "alter", false, false, true);
-  return r === null ? null : r.handlerVal;
-}
-function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
-  const tokens = tokenizeValue(s.trim());
-  const headTok = tokens[0] ?? "";
-  const head = headTok === "" ? null : parseToken(headTok, px);
-  const hk = kindOf(head);
-  let handlerVal;
-  if (hk & K_METHOD && allowMethod) handlerVal = head;
-  else if (hk & K_METHOD) {
-    if (report)
-      px.onParseIssue("event-method-handler", {
-        name: head.name,
-        role: "handler-name",
-        value: headTok
-      });
-    return null;
-  } else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
-  else {
-    if (report) px.onParseIssue("bad-value", { role: "handler-name", value: headTok });
-    return null;
-  }
-  if (!allowArgs) return tokens.length === 1 ? { handlerVal, args: [] } : null;
-  const args = new Array(tokens.length - 1);
-  for (let i = 1; i < tokens.length; i++) {
-    const val = parseToken(tokens[i], px);
-    if (val !== null && kindOf(val) & G_VALUE) args[i - 1] = val;
-    else {
-      if (report) px.onParseIssue("bad-value", { role: "handler-arg", value: tokens[i] });
-      args[i - 1] = NULL_CONST_VAL;
-    }
-  }
-  return { handlerVal, args };
-}
-function _parsePredicate(s, tokens, px) {
-  const predName = tokens[0];
-  const pred = PREDICATES[predName];
-  if (pred === void 0) {
-    px.onParseIssue("bad-value", { role: "predicate", value: predName });
-    return null;
-  }
-  const arity = tokens.length - 1;
-  if (arity !== pred.arity) {
-    px.onParseIssue("bad-value", { role: "predicate-arity", value: s, predicate: predName });
-    return null;
-  }
-  const args = new Array(arity);
-  for (let i = 0; i < arity; i++) {
-    const tok = tokens[i + 1];
-    const val = parseToken(tok, px);
-    if (val === null || !(kindOf(val) & G_BOOL)) {
-      px.onParseIssue("bad-value", { role: "predicate-arg", value: tok });
-      return null;
-    }
-    args[i] = val;
-  }
-  return new PredicateVal(pred, args);
-}
-function kindOf(val) {
-  if (val === null) return 0;
-  if (val instanceof ConstVal) return val.kind;
-  if (val instanceof StrTplVal) return val.kind;
-  if (val instanceof SeqAccessVal) return K_SEQ;
-  if (val instanceof FieldVal) return K_FIELD;
-  if (val instanceof MethodVal) return K_METHOD;
-  if (val instanceof BindVal) return K_BIND;
-  if (val instanceof DynVal) return K_DYN;
-  if (val instanceof TypeVal) return K_TYPE;
-  if (val instanceof NameVal) return K_NAME;
-  return 0;
-}
-var BaseVal = class {
-  render(_stack, _rx) {
-  }
-  eval(_stack) {
-  }
-  toPathItem() {
-    return null;
-  }
-  // Value of this expression when it sits in handler position (`@on.<event>`,
-  // `@when`, `@enrich-with`, `@loop-with`): the dispatch machinery calls the
-  // result with the event args. Defaults to `eval`; `MethodVal` overrides it
-  // to hand back the raw function instead of invoking it.
-  evalAsHandler(stack) {
-    return this.eval(stack);
-  }
-};
-var ConstVal = class extends BaseVal {
-  constructor(val, kind = K_CONST) {
-    super();
-    this.val = val;
-    this.kind = kind;
-  }
-  render(_stack, _rx) {
-    return this.val;
-  }
-  eval(_stack) {
-    return this.val;
-  }
-  toString() {
-    const v = this.val;
-    return typeof v === "string" ? `'${v.replace(/(['\\])/g, "\\$1")}'` : `${v}`;
-  }
-};
-var NULL_CONST_VAL = new ConstVal(null);
-var PredicateVal = class extends BaseVal {
-  constructor(pred, args) {
-    super();
-    this.pred = pred;
-    this.args = args;
-  }
-  eval(stack) {
-    const n = this.args.length;
-    const vals = new Array(n);
-    for (let i = 0; i < n; i++) vals[i] = this.args[i].eval(stack);
-    return this.pred.fn(...vals);
-  }
-  toString() {
-    return `${this.pred.name} ${this.args.map(String).join(" ")}`;
-  }
-};
-var VarVal = class extends BaseVal {
-};
-var StrTplVal = class _StrTplVal extends VarVal {
-  constructor(vals) {
-    super();
-    this.vals = vals;
-    this.kind = this.isLiteral() ? K_CONST : K_STRTPL;
-  }
-  // True when this template carries no dynamic placeholder: every part is a
-  // plain `ConstVal` and none was bound from a macro variable (the macro
-  // placeholder is real in the body even when it resolved to a constant).
-  isLiteral() {
-    for (const v of this.vals) if (!(v instanceof ConstVal) || v.fromMacroVar) return false;
-    return true;
-  }
-  render(stack, _rx) {
-    return this.eval(stack);
-  }
-  eval(stack) {
-    const strs = new Array(this.vals.length);
-    for (let i = 0; i < this.vals.length; i++) strs[i] = this.vals[i]?.eval(stack, "");
-    return strs.join("");
-  }
-  // When this is a placeholderless literal (see `isLiteral`), returns the
-  // string it spells out, in `'…'` source form; otherwise null. The linter
-  // uses this to nudge `$'foo'` → `'foo'` (PLACEHOLDERLESS_TEMPLATE_STRING).
-  toLiteralSource() {
-    if (!this.isLiteral()) return null;
-    let out = "";
-    for (const v of this.vals) out += v.val;
-    return new ConstVal(out).toString();
-  }
-  // `s` is the interior of a `$'…'` template (the text between `$'` and `'`).
-  // The interior is unescaped once (`\'`, `\\`) then split on `{…}` groups:
-  // text between them becomes a `ConstVal`, expressions inside braces are
-  // parsed via `parseText`. A constant-only template is left as a `StrTplVal`
-  // (not folded to a `ConstVal`) so the linter can flag it — see
-  // `toLiteralSource` and the PLACEHOLDERLESS_TEMPLATE_STRING lint rule.
-  static parse(s, px) {
-    const parts = unescapeStr(s).split(STR_TPL_SPLIT_RE);
-    const vals = new Array(parts.length);
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      const isExpr = part[0] === "{" && part.at(-1) === "}";
-      vals[i] = isExpr ? parseText(part.slice(1, -1), px) : new ConstVal(part);
-    }
-    let lo = 0;
-    let hi = vals.length;
-    const isTrimmable = (v) => v instanceof ConstVal && v.val === "" && !v.fromMacroVar;
-    while (lo < hi && isTrimmable(vals[lo])) lo++;
-    while (hi > lo && isTrimmable(vals[hi - 1])) hi--;
-    return new _StrTplVal(lo === 0 && hi === vals.length ? vals : vals.slice(lo, hi));
-  }
-};
-var NameVal = class extends VarVal {
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-  eval(stack) {
-    return stack.lookupName(this.name);
-  }
-  toString() {
-    return this.name;
-  }
-};
-var HandlerNameVal = class extends NameVal {
-  constructor(name, namespace) {
-    super(name);
-    this.namespace = namespace;
-  }
-  eval(stack) {
-    return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(this.namespace, this.name);
-  }
-};
-var mk404Handler = (type, name) => function(...args) {
-  console.warn("handler not found", { type, name, args }, this);
-  return this;
-};
-var TypeVal = class extends NameVal {
-  eval(stack) {
-    return stack.lookupType(this.name);
-  }
-};
-var RenderVal = class extends BaseVal {
-  render(stack, _rx) {
-    return this.eval(stack);
-  }
-};
-var RenderNameVal = class extends RenderVal {
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-};
-var BindVal = class extends RenderNameVal {
-  eval(stack) {
-    return stack.lookupBind(this.name);
-  }
-  toString() {
-    return `@${this.name}`;
-  }
-};
-var BindMemberVal = class extends BindVal {
-  constructor(name, member) {
-    super(name);
-    this.member = member;
-  }
-  eval(stack) {
-    const v = stack.lookupBind(this.name);
-    return seqGet(v, this.member, null);
-  }
-  toString() {
-    return `@${this.name}.${this.member}`;
-  }
-};
-var DynVal = class extends RenderNameVal {
-  eval(stack) {
-    return stack.lookupDynamic(this.name);
-  }
-  toString() {
-    return `*${this.name}`;
-  }
-};
-var FieldVal = class extends RenderNameVal {
-  eval(stack) {
-    return stack.lookupFieldRaw(this.name);
-  }
-  toPathItem() {
-    return new FieldStep(this.name);
-  }
-  toString() {
-    return `.${this.name}`;
-  }
-};
-var MethodVal = class extends RenderNameVal {
-  eval(stack) {
-    return stack.lookupMethod(this.name);
-  }
-  evalAsHandler(stack) {
-    return stack.lookupFieldRaw(this.name);
-  }
-  toString() {
-    return `$${this.name}`;
-  }
-};
-var SeqAccessVal = class extends RenderVal {
-  constructor(seqVal, keyVal) {
-    super();
-    this.seqVal = seqVal;
-    this.keyVal = keyVal;
-  }
-  toPathItem() {
-    return new SeqAccessStep(this.seqVal.name, this.keyVal.name);
-  }
-  eval(stack) {
-    const key = this.keyVal.eval(stack);
-    return seqGet(this.seqVal.eval(stack), key, null);
-  }
-  toString() {
-    return `${this.seqVal}[${this.keyVal}]`;
-  }
-};
-
-// src/attribute.js
-var Attributes = class {
-  constructor(items) {
-    this.items = items;
-  }
-  eval(_stack) {
-    return {};
-  }
-  static parse(attributes, px, parseAll = false) {
-    return getAttrParser(px).parse(attributes, parseAll);
-  }
-  isConstant() {
-    return false;
-  }
-};
-var booleanAttrsRaw = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected";
-var booleanAttrs = new Set(booleanAttrsRaw.split(","));
-var AttrParser = class {
-  constructor(px) {
-    this.clear(px);
-  }
-  clear(px) {
-    this.px = px;
-    this.attrs = null;
-    this.hasDynamic = false;
-    this.wrapperAttrs = null;
-    this.textChild = null;
-    this.eachAttr = null;
-    this.ifAttr = null;
-    this.events = null;
-  }
-  parseAttr(name, value, parseAll = false) {
-    const val = parseAll ? parseMacroAttr(value, this.px) : parseText(value, this.px);
-    if (val !== null) {
-      this.attrs ??= [];
-      this.attrs.push(new Attr(name, val));
-      this.hasDynamic ||= !(val instanceof ConstVal);
-    } else this.px.onParseIssue("bad-value", { role: "attr", attr: name, value });
-  }
-  pushWrapper(name, raw, val) {
-    const node = { name, val, raw };
-    this.wrapperAttrs ??= [];
-    this.wrapperAttrs.push(node);
-    return node;
-  }
-  parseIf(directiveName, value) {
-    const dynVal = parseBool(value, this.px);
-    if (dynVal) {
-      this.ifAttr = new IfAttr(directiveName.slice(3), dynVal);
-      this.attrs ??= [];
-      this.attrs.push(this.ifAttr);
-      this.hasDynamic = true;
-    } else {
-      const info = { role: "if", attr: directiveName.slice(3), value };
-      this.px.onParseIssue("bad-value", info);
-    }
-  }
-  parseThen(s) {
-    if (this.ifAttr) this.ifAttr.thenVal = parseText(s, this.px) ?? NOT_SET_VAL;
-  }
-  parseElse(value) {
-    if (this.ifAttr) this.ifAttr.elseVal = parseText(value, this.px) ?? NOT_SET_VAL;
-  }
-  parseEvent(directiveName, value) {
-    const [eventName, ...modifiers] = directiveName.slice(3).split("+");
-    const handler = EventHandler.parse(value, this.px);
-    if (handler) {
-      if (this.events === null) {
-        this.events = this.px.registerEvents();
-        this.attrs ??= [];
-        this.attrs.push(new ConstAttr("data-eid", new ConstVal(this.events.id)));
-      }
-      this.events.add(eventName, handler, modifiers);
-    }
-  }
-  _parseDirectiveValue(directiveName, s, parserFn) {
-    const val = parserFn(s, this.px);
-    if (val === null) {
-      const info = { role: "directive", directive: directiveName, value: s };
-      this.px.onParseIssue("bad-value", info);
-    }
-    return val;
-  }
-  parseDirective(s, directiveName) {
-    switch (directiveName) {
-      case "dangerouslysetinnerhtml":
-        this.attrs ??= [];
-        this.attrs.push(new RawHtmlAttr(this._parseDirectiveValue(directiveName, s, parseText)));
-        this.hasDynamic = true;
-        return;
-      case "push-view":
-        this.pushWrapper("push-view", s, this._parseDirectiveValue(directiveName, s, parseText));
-        return;
-      case "text":
-        this.textChild = this._parseDirectiveValue(directiveName, s, parseText);
-        return;
-      case "show":
-        this.pushWrapper("show", s, this._parseDirectiveValue(directiveName, s, parseBool));
-        return;
-      case "hide":
-        this.pushWrapper("hide", s, this._parseDirectiveValue(directiveName, s, parseBool));
-        return;
-      case "each": {
-        const val = this._parseDirectiveValue(directiveName, s, parseSequence);
-        this.eachAttr = this.pushWrapper("each", s, val);
-        return;
-      }
-      case "enrich-with":
-        if (this.eachAttr !== null)
-          this.eachAttr.enrichWithVal = this._parseDirectiveValue(
-            directiveName,
-            s,
-            parseAlterHandler
-          );
-        else
-          this.pushWrapper(
-            "scope",
-            s,
-            this._parseDirectiveValue(directiveName, s, parseAlterHandler)
-          );
-        return;
-      case "when":
-        this._parseWhen(s);
-        return;
-      case "loop-with":
-        this._parseLoopWith(s);
-        return;
-      case "then":
-        this.parseThen(s);
-        return;
-      case "else":
-        this.parseElse(s);
-        return;
-    }
-    if (directiveName.startsWith("on.")) this.parseEvent(directiveName, s);
-    else if (directiveName.startsWith("if.")) this.parseIf(directiveName, s);
-    else if (directiveName.startsWith("then.")) this.parseThen(s);
-    else if (directiveName.startsWith("else.")) this.parseElse(s);
-    else {
-      const info = { name: directiveName, value: s };
-      this.px.onParseIssue("unknown-directive", info);
-    }
-  }
-  _parseWhen(s) {
-    if (this.eachAttr !== null)
-      this.eachAttr.whenVal = this._parseDirectiveValue("when", s, parseAlterHandler);
-  }
-  _parseLoopWith(s) {
-    if (this.eachAttr !== null)
-      this.eachAttr.loopWithVal = this._parseDirectiveValue("loop-with", s, parseAlterHandler);
-  }
-  parse(attributes, parseAll = false) {
-    for (const { name, value } of attributes) {
-      const charCode = name.charCodeAt(0);
-      if (charCode === 58)
-        this.parseAttr(name === ":viewbox" ? "viewBox" : name.slice(1), value, parseAll);
-      else if (charCode === 64) this.parseDirective(value, name.slice(1));
-      else {
-        this.attrs ??= [];
-        const constVal = value === "" && booleanAttrs.has(name) ? true : value;
-        this.attrs.push(new ConstAttr(name, new ConstVal(constVal)));
-      }
-    }
-    const { attrs, hasDynamic } = this;
-    const pAttrs = hasDynamic ? new DynAttrs(attrs) : ConstAttrs.fromAttrs(attrs ?? []);
-    return [pAttrs, this.wrapperAttrs, this.textChild];
-  }
-};
-var ConstAttrs = class _ConstAttrs extends Attributes {
-  eval(_stack) {
-    return this.items;
-  }
-  static fromAttrs(attrs) {
-    const attrsObj = {};
-    for (const attr of attrs) attrsObj[attr.name] = attr.val.eval(null);
-    return new _ConstAttrs(attrsObj);
-  }
-  setDataAttr(key, val) {
-    this.items[key] = val;
-  }
-  toMacroVars() {
-    const r = {};
-    for (const name in this.items) r[name] = new ConstVal(`${this.items[name]}`).toString();
-    return r;
-  }
-  isConstant() {
-    return true;
-  }
-};
-var DynAttrs = class extends Attributes {
-  eval(stack) {
-    const attrs = {};
-    for (let i = 0; i < this.items.length; i++) {
-      const attr = this.items[i];
-      attrs[attr.name] = attr.eval(stack);
-    }
-    return attrs;
-  }
-  setDataAttr(key, val) {
-    this.items.push(new ConstAttr(key, new ConstVal(val)));
-  }
-  toMacroVars() {
-    const r = {};
-    for (const attr of this.items) r[attr.name] = attr.val.toString();
-    return r;
-  }
-};
-var BaseAttr = class {
-  constructor(name) {
-    this.name = name;
-  }
-};
-var Attr = class extends BaseAttr {
-  constructor(name, val) {
-    super(name);
-    this.val = val;
-  }
-  eval(stack) {
-    return this.val.eval(stack);
-  }
-};
-var ConstAttr = class extends Attr {
-};
-var RawHtmlAttr = class extends Attr {
-  constructor(val) {
-    super("dangerouslySetInnerHTML", val ?? NULL_CONST_VAL);
-  }
-  eval(stack) {
-    return { __html: `${this.val.eval(stack)}` };
-  }
-};
-var NOT_SET_VAL = NULL_CONST_VAL;
-var IfAttr = class extends BaseAttr {
-  constructor(name, condVal) {
-    super(name);
-    this.condVal = condVal;
-    this.thenVal = this.elseVal = NOT_SET_VAL;
-  }
-  get anyBranchIsSet() {
-    return this.thenVal !== NOT_SET_VAL || this.elseVal !== NOT_SET_VAL;
-  }
-  eval(stack) {
-    return this.condVal.eval(stack) ? this.thenVal.eval(stack) : this.elseVal.eval(stack);
-  }
-};
-var _attrParser = null;
-function getAttrParser(px) {
-  _attrParser ??= new AttrParser(px);
-  _attrParser.clear(px);
-  return _attrParser;
-}
-var EventHandler = class _EventHandler {
-  constructor(handlerVal, args = []) {
-    this.handlerVal = handlerVal;
-    this.args = args;
-  }
-  getHandlerAndArgs(stack, _event) {
-    const argValues = new Array(this.args.length);
-    for (let i = 0; i < argValues.length; i++) argValues[i] = this.args[i].eval(stack);
-    return [this.handlerVal.evalAsHandler(stack), argValues];
-  }
-  static parse(s, px) {
-    const r = parseReceiveHandler(s, px);
-    return r === null ? null : new _EventHandler(r.handlerVal, r.args);
-  }
-};
-var IntentHandler = class {
-  constructor(name, fn) {
-    this.name = name;
-    this.fn = fn;
-  }
-};
-
-// src/cache.js
-var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
-var NullDomCache = class {
-  get(_keys, _cacheKey) {
-  }
-  set(_keys, _cacheKey, _v) {
-  }
-  evict() {
-    return { hit: 0, miss: 0, badKey: 0 };
-  }
-};
-var WeakMapDomCache = class {
-  constructor() {
-    this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = /* @__PURE__ */ new Map();
-  }
-  _returnValue(r) {
-    if (r === void 0) this.miss += 1;
-    else this.hit += 1;
-    return r;
-  }
-  get(keys, cacheKey) {
-    const len = keys.length;
-    let cur = this.keysByLen.get(len);
-    if (!cur) return this._returnValue(void 0);
-    for (let i = 0; i < len - 1; i++) {
-      cur = cur.get(keys[i]);
-      if (!cur) return this._returnValue(void 0);
-    }
-    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
-  }
-  set(keys, cacheKey, v) {
-    const len = keys.length;
-    let cur = this.keysByLen.get(len);
-    if (!cur) {
-      cur = /* @__PURE__ */ new WeakMap();
-      this.keysByLen.set(len, cur);
-    }
-    for (let i = 0; i < len - 1; i++) {
-      const key = keys[i];
-      let next = cur.get(key);
-      if (!next) {
-        if (!isWeakKey(key)) {
-          this.badKey += 1;
-          return;
-        }
-        next = /* @__PURE__ */ new WeakMap();
-        cur.set(key, next);
-      }
-      cur = next;
-    }
-    const lastKey = keys[len - 1];
-    const leaf = cur.get(lastKey);
-    if (leaf) leaf[cacheKey] = v;
-    else if (isWeakKey(lastKey)) cur.set(lastKey, { [cacheKey]: v });
-    else this.badKey += 1;
-  }
-  evict() {
-    const { hit, miss, badKey } = this;
-    this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = /* @__PURE__ */ new Map();
-    return { hit, miss, badKey };
-  }
-};
-
-// src/vdom.js
-var HTML_NS = "http://www.w3.org/1999/xhtml";
-var SVG_NS = "http://www.w3.org/2000/svg";
-var MATH_NS = "http://www.w3.org/1998/Math/MathML";
-var isNamespaced = (node) => {
-  const ns = node.namespaceURI;
-  return ns !== null && ns !== HTML_NS;
-};
-var isForeignObject = (tag) => tag.length === 13 && tag.toLowerCase() === "foreignobject";
-var effectiveNs = (vnode, opts) => vnode.namespace ?? opts.namespace ?? null;
-function childOpts(vnode, ns, opts) {
-  const target = ns === SVG_NS && isForeignObject(vnode.tag) ? null : ns;
-  return target === (opts.namespace ?? null) ? opts : { ...opts, namespace: target };
-}
-var NEVER_ASSIGN = /* @__PURE__ */ new Set([
-  "width",
-  "height",
-  "href",
-  "list",
-  "form",
-  "tabIndex",
-  "download",
-  "rowSpan",
-  "colSpan",
-  "role",
-  "popover"
-]);
-var PROP_ATTR_NAME = { className: "class", htmlFor: "for" };
-function applyProperties(node, props) {
-  const namespaced = isNamespaced(node);
-  for (const name in props) setProp(node, name, props[name], namespaced);
-}
-function setProp(node, name, value, namespaced) {
-  if (name === "dangerouslySetInnerHTML") {
-    if (value === void 0) node.replaceChildren();
-    else {
-      const html2 = value.__html ?? "";
-      if (html2 !== node.innerHTML) node.innerHTML = html2;
-    }
-    return;
-  }
-  if (typeof value === "function") return;
-  const usesProp = !namespaced && !NEVER_ASSIGN.has(name) && name in node;
-  if (usesProp && value != null) {
-    try {
-      node[name] = value;
-      return;
-    } catch {
-    }
-  }
-  if (value == null || value === false && name[4] !== "-") {
-    if (usesProp) {
-      try {
-        node[name] = "";
-      } catch {
-      }
-      node.removeAttribute(PROP_ATTR_NAME[name] ?? name);
-    } else node.removeAttribute(name);
-  } else node.setAttribute(name, value);
-}
-function applyValueLast(node, value) {
-  if (node.tagName === "PROGRESS" && (value == null || value === 0)) {
-    node.removeAttribute("value");
-  } else {
-    setProp(node, "value", value, isNamespaced(node));
-  }
-}
-var VBase = class {
-};
-var getKey = (child) => child instanceof VNode ? child.key : void 0;
-var isIterable = (obj) => obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function";
-function childsEqual(a, b) {
-  if (a === b) return true;
-  for (let i = 0; i < a.length; i++) if (!a[i].isEqualTo(b[i])) return false;
-  return true;
-}
-function appendChildNodes(parent, childs, opts) {
-  for (const child of childs) parent.appendChild(child.toDom(opts));
-}
-function addChild(normalizedChildren, child) {
-  if (child == null) return;
-  if (isIterable(child)) {
-    for (const c of child) addChild(normalizedChildren, c);
-  } else if (child instanceof VBase) {
-    if (child instanceof VFragment) normalizedChildren.push(...child.childs);
-    else normalizedChildren.push(child);
-  } else normalizedChildren.push(new VText(child));
-}
-var VText = class _VText extends VBase {
-  constructor(text) {
-    super();
-    this.text = String(text);
-  }
-  get nodeType() {
-    return 3;
-  }
-  isEqualTo(other) {
-    return other instanceof _VText && this.text === other.text;
-  }
-  toDom(opts) {
-    return opts.document.createTextNode(this.text);
-  }
-};
-var VComment = class _VComment extends VBase {
-  constructor(text) {
-    super();
-    this.text = text;
-  }
-  get nodeType() {
-    return 8;
-  }
-  isEqualTo(other) {
-    return other instanceof _VComment && this.text === other.text;
-  }
-  toDom(opts) {
-    return opts.document.createComment(this.text);
-  }
-};
-var VFragment = class _VFragment extends VBase {
-  constructor(childs) {
-    super();
-    this.childs = [];
-    addChild(this.childs, childs);
-  }
-  get nodeType() {
-    return 11;
-  }
-  isEqualTo(other) {
-    if (!(other instanceof _VFragment) || this.childs.length !== other.childs.length) return false;
-    return childsEqual(this.childs, other.childs);
-  }
-  toDom(opts) {
-    const fragment = opts.document.createDocumentFragment();
-    appendChildNodes(fragment, this.childs, opts);
-    return fragment;
-  }
-};
-var VNode = class _VNode extends VBase {
-  constructor(tag, attrs, childs, key, namespace) {
-    super();
-    this.tag = tag;
-    this.attrs = attrs ?? {};
-    this.childs = childs ?? [];
-    this.key = key != null ? String(key) : void 0;
-    this.namespace = typeof namespace === "string" ? namespace : null;
-  }
-  get nodeType() {
-    return 1;
-  }
-  isSameKind(other) {
-    return this.tag === other.tag && this.namespace === other.namespace && this.key === other.key;
-  }
-  isEqualTo(other) {
-    if (this === other) return true;
-    if (!(other instanceof _VNode) || !this.isSameKind(other) || this.childs.length !== other.childs.length) {
-      return false;
-    }
-    if (this.attrs !== other.attrs) {
-      for (const key in this.attrs) if (this.attrs[key] !== other.attrs[key]) return false;
-      for (const key in other.attrs) if (!Object.hasOwn(this.attrs, key)) return false;
-    }
-    return childsEqual(this.childs, other.childs);
-  }
-  toDom(opts) {
-    const doc = opts.document;
-    const ns = effectiveNs(this, opts);
-    const tag = ns !== null && this.tag === this.tag.toUpperCase() ? this.tag.toLowerCase() : this.tag;
-    const attrs = this.attrs;
-    const createOpts = attrs.is != null ? { is: attrs.is } : void 0;
-    const node = ns === null ? doc.createElement(tag, createOpts) : doc.createElementNS(ns, tag, createOpts);
-    const cOpts = childOpts(this, ns, opts);
-    if ("value" in attrs || "checked" in attrs) {
-      const { value, checked, ...rest } = attrs;
-      applyProperties(node, rest);
-      appendChildNodes(node, this.childs, cOpts);
-      if (value !== void 0) applyValueLast(node, value);
-      if (checked !== void 0) setProp(node, "checked", checked, false);
-    } else {
-      applyProperties(node, attrs);
-      appendChildNodes(node, this.childs, cOpts);
-    }
-    return node;
-  }
-};
-function diffProps(a, b) {
-  if (a === b) return null;
-  let diff = null;
-  for (const aKey in a) {
-    if (!Object.hasOwn(b, aKey)) {
-      diff ??= {};
-      diff[aKey] = void 0;
-    } else if (a[aKey] !== b[aKey]) {
-      diff ??= {};
-      diff[aKey] = b[aKey];
-    }
-  }
-  for (const bKey in b) {
-    if (!Object.hasOwn(a, bKey)) {
-      diff ??= {};
-      diff[bKey] = b[bKey];
-    }
-  }
-  return diff;
-}
-function morphNode(domNode, source, target, opts) {
-  if (source === target || source.isEqualTo(target)) return domNode;
-  const type = source.nodeType;
-  if (type === target.nodeType) {
-    if (type === 3 || type === 8) {
-      domNode.data = target.text;
-      return domNode;
-    }
-    if (type === 1 && source.isSameKind(target)) {
-      const propsDiff = diffProps(source.attrs, target.attrs);
-      const hasValue = propsDiff != null && "value" in propsDiff;
-      const hasChecked = propsDiff != null && "checked" in propsDiff;
-      if (propsDiff) {
-        if (hasValue || hasChecked) {
-          const { value: _v, checked: _c, ...rest } = propsDiff;
-          applyProperties(domNode, rest);
-        } else applyProperties(domNode, propsDiff);
-      }
-      if (!target.attrs.dangerouslySetInnerHTML) {
-        const ns = effectiveNs(target, opts);
-        morphChildren(domNode, source.childs, target.childs, childOpts(target, ns, opts));
-      }
-      if (hasValue) applyValueLast(domNode, propsDiff.value);
-      else if (source.tag === "SELECT" && target.attrs.value !== void 0)
-        applyValueLast(domNode, target.attrs.value);
-      if (hasChecked) setProp(domNode, "checked", propsDiff.checked, false);
-      return domNode;
-    }
-    if (type === 11) {
-      morphChildren(domNode, source.childs, target.childs, opts);
-      return domNode;
-    }
-  }
-  const newNode = target.toDom(opts);
-  domNode.parentNode?.replaceChild(newNode, domNode);
-  return newNode;
-}
-function morphChildren(parentDom, oldChilds, newChilds, opts) {
-  if (oldChilds.length === 0) {
-    appendChildNodes(parentDom, newChilds, opts);
-    return;
-  }
-  if (newChilds.length === 0) {
-    parentDom.replaceChildren();
-    return;
-  }
-  if (oldChilds.length === newChilds.length) {
-    let hasKey = false;
-    for (let i = 0; i < oldChilds.length; i++) {
-      if (getKey(oldChilds[i]) != null || getKey(newChilds[i]) != null) {
-        hasKey = true;
-        break;
-      }
-    }
-    if (!hasKey) {
-      let dom = parentDom.firstChild;
-      for (let i = 0; i < oldChilds.length; i++) {
-        const next = dom.nextSibling;
-        morphNode(dom, oldChilds[i], newChilds[i], opts);
-        dom = next;
-      }
-      return;
-    }
-  }
-  const domNodes = Array.from(parentDom.childNodes);
-  const oldKeyMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0; i < oldChilds.length; i++) {
-    const key = getKey(oldChilds[i]);
-    if (key != null) oldKeyMap[key] = i;
-  }
-  const used = new Uint8Array(oldChilds.length);
-  let unkeyedCursor = 0;
-  for (let j = 0; j < newChilds.length; j++) {
-    const newChild = newChilds[j];
-    const newKey = getKey(newChild);
-    let oldIdx = -1;
-    if (newKey != null) {
-      if (newKey in oldKeyMap && !used[oldKeyMap[newKey]]) oldIdx = oldKeyMap[newKey];
-    } else {
-      while (unkeyedCursor < oldChilds.length) {
-        if (!used[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
-          oldIdx = unkeyedCursor++;
-          break;
-        }
-        unkeyedCursor++;
-      }
-    }
-    if (oldIdx >= 0) {
-      used[oldIdx] = 1;
-      const newDom = morphNode(domNodes[oldIdx], oldChilds[oldIdx], newChild, opts);
-      const ref = parentDom.childNodes[j] ?? null;
-      if (newDom !== ref) parentDom.insertBefore(newDom, ref);
-    } else {
-      const ref = parentDom.childNodes[j] ?? null;
-      parentDom.insertBefore(newChild.toDom(opts), ref);
-    }
-  }
-  for (let i = oldChilds.length - 1; i >= 0; i--)
-    if (!used[i] && domNodes[i].parentNode === parentDom) parentDom.removeChild(domNodes[i]);
-}
-function render(vnode, container, options, prev) {
-  const isFragment = vnode instanceof VFragment;
-  if (prev && prev.vnode instanceof VFragment === isFragment) {
-    const oldDom = isFragment ? container : prev.dom;
-    const newDom = morphNode(oldDom, prev.vnode, vnode, options);
-    return { vnode, dom: isFragment ? container : newDom };
-  }
-  const domNode = vnode.toDom(options);
-  container.replaceChildren(domNode);
-  return { vnode, dom: isFragment ? container : domNode };
-}
-function h(tagName, properties, children, namespace) {
-  const props = {};
-  let key;
-  if (properties) {
-    for (const propName in properties) {
-      const propVal = properties[propName];
-      if (propName === "key") key = propVal;
-      else if (propName === "namespace") namespace = namespace ?? propVal;
-      else props[propName] = propVal;
-    }
-  }
-  if (namespace == null) {
-    const lower = tagName.toLowerCase();
-    if (lower === "svg") {
-      namespace = SVG_NS;
-      tagName = "svg";
-    } else if (lower === "math") {
-      namespace = MATH_NS;
-      tagName = "math";
-    }
-  }
-  const c = tagName.charCodeAt(0);
-  const tag = namespace == null && c >= 97 && c <= 122 && tagName === tagName.toLowerCase() ? tagName.toUpperCase() : tagName;
-  const normalizedChildren = [];
-  addChild(normalizedChildren, children);
-  return new VNode(tag, props, normalizedChildren, key, namespace);
-}
-
-// src/renderer.js
-var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-var Renderer = class {
-  constructor(comps) {
-    this.comps = comps;
-    this.cache = new WeakMapDomCache();
-    this.renderTag = h;
-  }
-  renderFragment(childs) {
-    return new VFragment(childs);
-  }
-  renderComment(text) {
-    return new VComment(text);
-  }
-  setNullCache() {
-    this.cache = new NullDomCache();
-  }
-  renderToDOM(stack, val) {
-    const rootNode = document.createElement("div");
-    const rOpts = { document };
-    render(h("DIV", null, [this.renderRoot(stack, val)]), rootNode, rOpts);
-    return rootNode.childNodes[0];
-  }
-  renderToString(stack, val, cleanAttrs = true) {
-    const dom = this.renderToDOM(stack, val);
-    if (cleanAttrs) {
-      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
-      for (const { dataset } of nodes) for (const name of DATASET_ATTRS) delete dataset[name];
-    }
-    return dom.innerHTML;
-  }
-  renderRoot(stack, val, viewName = null) {
-    const comp = this.comps.getCompFor(val);
-    if (comp === null) return null;
-    return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
-  }
-  renderIt(stack, node, key, viewName) {
-    const comp = this.comps.getCompFor(stack.it);
-    return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : null;
-  }
-  // `node` is the parse node of the render site (`<x render>` / `render-it` /
-  // `render-each`, or the view's root anode for the app root). It keys the
-  // cache as a globally-unique object: node ids alone are unique only within a
-  // single view, so the same value rendered by two components (e.g. through a
-  // shared dynamic-var sequence) would otherwise collide in the cache.
-  _rValComp(stack, val, comp, node, key, viewName) {
-    const cacheKey = `${viewName ?? ""}${stack.viewsId ?? ""}${key}`;
-    const cachePath = [node, val];
-    stack._pushDynBindValuesToArray(cachePath, comp);
-    const cachedNode = this.cache.get(cachePath, cacheKey);
-    if (cachedNode) return cachedNode;
-    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
-    const body = this.renderView(view, stack);
-    if (body == null) return null;
-    const meta = this._renderMetadata({
-      $: "Comp",
-      nid: node?.nodeId ?? null,
-      cid: comp.id,
-      vid: view.name
-    });
-    const dom = new VFragment([meta, body]);
-    this.cache.set(cachePath, cacheKey, dom);
-    return dom;
-  }
-  pushEachEntry(r, nid, attrName, key, dom) {
-    r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
-  }
-  renderEachWhen(stack, iterInfo, view, nid) {
-    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
-    const r = [];
-    const it = stack.it;
-    const { iterData, start, end, keys } = unpackLoopResult(
-      loopWith.call(it, seq, makeLoopCtx(stack, filter)),
-      seq
-    );
-    const renderOne = (key, value, attrName) => {
-      const cachePath = enricher ? [view, it, value] : [view, value];
-      const binds = { key, value };
-      const cacheKey = `${stack.viewsId ?? ""}${nid}${key}`;
-      if (enricher) callEnricher(enricher, it, binds, key, value, iterData);
-      const cachedNode = this.cache.get(cachePath, cacheKey);
-      if (cachedNode) this.pushEachEntry(r, nid, attrName, key, cachedNode);
-      else {
-        const dom = this.renderView(view, stack.enter(value, binds, false));
-        if (dom != null) this.pushEachEntry(r, nid, attrName, key, dom);
-        this.cache.set(cachePath, cacheKey, dom);
-      }
-    };
-    if (keys) keysIter(seq, renderOne, keys);
-    else
-      getSeqInfo(seq)(
-        seq,
-        (key, value, attrName) => {
-          if (filter.call(it, key, value, iterData)) renderOne(key, value, attrName);
-        },
-        start,
-        end
-      );
-    return r;
-  }
-  renderView(view, stack) {
-    let n = stack.binds[1];
-    while (n !== null) {
-      const b = n[0];
-      if (b.isFrame) {
-        if (stack.it !== b.it) break;
-        console.error("recursion detected", stack.it, b.it);
-        return new VComment("RECURSION AVOIDED");
-      }
-      n = n[1];
-    }
-    return view.render(stack, this);
-  }
-  _renderMetadata(info) {
-    return new VComment(`§${JSON.stringify(info)}§`);
-  }
-  // Prefix a loop-less @enrich-with subtree with a boundary meta so event-path
-  // reconstruction replays its binds (mirrors the §Each§ / §Comp§ metas).
-  renderScopeMeta(nid, dom) {
-    return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
-  }
-};
-var getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
-var normalizeRange = (start, end, size) => {
-  let s = start == null ? 0 : start < 0 ? size + start : start;
-  let e = end == null ? size : end < 0 ? size + end : end;
-  s = s < 0 ? 0 : s > size ? size : s;
-  e = e < 0 ? 0 : e > size ? size : e;
-  return [s, e < s ? s : e];
-};
-var callEnricher = (enricher, it, binds, key, value, iterData) => {
-  enricher.call(it, binds, key, value, iterData);
-  console.assert(
-    binds.key === key && binds.value === value,
-    "@enrich-with handlers must not overwrite binds.key or binds.value"
-  );
-  binds.key = key;
-  binds.value = value;
-};
-var filterAlwaysTrue = (_v, _k, _seq) => true;
-var nullLoopWith = (seq) => ({ iterData: { seq } });
-var unpackLoopResult = (result, seq) => {
-  const r = result ?? {};
-  return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end, keys: r.keys };
-};
-var keysIter = (seq, visit, keys) => {
-  const attrName = isIndexedSeq(seq) ? "si" : "sk";
-  for (const key of keys) visit(key, seqGet(seq, key), attrName);
-};
-var makeLoopCtx = (stack, filter) => ({
-  lookup: (name) => stack.lookupBind(name),
-  filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
-});
-var nativeIndexedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seqSize(seq));
-  for (let i = s; i < e; i++) visit(i, seq[i], "si");
-};
-var nativeKeyedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seqSize(seq));
-  let i = 0;
-  for (const [k, v] of seqEntries(seq)) {
-    if (i >= e) break;
-    if (i >= s) visit(k, v, "sk");
-    i++;
-  }
-};
-var unkIter = () => {
-};
-var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
-
-// src/util/env.js
-var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
-
-// src/anode.js
-function resolveDynProducer(comp, name) {
-  let producerComp, producerProvide;
-  const lk = comp?.lookup?.[name];
-  if (lk != null) {
-    producerComp = comp.scope?.lookupComponent(lk.compName);
-    producerProvide = producerComp?.provide?.[lk.provideName];
-  } else {
-    const p = comp?.provide?.[name];
-    if (p == null) return null;
-    producerComp = comp;
-    producerProvide = p;
-  }
-  if (producerComp == null || producerProvide == null) return null;
-  const pi = producerProvide.val?.toPathItem?.() ?? null;
-  return { producerCompId: producerComp.id, producerSteps: pi ? [pi] : [] };
-}
-var BaseNode = class {
-  render(_stack, _rx) {
-    return null;
-  }
-  setDataAttr(key, val) {
-    console.warn("setDataAttr not implemented for", this, { key, val });
-  }
-  isConstant() {
-    return false;
-  }
-  isWhiteSpace() {
-    return false;
-  }
-  optimize() {
-  }
-};
-var TextNode = class extends BaseNode {
-  constructor(val) {
-    super();
-    this.val = val;
-  }
-  render(_stack, _rx) {
-    return this.val;
-  }
-  isWhiteSpace() {
-    for (let i = 0; i < this.val.length; i++) {
-      const c = this.val.charCodeAt(i);
-      if (!(c === 32 || c === 10 || c === 9 || c === 13)) return false;
-    }
-    return true;
-  }
-  hasNewLine() {
-    for (let i = 0; i < this.val.length; i++) {
-      const c = this.val.charCodeAt(i);
-      if (c === 10 || c === 13) return true;
-    }
-    return false;
-  }
-  condenseWhiteSpace(replacement = "") {
-    this.val = replacement;
-  }
-  isConstant() {
-    return true;
-  }
-  setDataAttr(_key, _val) {
-  }
-};
-var CommentNode = class extends TextNode {
-  render(_stack, rx) {
-    return rx.renderComment(this.val);
-  }
-};
-function optimizeChilds(childs) {
-  for (let i = 0; i < childs.length; i++) {
-    const child = childs[i];
-    if (child.isConstant()) childs[i] = new RenderOnceNode(child);
-    else child.optimize();
-  }
-}
-function optimizeNode(node) {
-  if (node.isConstant()) return new RenderOnceNode(node);
-  node.optimize();
-  return node;
-}
-var ChildsNode = class extends BaseNode {
-  constructor(childs) {
-    super();
-    this.childs = childs;
-  }
-  isConstant() {
-    return this.childs.every((v) => v.isConstant());
-  }
-  optimize() {
-    optimizeChilds(this.childs);
-  }
-};
-var DomNode = class extends ChildsNode {
-  constructor(tagName, attrs, childs, namespace = null) {
-    super(childs);
-    this.tagName = tagName;
-    this.attrs = attrs;
-    this.namespace = namespace;
-  }
-  render(stack, rx) {
-    const childNodes = new Array(this.childs.length);
-    for (let i = 0; i < childNodes.length; i++)
-      childNodes[i] = this.childs[i]?.render?.(stack, rx) ?? null;
-    return rx.renderTag(this.tagName, this.attrs.eval(stack), childNodes, this.namespace);
-  }
-  setDataAttr(key, val) {
-    this.attrs.setDataAttr(key, val);
-  }
-  isConstant() {
-    return this.attrs.isConstant() && super.isConstant();
-  }
-};
-var FragmentNode = class extends ChildsNode {
-  render(stack, rx) {
-    return rx.renderFragment(this.childs.map((c) => c?.render(stack, rx)));
-  }
-  setDataAttr(key, val) {
-    for (const child of this.childs) child.setDataAttr(key, val);
-  }
-};
-var maybeFragment = (xs) => xs.length === 1 ? xs[0] : new FragmentNode(xs);
-var VALID_NODE_RE = /^[a-zA-Z][a-zA-Z0-9-]*$/;
-var ANode = class _ANode extends BaseNode {
-  constructor(nodeId, val) {
-    super();
-    this.nodeId = nodeId;
-    this.val = val;
-  }
-  toPathStep(ctx) {
-    return ctx.applyKey(this.val?.toPathItem?.() ?? null);
-  }
-  static parse(html2, px) {
-    const nodes = px.parseHTML(html2);
-    if (nodes.length === 0) return new CommentNode("Empty View in ANode.parse");
-    if (nodes.length === 1) return _ANode.fromDOM(nodes[0], px);
-    const childs = [];
-    for (let i = 0; i < nodes.length; i++) {
-      const child = _ANode.fromDOM(nodes[i], px);
-      if (child !== null) childs.push(child);
-    }
-    const trimmed = condenseChildsWhites(childs);
-    if (trimmed.length === 0) return new CommentNode("Empty View in ANode.parse");
-    return maybeFragment(trimmed);
-  }
-  static fromDOM(node, px) {
-    if (node instanceof px.Text) return new TextNode(node.textContent);
-    else if (node instanceof px.Comment) return new CommentNode(node.textContent);
-    const { childNodes, attributes: attrs, tagName: tag } = node;
-    const childs = [];
-    for (let i = 0; i < childNodes.length; i++) {
-      const child = _ANode.fromDOM(childNodes[i], px);
-      if (child !== null) childs.push(child);
-    }
-    const prevTag = px.currentTag;
-    px.currentTag = tag;
-    try {
-      const isPseudoX = attrs[0]?.name === "@x";
-      if (tag === "X" || isPseudoX) return parseXOp(attrs, childs, isPseudoX ? 1 : 0, px);
-      else if (tag.charCodeAt(1) === 58 && (tag.charCodeAt(0) === 88 || tag.charCodeAt(0) === 120)) {
-        const macroName = tag.slice(2).toLowerCase();
-        if (macroName === "slot") {
-          const slotName = attrs.getNamedItem("name")?.value ?? "_";
-          return px.frame.macroSlots[slotName] ?? maybeFragment(childs);
-        }
-        const [nAttrs, wrappers] = Attributes.parse(attrs, px, true);
-        px.onAttributes(nAttrs, wrappers, null, true, tag);
-        return wrap(px.newMacroNode(macroName, nAttrs.toMacroVars(), childs), px, wrappers);
-      } else if (VALID_NODE_RE.test(tag)) {
-        const [nAttrs, wrappers, textChild] = Attributes.parse(attrs, px);
-        px.onAttributes(nAttrs, wrappers, textChild, false, tag);
-        if (textChild) childs.unshift(new RenderTextNode(null, textChild));
-        const domChilds = tag !== "PRE" ? condenseChildsWhites(childs) : childs;
-        const ns = node.namespaceURI;
-        const namespace = ns && ns !== HTML_NS ? ns : null;
-        return wrap(new DomNode(tag, nAttrs, domChilds, namespace), px, wrappers);
-      }
-      return new CommentNode(`Error: InvalidTagName ${tag}`);
-    } finally {
-      px.currentTag = prevTag;
-    }
-  }
-};
-function parseXOp(attrs, childs, opIdx, px) {
-  if (attrs.length <= opIdx) return maybeFragment(childs);
-  const { name, value } = attrs[opIdx];
-  if (X_OPS[name]?.ignoresChildren && hasMeaningfulChilds(childs))
-    px.onParseIssue("x-op-ignores-children", { op: name });
-  const asAttr = attrs.getNamedItem("as")?.value ?? null;
-  const as = asAttr === null ? null : parseViewName(asAttr, px);
-  let node;
-  switch (name) {
-    case "slot":
-      node = new SlotNode(null, new ConstVal(value), maybeFragment(childs));
-      break;
-    case "text":
-      node = px.addNodeIf(RenderTextNode, parseXOpVal(name, value, px, parseText));
-      break;
-    case "render":
-      node = px.addNodeIf(RenderNode, parseXOpVal(name, value, px, parseComponent), as);
-      break;
-    case "render-it":
-      node = px.addNode(RenderItNode, as);
-      break;
-    case "render-each":
-      node = parseRenderEach(px, value, as, attrs);
-      break;
-    case "show": {
-      const val = parseXOpVal(name, value, px, parseBool);
-      node = px.addNodeIf(ShowNode, val, maybeFragment(childs));
-      break;
-    }
-    case "hide": {
-      const val = parseXOpVal(name, value, px, parseBool);
-      node = px.addNodeIf(HideNode, val, maybeFragment(childs));
-      break;
-    }
-    default:
-      px.onParseIssue("unknown-x-op", { name, value });
-      return new CommentNode(`Error: InvalidSpecialTagOp ${name}=${value}`);
-  }
-  return processXExtras(node, attrs, name, opIdx + 1, px);
-}
-function parseXOpVal(opName, value, px, parserFn) {
-  const val = parserFn(value, px);
-  if (val === null) px.onParseIssue("bad-value", { role: "x-op", op: opName, value });
-  return val;
-}
-function parseViewName(s, px) {
-  return parseText(s, px) ?? new ConstVal(s);
-}
-function processXExtras(node, attrs, opName, startIdx, px) {
-  const { consumed, wrappable } = X_OPS[opName];
-  const wrappers = [];
-  for (let i = startIdx; i < attrs.length; i++) {
-    const a = attrs[i];
-    const aName = a.name;
-    if (consumed.has(aName)) continue;
-    const atPrefixed = aName.charCodeAt(0) === 64;
-    const baseName = atPrefixed ? aName.slice(1) : aName;
-    const wrapper = wrappable ? X_OPS[baseName]?.wrapper : null;
-    if (wrapper) {
-      if (!atPrefixed) maybeDeprecateBareXDirective(px, opName, baseName);
-      wrappers.push([wrapper, parseBool(a.value, px)]);
-      continue;
-    }
-    const issueInfo = { op: opName, name: aName, value: a.value };
-    px.onParseIssue("unknown-x-attr", issueInfo);
-  }
-  for (let i = wrappers.length - 1; i >= 0; i--) {
-    const [Cls, val] = wrappers[i];
-    const wrapper = px.addNodeIf(Cls, val, node);
-    if (wrapper !== null) node = wrapper;
-  }
-  return node;
-}
-function maybeDeprecateBareXDirective(px, opName, name) {
-  px.onDeprecatedSyntax("bare-x-directive", { op: opName, name });
-}
-function wrap(node, px, wrappers) {
-  if (wrappers) {
-    for (let i = wrappers.length - 1; i >= 0; i--) {
-      const wrapperNode = makeWrapperNode(wrappers[i], px);
-      if (wrapperNode) {
-        wrapperNode.wrapNode(node);
-        node = wrapperNode;
-      }
-    }
-  }
-  return node;
-}
-function makeWrapperNode(data, px) {
-  const Cls = WRAPPER_NODES[data.name];
-  const node = Cls.register ? px.addNodeIf(Cls, data.val) : data.val && new Cls(null, data.val);
-  if (node !== null && data.name === "each") {
-    node.iterInfo.enrichWithVal = data.enrichWithVal ?? null;
-    node.iterInfo.whenVal = data.whenVal ?? null;
-    node.iterInfo.loopWithVal = data.loopWithVal ?? null;
-  }
-  return node;
-}
-var MacroNode = class extends BaseNode {
-  constructor(name, attrs, slots, px) {
-    super();
-    this.name = name;
-    this.attrs = attrs;
-    this.slots = slots;
-    this.px = px;
-    this.node = null;
-    this.dataAttrs = {};
-  }
-  compile(scope) {
-    const { name, attrs, slots } = this;
-    if (this.px.isInsideMacro(name)) throw new Error(`Recursive macro expansion: ${name}`);
-    const macro2 = scope.lookupMacro(name);
-    if (macro2 === null) this.node = new CommentNode(`bad macro: ${name}`);
-    else {
-      const vars = { ...macro2.defaults, ...attrs };
-      this.node = macro2.expand(this.px.enterMacro(name, vars, slots));
-      for (const key in this.dataAttrs) this.node.setDataAttr(key, this.dataAttrs[key]);
-    }
-  }
-  render(stack, rx) {
-    return this.node.render(stack, rx);
-  }
-  setDataAttr(key, val) {
-    this.dataAttrs[key] = val;
-  }
-  isConstant() {
-    return this.node.isConstant();
-  }
-  optimize() {
-    this.node = optimizeNode(this.node);
-  }
-};
-var Macro = class {
-  constructor(defaults, rawView) {
-    this.defaults = defaults;
-    this.rawView = rawView;
-  }
-  expand(px) {
-    return ANode.parse(this.rawView, px);
-  }
-};
-var RenderViewId = class extends ANode {
-  constructor(nodeId, val, viewVal) {
-    super(nodeId, val);
-    this.viewVal = viewVal;
-  }
-  // The `as=` view selector, evaluated against the host (enclosing) stack like
-  // `@push-view`. Null when `as=` is absent, so the renderer falls through to
-  // `stack.lookupBestView`.
-  evalViewName(stack) {
-    return this.viewVal ? this.viewVal.eval(stack) : null;
-  }
-  // A `<x render*>` produces no DOM element of its own to carry `data-cid`;
-  // when it is a view's root the component boundary is recorded in the `Comp`
-  // meta comment instead (see Renderer._rValComp), so this is a no-op.
-  setDataAttr(_key, _val) {
-  }
-};
-function dynRenderStep(comp, name, key) {
-  const p = resolveDynProducer(comp, name);
-  if (!p) return null;
-  return key === void 0 ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
-}
-var RenderNode = class extends RenderViewId {
-  render(stack, rx) {
-    const newStack = stack.enter(this.val.eval(stack), {}, true);
-    return rx.renderIt(newStack, this, "", this.evalViewName(stack));
-  }
-  toPathStep(ctx) {
-    if (this.val instanceof DynVal) return dynRenderStep(ctx.comp, this.val.name);
-    return super.toPathStep(ctx);
-  }
-};
-var RenderItNode = class extends RenderViewId {
-  render(stack, rx) {
-    const newStack = stack.enter(stack.it, {}, true);
-    return rx.renderIt(newStack, this, "", this.evalViewName(stack));
-  }
-  toPathStep(ctx) {
-    const next = ctx.next();
-    if (next === null) return null;
-    const nextNode = next.resolveNode();
-    if (nextNode instanceof EachNode && next.hasKey) {
-      if (nextNode.val instanceof DynVal)
-        return dynRenderStep(ctx.comp, nextNode.val.name, next.key);
-      return new EachRenderItStep(nextNode.val.name, next.key);
-    }
-    return null;
-  }
-};
-function parseRenderEach(px, value, as, attrs) {
-  const seqVal = parseXOpVal("render-each", value, px, parseSequence);
-  if (seqVal === null) return null;
-  const renderIt = px.addNode(RenderItNode, as);
-  const attrParser = getAttrParser(px);
-  const eachAttr = attrParser.pushWrapper("each", value, seqVal);
-  attrParser.eachAttr = eachAttr;
-  const when = attrs.getNamedItem("@when") ?? attrs.getNamedItem("when");
-  if (when) {
-    if (when.name.charCodeAt(0) !== 64) maybeDeprecateBareXDirective(px, "render-each", "when");
-    attrParser._parseWhen(when.value);
-  }
-  const lWith = attrs.getNamedItem("@loop-with") ?? attrs.getNamedItem("loop-with");
-  if (lWith) {
-    if (lWith.name.charCodeAt(0) !== 64)
-      maybeDeprecateBareXDirective(px, "render-each", "loop-with");
-    attrParser._parseLoopWith(lWith.value);
-  }
-  const each = px.addNodeIf(EachNode, seqVal);
-  each.iterInfo.whenVal = eachAttr.whenVal ?? null;
-  each.iterInfo.loopWithVal = eachAttr.loopWithVal ?? null;
-  each.fromRenderEach = true;
-  each.wrapNode(renderIt);
-  return each;
-}
-var RenderTextNode = class extends ANode {
-  render(stack, _rx) {
-    return this.val.eval(stack);
-  }
-  // Renders to a text node, which can't carry `data-cid`.
-  setDataAttr(_key, _val) {
-  }
-};
-var RenderOnceNode = class extends BaseNode {
-  constructor(node) {
-    super();
-    this.node = node;
-    this._render = (stack, rx) => {
-      const dom = node.render(stack, rx);
-      this._render = (_stack, _rx) => dom;
-      return dom;
-    };
-  }
-  render(stack, rx) {
-    return this._render(stack, rx);
-  }
-};
-var WrapperNode = class extends ANode {
-  constructor(nodeId, val, node = null) {
-    super(nodeId, val);
-    this.node = node;
-  }
-  wrapNode(node) {
-    this.node = node;
-  }
-  setDataAttr(key, val) {
-    this.node.setDataAttr(key, val);
-  }
-  optimize() {
-    this.node = optimizeNode(this.node);
-  }
-  static register = false;
-};
-var ShowNode = class extends WrapperNode {
-  render(stack, rx) {
-    return this.val.eval(stack) ? this.node.render(stack, rx) : null;
-  }
-};
-var HideNode = class extends WrapperNode {
-  render(stack, rx) {
-    return this.val.eval(stack) ? null : this.node.render(stack, rx);
-  }
-};
-var PushViewNameNode = class extends WrapperNode {
-  render(stack, rx) {
-    return this.node.render(stack.pushViewName(this.val.eval(stack)), rx);
-  }
-};
-var SlotNode = class extends WrapperNode {
-  // Marker instead of `instanceof`: newMacroNode receives nodes that may come
-  // from a different copy of this module (CLI tools import src/ while the
-  // module under render imports the dist bundle), and cross-copy instanceof
-  // is always false.
-  isSlotNode = true;
-  optimize() {
-    this.node.optimize();
-  }
-};
-var ScopeNode = class extends WrapperNode {
-  render(stack, rx) {
-    const binds = this.val.evalAsHandler(stack)?.call(stack.it) ?? {};
-    const dom = this.node.render(stack.enter(stack.it, binds, false), rx);
-    return rx.renderScopeMeta(this.nodeId, dom);
-  }
-  toPathStep(_ctx) {
-    return new ScopeBindStep(this.val);
-  }
-  wrapNode(node) {
-    this.node = node;
-    this.node.setDataAttr("data-nid", this.nodeId);
-  }
-  static register = true;
-};
-var EachNode = class extends WrapperNode {
-  constructor(nodeId, val) {
-    super(nodeId, val);
-    this.iterInfo = new IterInfo(val, null, null, null);
-  }
-  render(stack, rx) {
-    return rx.renderEachWhen(stack, this.iterInfo, this.node, this.nodeId);
-  }
-  toPathStep(ctx) {
-    return ctx.hasKey ? new EachBindStep(this.iterInfo, ctx.key) : null;
-  }
-  static register = true;
-};
-var IterInfo = class {
-  constructor(val, whenVal, loopWithVal, enrichWithVal) {
-    this.val = val;
-    this.whenVal = whenVal;
-    this.loopWithVal = loopWithVal;
-    this.enrichWithVal = enrichWithVal;
-  }
-  eval(stack) {
-    const seq = this.val.eval(stack) ?? [];
-    const filter = this.whenVal?.evalAsHandler(stack) ?? filterAlwaysTrue;
-    const loopWith = this.loopWithVal?.evalAsHandler(stack) ?? nullLoopWith;
-    const enricher = this.enrichWithVal?.evalAsHandler(stack) ?? null;
-    return { seq, filter, loopWith, enricher };
-  }
-  // Rebuild the per-item binds for `key`, mirroring renderEachWhen: seed
-  // { key, value }, then run @enrich-with (with @loop-with's iterData) if any.
-  enrichBinds(stack, key) {
-    const { seq, filter, loopWith, enricher } = this.eval(stack);
-    const value = seqGet(seq, key, null);
-    const binds = { key, value };
-    if (enricher) {
-      const { iterData } = unpackLoopResult(
-        loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)),
-        seq
-      );
-      callEnricher(enricher, stack.it, binds, key, value, iterData);
-    }
-    return binds;
-  }
-};
-function xOp(consumed = [], { wrappable = false, wrapper = null, ignoresChildren = false } = {}) {
-  return { consumed: new Set(consumed), wrappable, wrapper, ignoresChildren };
-}
-var X_OPS = {
-  slot: xOp(),
-  text: xOp([], { wrappable: true, ignoresChildren: true }),
-  render: xOp(["as"], { wrappable: true, ignoresChildren: true }),
-  "render-it": xOp(["as"], { wrappable: true, ignoresChildren: true }),
-  // `@when`/`@loop-with` are consumed here (handled in parseRenderEach) so
-  // `processXExtras` does not flag them as unknown attrs. TEMPORARY: the bare
-  // `when`/`loop-with` spellings are deprecated in favor of the `@` form — see
-  // maybeDeprecateBareXDirective (added 2026-07-08).
-  "render-each": xOp(["as", "when", "loop-with", "@when", "@loop-with"], {
-    wrappable: true,
-    ignoresChildren: true
-  }),
-  show: xOp([], { wrapper: ShowNode }),
-  hide: xOp([], { wrapper: HideNode })
-};
-var WRAPPER_NODES = {
-  show: ShowNode,
-  hide: HideNode,
-  each: EachNode,
-  // internal wrapper produced by a loop-less @enrich-with (no surface @scope directive)
-  scope: ScopeNode,
-  "push-view": PushViewNameNode
-};
-var ParseContext = class _ParseContext {
-  constructor(document2, Text, Comment, nodes, events, macroNodes, frame, parent) {
-    this.nodes = nodes ?? [];
-    this.events = events ?? [];
-    this.macroNodes = macroNodes ?? [];
-    this.parent = parent ?? null;
-    this.frame = frame ?? {};
-    this.document = document2 ?? globalThis.document;
-    this.Text = Text ?? globalThis.Text;
-    this.Comment = Comment ?? globalThis.Comment;
-    this.cacheConstNodes = true;
-    this.currentTag = null;
-  }
-  isInsideMacro(name) {
-    return this.frame.macroName === name || this.parent?.isInsideMacro(name);
-  }
-  enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
-    const frame = { macroName, macroVars, macroSlots };
-    return new _ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
-  }
-  parseHTML(html2) {
-    const t = this.document.createElement("template");
-    t.innerHTML = html2;
-    return t.content.childNodes;
-  }
-  addNodeIf(Class, val, extra) {
-    if (val !== null) {
-      const nodeId = this.nodes.length;
-      const node = new Class(nodeId, val, extra);
-      this.nodes.push(node);
-      return node;
-    }
-    return null;
-  }
-  // For nodes that carry no value (e.g. RenderItNode, which reads stack.it at
-  // render time); addNodeIf treats a null val as a failed parse.
-  addNode(Class, extra) {
-    const nodeId = this.nodes.length;
-    const node = new Class(nodeId, null, extra);
-    this.nodes.push(node);
-    return node;
-  }
-  registerEvents() {
-    const id = this.events.length;
-    const events = new NodeEvents(id);
-    this.events.push(events);
-    return events;
-  }
-  newMacroNode(macroName, mAttrs, childs) {
-    const anySlot = [];
-    const slots = { _: new FragmentNode(anySlot) };
-    for (const child of childs)
-      if (child.isSlotNode) slots[child.val.val] = child.node;
-      else if (!child.isWhiteSpace()) anySlot.push(child);
-    const node = new MacroNode(macroName, mAttrs, slots, this);
-    this.macroNodes.push(node);
-    return node;
-  }
-  compile(scope) {
-    for (let i = 0; i < this.macroNodes.length; i++) this.macroNodes[i].compile(scope);
-  }
-  *genEventNames() {
-    for (const event of this.events) yield* event.genEventNames();
-  }
-  getEventForId(id) {
-    return this.events[id] ?? null;
-  }
-  getNodeForId(id) {
-    return this.nodes[id] ?? null;
-  }
-  onAttributes(_attrs, _wrapperAttrs, _textChild, _isMacroCall, _tag) {
-  }
-  onParseIssue(kind, info) {
-    console.warn(`tutuca parse issue [${kind}]`, info);
-  }
-  // Lint-only channel for deprecation nudges on still-valid syntax; the base
-  // (runtime) context ignores them so live apps stay quiet. See LintParseContext.
-  onDeprecatedSyntax(_kind, _info) {
-  }
-};
-var _htmlBlockTags = "ADDRESS,ARTICLE,ASIDE,BLOCKQUOTE,CAPTION,COL,COLGROUP,DETAILS,DIALOG,DIV,DD,DL,DT,FIELDSET,FIGCAPTION,FIGURE,FOOTER,FORM,H1,H2,H3,H4,H5,H6,HEADER,HGROUP,HR,LEGEND,LI,MAIN,MENU,NAV,OL,P,PRE,SECTION,SUMMARY,TABLE,TBODY,TD,TFOOT,TH,THEAD,TR,UL";
-var HTML_BLOCK_TAGS = new Set(_htmlBlockTags.split(","));
-var isBlockDomNode = (n) => {
-  const node = n instanceof FragmentNode ? n.childs[0] : n;
-  return node instanceof DomNode && HTML_BLOCK_TAGS.has(node.tagName);
-};
-var isEmptyText = (c) => c instanceof TextNode && c.val === "";
-var isIgnorableXChild = (c) => c instanceof CommentNode || (c.isWhiteSpace?.() ?? false);
-var hasMeaningfulChilds = (childs) => childs.some((c) => !isIgnorableXChild(c));
-function trimEdgeWhite(node) {
-  if (!node.isWhiteSpace?.()) return false;
-  node.condenseWhiteSpace();
-  return true;
-}
-function condenseChildsWhites(childs) {
-  if (childs.length === 0) return childs;
-  const last = childs.length - 1;
-  let emptied = trimEdgeWhite(childs[0]);
-  if (last > 0 && trimEdgeWhite(childs[last])) emptied = true;
-  for (let i = 1; i < last; i++) {
-    const cur = childs[i];
-    if (!(cur.isWhiteSpace?.() && cur.hasNewLine())) continue;
-    const bothBlock = isBlockDomNode(childs[i - 1]) && isBlockDomNode(childs[i + 1]);
-    cur.condenseWhiteSpace(bothBlock ? "" : " ");
-    if (bothBlock) emptied = true;
-  }
-  return emptied ? childs.filter((c) => !isEmptyText(c)) : childs;
-}
-var View = class {
-  constructor(name, rawView = "No View Defined", style = "", anode = null, ctx = null) {
-    this.name = name;
-    this.anode = anode;
-    this.style = style;
-    this.ctx = ctx;
-    this.rawView = rawView;
-  }
-  compile(ctx, scope, cid) {
-    this.ctx = ctx;
-    this.anode = ANode.parse(this.rawView, ctx);
-    this.anode.setDataAttr("data-cid", cid);
-    this.anode.setDataAttr("data-vid", this.name);
-    this.ctx.compile(scope);
-    if (ctx.cacheConstNodes) this.anode = optimizeNode(this.anode);
-  }
-  render(stack, rx) {
-    if (this.anode === null) {
-      throw new Error(
-        `tutuca: view "${this.name}" was rendered before it was compiled — its component is not registered in this app/scope. Source: ${String(this.rawView).slice(0, 80).replace(/\s+/g, " ")}…`
-      );
-    }
-    return this.anode.render(stack, rx);
-  }
-};
-var NodeEvents = class {
-  constructor(id) {
-    this.id = id;
-    this.handlers = [];
-  }
-  add(name, handlerCall, modifiers) {
-    this.handlers.push(new NodeEvent(name, handlerCall, modifiers));
-  }
-  *genEventNames() {
-    for (const handler of this.handlers) yield handler.name;
-  }
-  getHandlersFor(eventName) {
-    let r = null;
-    for (const handler of this.handlers)
-      if (handler.handlesEventName(eventName)) {
-        r ??= [];
-        r.push(handler);
-      }
-    return r;
-  }
-};
-var NodeEvent = class {
-  constructor(name, handlerCall, modifiers) {
-    this.name = name;
-    this.handlerCall = handlerCall;
-    this.modifierWrapper = compileModifiers(name, modifiers);
-    this.modifiers = modifiers;
-  }
-  handlesEventName(name) {
-    return this.name === name;
-  }
-  getHandlerAndArgs(stack, event) {
-    const r = this.handlerCall.getHandlerAndArgs(stack, event);
-    r[0] = this.modifierWrapper(r[0], event);
-    return r;
-  }
-};
-var fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that;
-var fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName);
-var fwdCtrl = fwdIfCtxPred(({ e }) => isMac && e.metaKey || e.ctrlKey);
-var fwdMeta = fwdIfCtxPred(({ e }) => e.metaKey);
-var fwdAlt = fwdIfCtxPred(({ e }) => e.altKey);
-var MOD_WRAPPERS_FOR_ANY_EVENT = {
-  ctrl: fwdCtrl,
-  cmd: fwdCtrl,
-  meta: fwdMeta,
-  alt: fwdAlt
-};
-var MOD_WRAPPERS_BY_EVENT = {
-  keydown: {
-    send: fwdIfKey("Enter"),
-    cancel: fwdIfKey("Escape")
-  }
-};
-var MOD_EFFECTS = {
-  prevent: (e) => e.preventDefault?.(),
-  stop: (e) => e.stopPropagation?.()
-};
-var NO_WRAPPERS = {};
-var identityModifierWrapper = (f, _ctx) => f;
-function compileModifiers(eventName, names) {
-  if (names.length === 0) return identityModifierWrapper;
-  const wrappers = MOD_WRAPPERS_BY_EVENT[eventName] ?? NO_WRAPPERS;
-  const effects = [];
-  for (const name of names) {
-    const effect = MOD_EFFECTS[name];
-    if (effect !== void 0) effects.push(effect);
-  }
-  let w = effects.length === 0 ? (that, f, args, _ctx) => f.apply(that, args) : (that, f, args, ctx) => {
-    for (const effect of effects) effect(ctx.e);
-    return f.apply(that, args);
-  };
-  for (const name of names) {
-    const wrapper = wrappers[name] ?? MOD_WRAPPERS_FOR_ANY_EVENT[name];
-    if (wrapper !== void 0) w = wrapper(w);
-  }
-  return (f, ctx) => function(...args) {
-    return w(this, f, args, ctx);
-  };
-}
-
-// src/components.js
-var Components = class {
-  constructor() {
-    this.getComponentSymbol = /* @__PURE__ */ Symbol("getComponent");
-    this.byId = /* @__PURE__ */ new Map();
-  }
-  registerComponent(comp) {
-    comp.Class.prototype[this.getComponentSymbol] = () => comp;
-    this.byId.set(comp.id, comp);
-  }
-  getComponentForId(id) {
-    return this.byId.get(id) ?? null;
-  }
-  getCompFor(v) {
-    return v?.[this.getComponentSymbol]?.() ?? null;
-  }
-  getHandlerFor(v, name, key) {
-    return this.getCompFor(v)?.[key][name] ?? null;
-  }
-  // The `lex` leg of an intent's route: the handlers registered on the scope chain of
-  // the component that raised it, innermost first. A list, not a first match — see
-  // ComponentStack.lookupIntentChain.
-  getIntentChainFor(v, name) {
-    return this.getCompFor(v)?.scope.lookupIntentChain(name) ?? [];
-  }
-  compileStyles() {
-    const styles = [];
-    for (const comp of this.byId.values()) styles.push(comp.compileStyle());
-    return styles.join("\n");
-  }
-};
-var ComponentStack = class _ComponentStack {
-  constructor(comps = new Components(), parent = null) {
-    this.comps = comps;
-    this.parent = parent;
-    this.byName = {};
-    this.intentsByName = {};
-    this.macros = {};
-  }
-  enter() {
-    return new _ComponentStack(this.comps, this);
-  }
-  registerComponents(comps, opts) {
-    const { aliases = {} } = opts ?? {};
-    for (let i = 0; i < comps.length; i++) {
-      const comp = comps[i];
-      comp.scope = this.enter();
-      comp.Class.scope = comp.scope;
-      this.comps.registerComponent(comp);
-      this.byName[comp.name] = comp;
-    }
-    for (const alias in aliases) {
-      const comp = this.byName[aliases[alias]];
-      console.assert(this.byName[alias] === void 0, "alias overrides component", alias);
-      if (comp !== void 0) this.byName[alias] = comp;
-      else console.warn("alias", alias, "to inexistent component", aliases[alias]);
-    }
-  }
-  registerMacros(macros) {
-    for (const key in macros) {
-      const lower = key.toLowerCase();
-      console.assert(this.macros[lower] === void 0, "macro key collision", lower);
-      this.macros[lower] = macros[key];
-    }
-  }
-  getCompFor(v) {
-    return this.comps.getCompFor(v);
-  }
-  // Handlers that answer an intent's `lex` leg. A name maps to a LIST, because the leg
-  // walks: a handler that returns PASS declines and hands the intent to the next one.
-  // A bare function is accepted as a one-element list.
-  registerIntentHandlers(handlers) {
-    for (const name in handlers) {
-      const fns = Array.isArray(handlers[name]) ? handlers[name] : [handlers[name]];
-      this.intentsByName[name] = fns.map((fn) => new IntentHandler(name, fn));
-    }
-  }
-  // Innermost scope first, then outward. Concatenated rather than first-match, so a
-  // declining handler can hand the intent to one further up.
-  lookupIntentChain(name) {
-    const here = this.intentsByName[name] ?? [];
-    const up = this.parent?.lookupIntentChain(name) ?? [];
-    return up.length === 0 ? here : here.concat(up);
-  }
-  lookupComponent(name) {
-    return this.byName[name] ?? this.parent?.lookupComponent(name) ?? null;
-  }
-  lookupMacro(name) {
-    return this.macros[name] ?? this.parent?.lookupMacro(name) ?? null;
-  }
-};
-var ProvideInfo = class {
-  constructor(name, val, symbol) {
-    this.name = name;
-    this.val = val;
-    this.symbol = symbol;
-  }
-};
-var LookupInfo = class {
-  constructor(name, compName, provideName, val) {
-    this.name = name;
-    this.compName = compName;
-    this.provideName = provideName;
-    this.val = val;
-    this._sym = void 0;
-  }
-  getProducerSymbol(stack) {
-    if (this._sym === void 0)
-      this._sym = stack.lookupType(this.compName)?.provide?.[this.provideName]?.symbol ?? null;
-    return this._sym;
-  }
-};
-var isString = (v) => typeof v === "string";
-var _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
-var KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
-var _compId = 0;
-var Component = class {
-  constructor(Class, o) {
-    this.id = _compId++;
-    this.name = o.name ?? "UnkComp";
-    this.Class = Class;
-    this.views = { main: new View("main", o.view, o.style) };
-    this.commonStyle = o.commonStyle ?? "";
-    this.globalStyle = o.globalStyle ?? "";
-    this.receive = o.receive ?? {};
-    this.intent = o.intent ?? {};
-    this.alter = o.alter ?? {};
-    for (const name in o.views ?? {}) {
-      const v = o.views[name];
-      const { view, style } = isString(v) ? { view: v } : v;
-      this.views[name] = new View(name, view, style);
-    }
-    this._rawProvide = o.provide ?? {};
-    this._rawLookup = o.lookup ?? {};
-    this.provide = {};
-    this.lookup = {};
-    this.scope = null;
-    this.spec = o;
-    this.extra = {};
-    for (const key of Object.keys(o)) if (!KNOWN_SPEC_KEYS.has(key)) this.extra[key] = o[key];
-  }
-  compile(ParseContext2) {
-    for (const name in this.views)
-      this.views[name].compile(new ParseContext2(), this.scope, this.id);
-    const ctx = this.views.main.ctx;
-    for (const key in this._rawProvide) {
-      const val = parseProvide(this._rawProvide[key], ctx);
-      if (val) this.provide[key] = new ProvideInfo(key, val, Symbol(key));
-    }
-    for (const key in this._rawLookup) {
-      const linfo = this._rawLookup[key];
-      const forStr = isString(linfo) ? linfo : isString(linfo?.for) ? linfo.for : null;
-      const [compName, provideName] = forStr === null ? [] : forStr.split(".");
-      if (!isString(compName) || !isString(provideName)) continue;
-      const defStr = isString(linfo?.default) ? linfo.default : null;
-      const val = defStr === null ? null : parseField(defStr, ctx);
-      this.lookup[key] = new LookupInfo(key, compName, provideName, val);
-    }
-    for (const key in this.lookup)
-      if (this.provide[key] !== void 0)
-        console.warn("name declared in both provide and lookup", this.name, key);
-  }
-  make(args, opts) {
-    return this.Class.make(args, opts ?? { scope: this.scope });
-  }
-  getView(name) {
-    return this.views[name] ?? this.views.main;
-  }
-  getEventForId(id, name = "main") {
-    return this.getView(name).ctx.getEventForId(id);
-  }
-  getNodeForId(id, name = "main") {
-    return this.getView(name).ctx.getNodeForId(id);
-  }
-  compileStyle() {
-    const { id, commonStyle, globalStyle, views } = this;
-    const styles = commonStyle ? [`[data-cid="${id}"]{${commonStyle}}`] : [];
-    if (globalStyle !== "") styles.push(globalStyle);
-    for (const name in views) {
-      const { style } = views[name];
-      if (style !== "") styles.push(`[data-cid="${id}"][data-vid="${name}"]{${style}}`);
-    }
-    return styles.join("\n");
-  }
-};
-
-// src/stack.js
-var STOP = /* @__PURE__ */ Symbol("STOP");
-var NEXT = /* @__PURE__ */ Symbol("NEXT");
-function lookup(chain, name, dv = null) {
-  let n = chain;
-  while (n !== null) {
-    const r = n[0].lookup(name);
-    if (r === STOP) return dv;
-    if (r !== NEXT) return r;
-    n = n[1];
-  }
-  return dv;
-}
-var BindFrame = class {
-  constructor(it, binds, isFrame) {
-    this.it = it;
-    this.binds = binds;
-    this.isFrame = isFrame;
-  }
-  lookup(name) {
-    const v = this.binds[name];
-    return v === void 0 ? this.isFrame ? STOP : NEXT : v;
-  }
-};
-var ObjectFrame = class {
-  constructor(binds) {
-    this.binds = binds;
-  }
-  lookup(key) {
-    const v = this.binds[key];
-    return v === void 0 ? NEXT : v;
-  }
-};
-function computeViewsId(views) {
-  let s = "";
-  let n = views;
-  while (n !== null) {
-    s += n[0];
-    n = n[1];
-  }
-  return s === "main" ? "" : s;
-}
-var Stack = class _Stack {
-  constructor(comps, it, binds, dynBinds, views, viewsId, ctx = null) {
-    this.comps = comps;
-    this.it = it;
-    this.binds = binds;
-    this.dynBinds = dynBinds;
-    this.views = views;
-    this.viewsId = viewsId;
-    this.ctx = ctx;
-  }
-  // Evaluate every provide the entered component publishes and push them as one
-  // dynBinds frame (keyed by each provide's symbol). No-op when there are no provides.
-  _pushProvides() {
-    const provide = this.comps.getCompFor(this.it)?.provide;
-    if (provide == null) return this;
-    const dynObj = {};
-    let has = false;
-    for (const k in provide) {
-      dynObj[provide[k].symbol] = provide[k].val.eval(this);
-      has = true;
-    }
-    if (!has) return this;
-    const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
-    const { comps, it, binds, views, viewsId, ctx } = this;
-    return new _Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
-  }
-  static root(comps, it, ctx) {
-    const binds = [new BindFrame(it, {}, true), null];
-    const dynBinds = [new ObjectFrame({}), null];
-    const views = ["main", null];
-    return new _Stack(comps, it, binds, dynBinds, views, "", ctx)._pushProvides();
-  }
-  enter(it, bindings = {}, isFrame = true) {
-    const { comps, binds, dynBinds, views, viewsId, ctx } = this;
-    const newBinds = [new BindFrame(it, bindings, isFrame), binds];
-    const stack = new _Stack(comps, it, newBinds, dynBinds, views, viewsId, ctx);
-    return isFrame ? stack._pushProvides() : stack;
-  }
-  pushViewName(name) {
-    const { comps, it, binds, dynBinds, views, ctx } = this;
-    const newViews = [name, views];
-    return new _Stack(comps, it, binds, dynBinds, newViews, computeViewsId(newViews), ctx);
-  }
-  _pushDynBindValuesToArray(arr, comp) {
-    for (const k in comp.provide) arr.push(this._lookupProvide(comp.provide[k]));
-    for (const k in comp.lookup) arr.push(this._lookupAlias(comp.lookup[k]));
-  }
-  _lookupProvide(p) {
-    return lookup(this.dynBinds, p.symbol) ?? p.val.eval(this) ?? null;
-  }
-  _lookupAlias(lk) {
-    const sym = lk.getProducerSymbol(this);
-    return (sym != null ? lookup(this.dynBinds, sym) : null) ?? lk.val?.eval(this) ?? null;
-  }
-  lookupDynamic(name) {
-    const comp = this.comps.getCompFor(this.it);
-    if (comp == null) return null;
-    const lk = comp.lookup[name];
-    if (lk !== void 0) return this._lookupAlias(lk);
-    const p = comp.provide[name];
-    return p !== void 0 ? this._lookupProvide(p) : null;
-  }
-  lookupBind(name) {
-    return lookup(this.binds, name);
-  }
-  lookupType(name) {
-    return this.comps.getCompFor(this.it).scope.lookupComponent(name);
-  }
-  lookupFieldRaw(name) {
-    return this.it[name] ?? null;
-  }
-  lookupMethod(name) {
-    const fn = this.it[name];
-    return fn instanceof Function ? fn.call(this.it) : null;
-  }
-  lookupName(name) {
-    return this.ctx.lookupName(name);
-  }
-  getHandlerFor(name, key) {
-    return this.comps.getHandlerFor(this.it, name, key);
-  }
-  lookupBestView(views, defaultViewName) {
-    let n = this.views;
-    while (n !== null) {
-      const view = views[n[0]];
-      if (view !== void 0) return view;
-      n = n[1];
-    }
-    return views[defaultViewName];
-  }
-};
-
-// src/oo.js
-var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
-var nullCoercer = (v) => v;
-var isPlainObject2 = (v) => {
-  if (v === null || typeof v !== "object") return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-};
-function defaultToData(v) {
-  if (v instanceof Map) return [...v.entries()];
-  if (v instanceof Set) return [...v.values()];
-  return v;
-}
-var Field = class {
-  constructor(type, name, typeCheck, coercer, defaultValue = null) {
-    this.type = type;
-    this.name = name;
-    this.typeCheck = typeCheck;
-    this.coercer = coercer;
-    this.checks = [];
-    this.defaultValue = defaultValue;
-  }
-  toDataDef() {
-    return { type: this.type, defaultValue: defaultToData(this.defaultValue) };
-  }
-  getFirstFailingCheck(v) {
-    if (!this.typeCheck.isValid(v)) return this.typeCheck;
-    for (const check3 of this.checks) if (!check3.isValid(v)) return check3;
-    return null;
-  }
-  isValid(v) {
-    return this.getFirstFailingCheck(v) === null;
-  }
-  addCheck(check3) {
-    this.checks.push(check3);
-    return this;
-  }
-  coerceOr(v, defaultValue = null) {
-    if (this.isValid(v)) return v;
-    const v1 = this.coercer(v);
-    return this.isValid(v1) ? v1 : defaultValue;
-  }
-  coerceOrDefault(v) {
-    return this.coerceOr(v, this.defaultValue);
-  }
-};
-var Check = class {
-  isValid(_v) {
-    return true;
-  }
-  getMessage(_v) {
-    return "Invalid";
-  }
-};
-var CheckTypeAny = class extends Check {
-};
-var CHECK_TYPE_ANY = new CheckTypeAny();
-var FnCheck = class extends Check {
-  constructor(isValidFn, getMessageFn) {
-    super();
-    this._isValid = isValidFn;
-    this._getMessage = getMessageFn;
-  }
-  isValid(v) {
-    return this._isValid(v);
-  }
-  getMessage(v) {
-    return this._getMessage(v);
-  }
-};
-var check = (fn, message) => new FnCheck(fn, () => message);
-var CHECK_TYPE_INT = check(Number.isInteger, "Integer expected");
-var CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
-var CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
-var CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
-var CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
-var CHECK_TYPE_OBJECT = check(isPlainObject2, "Plain object expected");
-var CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
-var CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
-var FieldBool = class extends Field {
-  constructor(name, defaultValue = false) {
-    super("bool", name, CHECK_TYPE_BOOL, (v) => !!v, defaultValue);
-  }
-};
-var FieldAny = class extends Field {
-  constructor(name, defaultValue = null) {
-    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
-  }
-  toDataDef() {
-    return { type: getTypeName(this.defaultValue) ?? "any", defaultValue: this.defaultValue };
-  }
-};
-var FieldString = class extends Field {
-  constructor(name, defaultValue = "") {
-    super("text", name, CHECK_TYPE_STRING, (v) => v?.toString?.() ?? "", defaultValue);
-  }
-};
-var FieldInt = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super(
-      "int",
-      name,
-      CHECK_TYPE_INT,
-      (v) => Number.isFinite(v) ? Math.trunc(v) : null,
-      defaultValue
-    );
-  }
-};
-var FieldFloat = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("float", name, CHECK_TYPE_FLOAT, (_) => null, defaultValue);
-  }
-};
-var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
-var CheckTypeName = class {
-  constructor(typeName) {
-    this.typeName = typeName;
-  }
-  isValid(v) {
-    return getTypeName(v) === this.typeName;
-  }
-  getMessage(v) {
-    return `Expected "${this.typeName}", got "${getTypeName(v)}"`;
-  }
-};
-var FieldComp = class extends Field {
-  constructor(type, name, args) {
-    super(type, name, new CheckTypeName(type), nullCoercer, null);
-    this.args = args;
-  }
-  toDataDef() {
-    return { component: this.type, args: this.args };
-  }
-};
-var FieldList = class extends Field {
-  constructor(name, defaultValue = []) {
-    super("list", name, CHECK_TYPE_LIST, (v) => Array.isArray(v) ? [...v] : null, defaultValue);
-  }
-};
-var FieldObject = class extends Field {
-  constructor(name, defaultValue = {}) {
-    super(
-      "object",
-      name,
-      CHECK_TYPE_OBJECT,
-      (v) => isPlainObject2(v) ? { ...v } : null,
-      defaultValue
-    );
-  }
-};
-var FieldMap = class extends Field {
-  constructor(name, defaultValue = /* @__PURE__ */ new Map()) {
-    super(
-      "map",
-      name,
-      CHECK_TYPE_MAP,
-      (v) => {
-        if (v instanceof Map) return new Map(v);
-        if (Array.isArray(v) || isPlainObject2(v))
-          return new Map(Array.isArray(v) ? v : Object.entries(v));
-        return null;
-      },
-      defaultValue
-    );
-  }
-};
-var FieldSet = class extends Field {
-  constructor(name, defaultValue = /* @__PURE__ */ new Set()) {
-    super(
-      "set",
-      name,
-      CHECK_TYPE_SET,
-      (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null,
-      defaultValue
-    );
-  }
-};
-function mkCompField(field, scope, args) {
-  const Comp = scope?.lookupComponent(field.type) ?? null;
-  if (Comp === null)
-    console.warn(
-      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
-    );
-  return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
-}
-var ClassBuilder = class {
-  constructor(name) {
-    this.name = name;
-    this.fields = {};
-    this.compFields = /* @__PURE__ */ new Set();
-    this._methods = {};
-    this._statics = {};
-  }
-  build() {
-    const { name, fields, compFields, _methods } = this;
-    const defaults = Object.fromEntries(
-      Object.entries(fields).map(([fieldName, field]) => [fieldName, field.defaultValue])
-    );
-    const Class = {
-      [name]: class {
-        constructor(values = {}) {
-          Object.assign(this, defaults, values);
-        }
-      }
-    }[name];
-    Class[immer_exports.immerable] = true;
-    Object.assign(Class.prototype, _methods);
-    const metaClass = { fields, name, methods: _methods };
-    Object.assign(
-      Class,
-      {
-        getMetaClass: () => metaClass,
-        make(inArgs = {}, opts = {}) {
-          const args = {};
-          const scope = opts.scope ?? this.scope;
-          for (const key in inArgs) {
-            const field = fields[key];
-            if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
-            else if (field === void 0)
-              console.warn("extra argument to constructor:", name, key, inArgs);
-            else args[key] = field.coerceOrDefault(inArgs[key]);
-          }
-          for (const key of compFields)
-            if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
-          return (0, immer_exports.freeze)(new this(args), true);
-        }
-      },
-      this._statics
-    );
-    return Class;
-  }
-  methods(proto) {
-    for (const k in proto) this._methods[k] = proto[k];
-  }
-  statics(proto) {
-    for (const k in proto) this._statics[k] = proto[k];
-  }
-  addField(name, dval, FieldCls) {
-    const field = new FieldCls(name, dval);
-    this.fields[name] = field;
-    return field;
-  }
-  addCompField(name, type, args) {
-    const field = new FieldComp(type, name, args);
-    this.compFields.add(name);
-    this.fields[name] = field;
-    return field;
-  }
-};
-var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
-var fieldsByTypeName = {
-  text: FieldString,
-  int: FieldInt,
-  float: FieldFloat,
-  bool: FieldBool,
-  list: FieldList,
-  object: FieldObject,
-  map: FieldMap,
-  set: FieldSet,
-  any: FieldAny
-};
-function fieldFromDescriptor(name, value) {
-  const FieldCls = fieldsByTypeName[value.type] ?? FieldAny;
-  const probe = new FieldCls(name);
-  return [FieldCls, probe.coerceOr(value.defaultValue, probe.defaultValue)];
-}
-function classFromData(name, { fields = {}, methods, statics }) {
-  const b = new ClassBuilder(name);
-  for (const field in fields) {
-    const value = fields[field];
-    const type = typeof value;
-    if (type === "string") b.addField(field, value, FieldString);
-    else if (type === "number")
-      b.addField(field, value, Number.isInteger(value) ? FieldInt : FieldFloat);
-    else if (type === "boolean") b.addField(field, value, FieldBool);
-    else if (Array.isArray(value)) b.addField(field, [...value], FieldList);
-    else if (value instanceof Set) b.addField(field, new Set(value), FieldSet);
-    else if (value instanceof Map) b.addField(field, new Map(value), FieldMap);
-    else if (value?.type && Object.hasOwn(value, "defaultValue")) {
-      const [FieldCls, dval] = fieldFromDescriptor(field, value);
-      b.addField(field, dval, FieldCls);
-    } else if (value?.component && value?.args !== void 0)
-      b.addCompField(field, value.component, value.args);
-    else if (isPlainObject2(value)) b.addField(field, { ...value }, FieldObject);
-    else {
-      const FieldCls = value?.[FIELD_CLASS] ?? FieldAny;
-      b.addField(field, value, FieldCls);
-    }
-  }
-  if (methods) b.methods(methods);
-  if (statics) b.statics(statics);
-  return b.build();
-}
-function validateDraftFields(current, draft) {
-  const meta = current?.constructor?.getMetaClass?.();
-  if (!meta) return;
-  for (const [name, field] of Object.entries(meta.fields)) {
-    const value = draft[name];
-    if (field.isValid(value)) continue;
-    const coerced = field.coerceOr(value, BAD_VALUE);
-    if (coerced !== BAD_VALUE) draft[name] = coerced;
-    else {
-      console.warn(`invalid value for ${meta.name}.${name}`, value);
-      draft[name] = current[name];
-    }
-  }
-}
-Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
-var component = (opts) => Component.fromSpec(opts);
-
-// src/transactor.js
-var State = class {
-  constructor(val) {
-    this.val = val;
-    this.changeSubs = [];
-  }
-  onChange(cb) {
-    this.changeSubs.push(cb);
-  }
-  set(val, info) {
-    const old = this.val;
-    this.val = val;
-    for (const sub of this.changeSubs) sub({ val, old, info, timestamp: Date.now() });
-  }
-  update(fn, info) {
-    return this.set(fn(this.val), info);
-  }
-};
-var Transactor = class {
-  constructor(comps, rootValue) {
-    this.comps = comps;
-    this.transactions = [];
-    this.state = new State(rootValue);
-    this.onTransactionPushed = () => {
-    };
-    this._observers = [];
-    this._inflight = /* @__PURE__ */ new Set();
-  }
-  pushTransaction(t) {
-    this.transactions.push(t);
-    this.onTransactionPushed(t);
-  }
-  // Subscribe to a normalized record for every handler invocation. `kind` is the
-  // handler bucket (`receive` / `intent`), plus `answer` — an observation-only kind for
-  // a message the runtime wrote to answer an intent. The BUCKET does not know about
-  // that distinction, and must not: a handler cannot tell an answer from a message its
-  // parent sent. Returns an unsubscribe function. Records
-  // carry: kind, name, args, path, pathKeys, targetPath, handler, handlerName,
-  // matched, before, after, parent, timestamp. Purely observational.
-  observe(cb) {
-    this._observers.push(cb);
-    return () => {
-      const i = this._observers.indexOf(cb);
-      if (i !== -1) this._observers.splice(i, 1);
-    };
-  }
-  _emit(record) {
-    for (const cb of this._observers) cb(record);
-  }
-  // Build and dispatch the observer record for a settled transaction. The
-  // resolved handler (`_resolvedHandler`/`_matched`) and per-leaf before/after
-  // (`_before`/`_after`) were captured while the handler ran (see callHandler /
-  // updateRootValue). No-op when nobody is observing.
-  _emitTransaction(transaction, root) {
-    if (this._observers.length === 0) return;
-    if (transaction._resolvedHandler === void 0) return;
-    const path = transaction.getTransactionPath().pinKeys(root);
-    this._emit({
-      kind: transaction.observeKind,
-      name: transaction.observeName,
-      args: transaction.args ?? null,
-      path,
-      pathKeys: path.toKeys(),
-      targetPath: transaction.targetPath ?? transaction.path,
-      handler: transaction._resolvedHandler ?? null,
-      handlerName: transaction._resolvedHandler?.name || null,
-      matched: transaction._matched ?? null,
-      before: transaction._before,
-      after: transaction._after,
-      parent: transaction.parentTransaction,
-      timestamp: Date.now()
-    });
-  }
-  // Make `child` a tracked unit of `parent`'s subtree: the parent's completion stays open
-  // until the child's *whole* subtree settles. Tracking happens at dispatch time — during
-  // the parent's handler or afterTransaction — while the parent's self-unit is still held,
-  // so the parent counter can't reach zero before the child is registered. Returns `child`.
-  _link(child, parent) {
-    if (parent) {
-      const release = parent.completion.track();
-      child.completion.whenSubtreeSettled().then(release);
-    }
-    return child;
-  }
-  pushSend(path, name, args = [], opts = {}, parent = null) {
-    const t = new SendEvent(path, this, name, args, parent, opts);
-    this.pushTransaction(t);
-    return this._link(t, parent);
-  }
-  // Raise an intent: a job the sender did not address, walked along a route until
-  // something answers. `opts.route` is a list of legs (see DEFAULT_ROUTE) and
-  // `opts.livePath` opts out of pinning the answer's destination keys.
-  pushIntent(path, name, args = [], opts = {}, parent = null) {
-    const release = parent ? parent.completion.track() : null;
-    const walk = new IntentWalk(this, path, name, args, opts, parent, release);
-    walk.advance();
-    return walk;
-  }
-  // Drain queued transactions and await in-flight requests until quiescent. Each
-  // awaited request enqueues a ResponseEvent, which may dispatch more work, so we
-  // loop. `maxTurns` backstops a pathological non-terminating cascade.
-  async settle(maxTurns = 1e4) {
-    while ((this.hasPendingTransactions || this._inflight.size) && maxTurns-- > 0) {
-      while (this.hasPendingTransactions) this.transactNext();
-      if (this._inflight.size) await Promise.allSettled([...this._inflight]);
-    }
-  }
-  get hasPendingTransactions() {
-    return this.transactions.length > 0;
-  }
-  transactNext() {
-    if (this.hasPendingTransactions) this.transact(this.transactions.shift());
-  }
-  transact(transaction) {
-    try {
-      const curState = this.state.val;
-      const newState = transaction.run(curState, this.comps);
-      if (newState !== void 0) {
-        this.state.set(newState, { transaction });
-        transaction.afterTransaction();
-        this._emitTransaction(transaction, curState);
-      } else console.warn("undefined new state", { curState, transaction });
-    } finally {
-      transaction.ensureWalkAdvanced?.();
-      transaction._completion?.ensureSelfSettled();
-      transaction._completion?.releaseSelf();
-    }
-  }
-  transactInputNow(path, event, eventHandler, dragInfo) {
-    this.transact(new InputEvent(path, event, eventHandler, this, dragInfo));
-  }
-};
-function nullHandler() {
-  return this;
-}
-var Transaction = class {
-  constructor(path, transactor, parentTransaction = null) {
-    this.path = path;
-    this.transactor = transactor;
-    this.parentTransaction = parentTransaction;
-    this._completion = null;
-  }
-  // Lazily created (like the rest of the per-transaction state): a leaf event that
-  // nobody tracks or awaits never allocates one. See `class Completion`.
-  get completion() {
-    this._completion ??= new Completion();
-    return this._completion;
-  }
-  // Resolves once this transaction's own handler has run.
-  whenSettled() {
-    return this.completion.whenSettled();
-  }
-  // Resolves once this transaction AND all transitively-derived work (sends, bubbles,
-  // requests and the responses they produce, recursively) have settled.
-  whenSubtreeSettled() {
-    return this.completion.whenSubtreeSettled();
-  }
-  run(rootValue, comps) {
-    return this.updateRootValue(rootValue, comps);
-  }
-  afterTransaction() {
-  }
-  // Ending a walk and forwarding belong to the two dispatch buckets; the base warns
-  // rather than throwing, so a stray call from the wrong place is a message and not a
-  // crash. `walk` is undefined here, which is how ctx.reply/ctx.fail tell the two apart.
-  stop() {
-    console.warn('ctx.stop() is only meaningful in an "intent" handler - ignored');
-  }
-  forward(_opts) {
-    console.warn('ctx.forward() needs a "receive" or "intent" handler - ignored');
-  }
-  buildRootStack(root, comps) {
-    return Stack.root(comps, root);
-  }
-  buildStack(root, comps) {
-    return this.path.toTransactionPath().buildStack(this.buildRootStack(root, comps));
-  }
-  // The kind reported to observers (see Transactor.observe); null on the base.
-  get observeKind() {
-    return null;
-  }
-  // The name reported to observers; null on the base. Overridden by NameArgs (the
-  // dispatched message name) and InputEvent (the DOM event type). Kept separate from
-  // `name`/`ctx.name` so it can't change handler-visible behavior.
-  get observeName() {
-    return null;
-  }
-  callHandler(root, instance, draft, comps) {
-    const [handler, args] = this.getHandlerAndArgs(root, instance, comps);
-    this._resolvedHandler = handler;
-    return handler.apply(instance, [draft, ...args]);
-  }
-  getHandlerAndArgs(_root, _instance, _comps) {
-    return null;
-  }
-  // The path used to apply the mutation. Teleports dynamic-var renders so it lands on
-  // the data's real location (the dispatch `this.path` keeps intermediates). A subclass
-  // may override to supply a pre-resolved path (see ResponseEvent's pinned keys).
-  getTransactionPath() {
-    return this.path.toTransactionPath().compact();
-  }
-  updateRootValue(curRoot, comps) {
-    const txnPath = this.getTransactionPath();
-    const curLeaf = txnPath.lookup(curRoot);
-    const newLeaf = (0, immer_exports.produce)(curLeaf, (draft) => {
-      const result = this.callHandler(curRoot, curLeaf, draft, comps);
-      if (result === void 0 || result === draft) validateDraftFields(curLeaf, draft);
-      return result;
-    });
-    this._before = curLeaf;
-    this._after = newLeaf;
-    this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
-    return curLeaf !== newLeaf ? txnPath.setValue(curRoot, newLeaf) : curRoot;
-  }
-  lookupName(_name) {
-    return null;
-  }
-};
-var toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
-function getValue(e) {
-  return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
-}
-var InputEvent = class extends Transaction {
-  constructor(path, e, handler, transactor, dragInfo) {
-    super(path, transactor);
-    this.e = e;
-    this.handler = handler;
-    this.dragInfo = dragInfo;
-    this._dispatchPath = null;
-  }
-  // Frame steps removed, DynStep + one step per crossed component kept: bubbling
-  // it visits every component (including intermediates of a dynamic-var render).
-  get dispatchPath() {
-    this._dispatchPath ??= this.path.compact();
-    return this._dispatchPath;
-  }
-  // A DOM event is an ADDRESSED message like any other — it reaches the component that
-  // owns the view and stops. It keeps its own class only because it resolves its handler
-  // from the compiled view and runs synchronously, not because it is a different channel.
-  get observeKind() {
-    return "receive";
-  }
-  get observeName() {
-    return this.e?.type ?? null;
-  }
-  // A view's name is a message. `forward` is where that name can LEAVE the component:
-  // it becomes an intent with the same name and the same arguments, so a view that says
-  // `@on.click="saveDraft .text"` never has to change when an ancestor takes the job over.
-  // (A `$method` handler has a name too, so forwarding one raises an intent under it.)
-  forward(opts) {
-    this._forward = opts ?? {};
-  }
-  afterTransaction() {
-    const f = this._forward;
-    if (f === void 0) return;
-    this._forward = void 0;
-    const { args = this._handlerArgs ?? [], ...rest } = f;
-    const hv = this.handler?.handlerCall?.handlerVal ?? this.handler?.handlerVal;
-    const name = hv?.name;
-    if (name === void 0)
-      return console.warn("ctx.forward() from a handler with no name - ignored");
-    this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
-  }
-  buildRootStack(root, comps) {
-    return Stack.root(comps, root, this);
-  }
-  getHandlerAndArgs(root, _instance, comps) {
-    const stack = this.buildStack(root, comps);
-    const [handler, args] = this.handler.getHandlerAndArgs(stack, this);
-    this._handlerArgs = [...args];
-    const path = this.dispatchPath;
-    args.push(new EventContext(path, this.transactor, this));
-    return [handler, args];
-  }
-  lookupName(name) {
-    const { e } = this;
-    switch (name) {
-      case "value":
-        return getValue(e);
-      case "valueAsInt":
-        return toNullIfNaN(parseInt(getValue(e), 10));
-      case "valueAsFloat":
-        return toNullIfNaN(parseFloat(getValue(e)));
-      case "target":
-        return e.target;
-      case "event":
-        return e;
-      case "isAlt":
-        return e.altKey;
-      case "isShift":
-        return e.shiftKey;
-      case "isCtrl":
-      /* falls through */
-      case "isCmd":
-        return isMac && e.metaKey || e.ctrlKey;
-      case "key":
-        return e.key;
-      case "keyCode":
-        return e.keyCode;
-      case "isUpKey":
-        return e.key === "ArrowUp";
-      case "isDownKey":
-        return e.key === "ArrowDown";
-      case "isSend":
-        return e.key === "Enter";
-      case "isCancel":
-        return e.key === "Escape";
-      case "isTabKey":
-        return e.key === "Tab";
-      case "ctx":
-        return new EventContext(this.dispatchPath, this.transactor, this);
-      case "dragInfo":
-        return this.dragInfo;
-    }
-    return null;
-  }
-};
-var NameArgsTransaction = class extends Transaction {
-  constructor(path, transactor, name, args, parentTransaction, opts = {}) {
-    super(path, transactor, parentTransaction);
-    this.name = name;
-    this.args = args;
-    this.opts = opts;
-    this.targetPath = path;
-  }
-  handlerProp = null;
-  // NameArgs verbs map their handler bucket straight to the observed kind:
-  // receive / bubble / response / input.
-  get observeKind() {
-    return this.handlerProp;
-  }
-  get observeName() {
-    return this.name;
-  }
-  getHandlerForName(comp) {
-    const handlers = comp?.[this.handlerProp];
-    const exact = handlers?.[this.name];
-    if (exact) {
-      this._matched = "exact";
-      return exact;
-    }
-    const unknown = handlers?.$unknown;
-    if (unknown) {
-      this._matched = "unknown";
-      return unknown;
-    }
-    this._matched = "none";
-    return nullHandler;
-  }
-  getHandlerAndArgs(_root, instance, comps) {
-    const handler = this.getHandlerForName(comps.getCompFor(instance));
-    return [handler, [...this.args, new EventContext(this.path, this.transactor, this)]];
-  }
-};
-var SendEvent = class extends NameArgsTransaction {
-  handlerProp = "receive";
-  // `receive` is the ADDRESSED bucket, and it is the only one: a view's `@on.click`,
-  // a parent's ctx.send, the host's sendAtRoot and an answer to an intent all arrive
-  // here, and a handler cannot tell them apart. Splitting on where a message came from
-  // would let the view's name through and turn the parent's away, though the two say
-  // the same thing — and neither a test nor a parent could drive the component.
-  get observeKind() {
-    return this._isAnswer ? "answer" : "receive";
-  }
-  // `forward` in a RECEIVE body starts a walk: the message that arrived becomes an
-  // intent, keeping its name and payload. This is what lets a view's name leave the
-  // component without the view changing.
-  forward(opts) {
-    this._forward = opts ?? {};
-  }
-  afterTransaction() {
-    const f = this._forward;
-    if (f === void 0) return;
-    this._forward = void 0;
-    const { args = this.args, ...rest } = f;
-    this.transactor.pushIntent(this.path, this.name, args, rest, this);
-  }
-};
-var IntentEvent = class extends NameArgsTransaction {
-  handlerProp = "intent";
-  constructor(path, transactor, walk) {
-    super(path, transactor, walk.name, walk.args, walk.parent, {});
-    this.walk = walk;
-    this.targetPath = walk.origin;
-  }
-  // `forward` in an INTENT body amends the hop about to be pushed — it does not push
-  // one itself, because a walk advances on its own.
-  forward(opts) {
-    this.walk.amend(opts, this.path);
-  }
-  stop() {
-    this.walk.finish(null, null);
-  }
-  afterTransaction() {
-    this.ensureWalkAdvanced();
-  }
-  // Idempotent, because both afterTransaction and the transactor's `finally` call it —
-  // whichever gets there first advances the walk exactly once.
-  ensureWalkAdvanced() {
-    if (this._advanced) return;
-    this._advanced = true;
-    this.walk.advance();
-  }
-};
-var PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
-var DEFAULT_ROUTE = ["dyn", "lex"];
-var INTENT_DEPTH = 64;
-var IntentWalk = class {
-  constructor(transactor, path, name, args, opts, parent, release) {
-    this.transactor = transactor;
-    this.name = name;
-    this.args = args;
-    this.route = opts?.route ?? DEFAULT_ROUTE;
-    this.parent = parent;
-    this.release = release;
-    this.origin = path;
-    this.answerPath = opts?.livePath ? null : path.toTransactionPath().pinKeys(transactor.state.val);
-    this.legIndex = 0;
-    this.dynAt = path;
-    this.hops = 0;
-    this.ended = false;
-  }
-  // Offer the intent to the next hop. Called once at dispatch, and again by every hop
-  // that ran without answering.
-  advance() {
-    if (this.ended) return;
-    if (this.hops++ >= INTENT_DEPTH) return this.exhaust("intentDepth");
-    while (this.legIndex < this.route.length) {
-      const leg = this.route[this.legIndex];
-      if (leg === "dyn") {
-        if (this.dynAt.steps.length === 0) {
-          this.legIndex++;
-          continue;
-        }
-        this.dynAt = this.dynAt.popStep();
-        this.transactor.pushTransaction(new IntentEvent(this.dynAt, this.transactor, this));
-        return;
-      }
-      if (leg === "lex") {
-        this.legIndex++;
-        return this._tryLex();
-      }
-      console.warn("unknown intent route leg", leg, '- expected "dyn" or "lex"');
-      this.legIndex++;
-    }
-    this.exhaust("noHandler");
-  }
-  // The `lex` leg: the handlers registered on the scope chain of the component that
-  // raised the intent, in order.
-  _tryLex() {
-    const root = this.transactor.state.val;
-    const txnPath = this.origin.toTransactionPath();
-    const leaf = txnPath.lookup(root);
-    const chain = this.transactor.comps.getIntentChainFor(leaf, this.name);
-    if (this.transactor._observers.length > 0) {
-      const path = txnPath.pinKeys(root);
-      this.transactor._emit({
-        kind: "intent",
-        name: this.name,
-        args: this.args,
-        path,
-        pathKeys: path.toKeys(),
-        targetPath: this.origin,
-        handler: chain[0]?.fn ?? null,
-        handlerName: chain[0]?.fn?.name || this.name,
-        matched: chain.length > 0 ? "exact" : "none",
-        before: leaf,
-        after: void 0,
-        parent: this.parent,
-        timestamp: Date.now()
-      });
-    }
-    if (chain.length === 0) return this.advance();
-    const p = this._runLex(chain, 0);
-    this.transactor._inflight.add(p);
-    p.finally(() => this.transactor._inflight.delete(p));
-  }
-  async _runLex(chain, i) {
-    if (this.ended) return;
-    if (i >= chain.length) return this.advance();
-    const ctx = new IntentContext(this.origin, this.transactor, this.parent);
-    try {
-      const res = await chain[i].fn.apply(null, [...this.args, ctx]);
-      if (res === PASS) return this._runLex(chain, i + 1);
-      this.answer("Ok", res);
-    } catch (error) {
-      this.answer("Error", error);
-    }
-  }
-  // A hop answered. Ends the walk.
-  answer(suffix, value) {
-    this.finish(`${this.name}${suffix}`, [value]);
-  }
-  // `forward` from an intent body: keep walking, optionally with new arguments or a
-  // narrowed route.
-  amend(opts, from) {
-    if (opts?.args !== void 0) this.args = opts.args;
-    if (opts?.route !== void 0) {
-      this.route = opts.route;
-      this.legIndex = 0;
-      this.dynAt = from ?? this.dynAt;
-    }
-  }
-  // The route ran out. What the sender hears depends only on what it DECLARES, which is
-  // how "a sender expects an answer if and only if it declares an answer arm" becomes
-  // code — nobody writes it down twice, and there is no schema to keep in step.
-  exhaust(reason) {
-    if (this.ended) return;
-    const { name, args } = this;
-    const comp = this.transactor.comps.getCompFor(
-      this.origin.toTransactionPath().lookup(this.transactor.state.val)
-    );
-    const declares = (n) => comp?.receive?.[n] !== void 0;
-    if (declares(`${name}Unhandled`)) {
-      this.finish(`${name}Unhandled`, args);
-    } else if (declares(`${name}Error`)) {
-      this.finish(`${name}Error`, [reason]);
-    } else {
-      if (declares(`${name}Ok`))
-        console.warn(
-          `intent "${name}" was not answered (${reason}) and this component declares only "${name}Ok" - add "${name}Unhandled" or "${name}Error" to handle it`
-        );
-      this.finish(null, null);
-    }
-  }
-  // End the walk. `name === null` means no answer goes out, which is what `stop` and a
-  // fire-and-forget notification both are — the tracked unit is released here instead
-  // of following an answer's subtree.
-  finish(name, args) {
-    if (this.ended) return;
-    this.ended = true;
-    if (name === null) return this.release?.();
-    const path = this.answerPath ?? this.origin;
-    const t = new SendEvent(path, this.transactor, name, args, this.parent, {});
-    t._isAnswer = true;
-    this.transactor.pushTransaction(t);
-    if (this.release) t.completion.whenSubtreeSettled().then(this.release);
-  }
-};
-var Completion = class {
-  constructor() {
-    this.val = void 0;
-    this.selfSettled = false;
-    this.subtreeSettled = false;
-    this.pending = 1;
-    this._selfResolve = null;
-    this._selfPromise = null;
-    this._subtreeResolve = null;
-    this._subtreePromise = null;
-    this._selfReleased = false;
-  }
-  whenSettled() {
-    if (this.selfSettled) return Promise.resolve(this.val);
-    this._selfPromise ??= new Promise((res) => {
-      this._selfResolve = res;
-    });
-    return this._selfPromise;
-  }
-  whenSubtreeSettled() {
-    if (this.subtreeSettled) return Promise.resolve(this.val);
-    this._subtreePromise ??= new Promise((res) => {
-      this._subtreeResolve = res;
-    });
-    return this._subtreePromise;
-  }
-  // The transaction's own handler ran (records its {value, old}). Does not touch the counter.
-  markSelfSettled(val) {
-    if (this.selfSettled) return;
-    this.selfSettled = true;
-    this.val = val;
-    this._selfResolve?.(val);
-  }
-  // Settle self even when no handler produced a value (skipSelf / undefined / throw paths).
-  ensureSelfSettled() {
-    if (!this.selfSettled) this.markSelfSettled(this.val);
-  }
-  // Register an outstanding unit; returns a one-shot release.
-  track() {
-    this.pending++;
-    let done = false;
-    return () => {
-      if (done) return;
-      done = true;
-      this._release();
-    };
-  }
-  releaseSelf() {
-    if (this._selfReleased) return;
-    this._selfReleased = true;
-    this._release();
-  }
-  _release() {
-    if (--this.pending === 0) {
-      this.subtreeSettled = true;
-      this._subtreeResolve?.(this.val);
-    }
-  }
-};
-var Dispatcher = class {
-  constructor(path, transactor, parentTransaction, root = transactor.state.val) {
-    this.path = path;
-    this.transactor = transactor;
-    this.parent = parentTransaction;
-    this.root = root;
-  }
-  // Walk the component instances on this ctx's path, leaf→root, calling
-  // callback(Component, instance). Return false from the callback to stop early.
-  walkPath(callback) {
-    const comps = this.transactor.comps;
-    const chain = this.path.toTransactionPath().resolveChain(this.root);
-    for (let i = chain.length - 1; i >= 0; i--) {
-      const comp = comps.getCompFor(chain[i]);
-      if (comp && callback(comp, chain[i]) === false) return;
-    }
-  }
-  get at() {
-    return new PathChanges(this);
-  }
-  // A message is ADDRESSED: it names one component and stops there.
-  send(name, args, opts) {
-    return this.sendAtPath(this.path, name, args, opts);
-  }
-  sendAtPath(path, name, args, opts) {
-    return this.transactor.pushSend(path, name, args, opts, this.parent);
-  }
-  // An intent is ROUTED: it names a job and walks until something answers. The verb
-  // does not decide which scope answers — `opts.route` does, written here at the call
-  // site, which is where the decision actually is.
-  intent(name, args, opts) {
-    return this.intentAtPath(this.path, name, args, opts);
-  }
-  intentAtPath(path, name, args, opts) {
-    return this.transactor.pushIntent(path, name, args, opts, this.parent);
-  }
-  lookupTypeFor(name, inst) {
-    return this.transactor.comps.getCompFor(inst).scope.lookupComponent(name);
-  }
-};
-var EventContext = class extends Dispatcher {
-  get name() {
-    return this.parent?.name ?? null;
-  }
-  get targetPath() {
-    return this.parent.targetPath;
-  }
-  // Answer the intent being handled, with a result or with an error. Either ENDS the
-  // walk. Legal only in an `intent` handler: a message has no sender waiting on it.
-  reply(value) {
-    return this.parent.walk === void 0 ? warnNotIntent("reply") : this.parent.walk.answer("Ok", value);
-  }
-  fail(error) {
-    return this.parent.walk === void 0 ? warnNotIntent("fail") : this.parent.walk.answer("Error", error);
-  }
-  // End the walk answering nothing — "served, and no answer".
-  stop() {
-    return this.parent.stop();
-  }
-  // From an `intent` body: hand the intent to the next hop, optionally amending it.
-  // From a `receive` body: turn the message that arrived into an intent. One word from
-  // both ends of a walk; which one you get depends on which bucket you are in.
-  forward(opts) {
-    return this.parent.forward(opts);
-  }
-};
-var IntentContext = class extends Dispatcher {
-};
-function warnNotIntent(verb) {
-  console.warn(`ctx.${verb}() is only meaningful in an "intent" handler - ignored`);
-}
-var PathChanges = class extends PathBuilder {
-  constructor(dispatcher) {
-    super();
-    this.dispatcher = dispatcher;
-  }
-  send(name, args, opts) {
-    return this.dispatcher.sendAtPath(this.buildPath(), name, args, opts);
-  }
-  intent(name, args, opts) {
-    return this.dispatcher.intentAtPath(this.buildPath(), name, args, opts);
-  }
-  buildPath() {
-    return this.dispatcher.path.concat(this.pathChanges);
-  }
-};
-function rootDispatcher(transactor) {
-  return new Dispatcher(new Path([]), transactor, null);
-}
-
-// src/app.js
-var _evs = "dragstart dragover dragend touchstart touchmove touchend touchcancel".split(" ");
-var App = class {
-  constructor(rootNode, comps, renderer, ParseContext2) {
-    this.rootNode = rootNode;
-    this.comps = comps;
-    this.compStack = new ComponentStack(comps);
-    this.transactor = new Transactor(comps, null);
-    this.ParseContext = ParseContext2;
-    this.renderer = renderer;
-    this.maxEventNodeDepth = Infinity;
-    this._transactNextBatchId = this._evictCacheId = null;
-    this._eventNames = new Set(_evs);
-    this.dragInfo = this.curDragOver = null;
-    this._touch = null;
-    this.transactor.onTransactionPushed = (_transaction) => {
-      if (this._transactNextBatchId === null) this._scheduleNextTransactionBatchExecution();
-    };
-    this._compiled = false;
-    this._renderOpts = { document: rootNode.ownerDocument };
-    this._renderState = null;
-    this.rootViewName = null;
-  }
-  get state() {
-    return this.transactor.state;
-  }
-  handleEvent(e) {
-    const { type } = e;
-    if (type[0] === "t" && type.startsWith("touch")) {
-      this._handleTouchEvent(e);
-      return;
-    }
-    this._dispatchEvent(e);
-  }
-  _dispatchEvent(e) {
-    const { type } = e;
-    const isDrag = type === "dragover" || type === "dragstart" || type === "dragend" || type === "drop";
-    const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
-    const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
-    if (isDrag) this._handleDragEvent(e, type, path);
-    if (path !== null && handlers !== null)
-      for (const handler of handlers) transactor.transactInputNow(path, e, handler, this.dragInfo);
-  }
-  _handleTouchEvent(e) {
-    const { type } = e;
-    if (type === "touchstart") {
-      if (this._touch !== null || e.touches.length !== 1) return;
-      const t = e.touches[0];
-      const draggable = t.target?.closest?.('[draggable="true"]');
-      if (!draggable) return;
-      this._touch = makeTouchInfo(t.identifier, t.clientX, t.clientY, draggable, false);
-      return;
-    }
-    if (this._touch === null) return;
-    const touch = findTouch(e, this._touch.id);
-    if (touch === null) return;
-    const { rootNode, _touch } = this;
-    const { clientX, clientY } = touch;
-    const fire = (type2, target) => {
-      const e2 = { type: type2, target, clientX, clientY, preventDefault: NOOP };
-      this._dispatchEvent(e2);
-    };
-    if (type === "touchmove") {
-      if (!_touch.active) {
-        const dx = clientX - _touch.startX;
-        const dy = clientY - _touch.startY;
-        if (dx * dx + dy * dy < 100) return;
-        _touch.active = true;
-        e.preventDefault();
-        fire("dragstart", _touch.target);
-      } else {
-        e.preventDefault();
-        fire("dragover", hitTest(rootNode, clientX, clientY));
-      }
-      return;
-    }
-    if (type === "touchend" || type === "touchcancel") {
-      if (_touch.active) {
-        if (type === "touchend") fire("drop", hitTest(rootNode, clientX, clientY));
-        fire("dragend", _touch.target);
-      }
-      this._touch = null;
-    }
-  }
-  _handleDragEvent(e, type, path) {
-    if (type === "dragover") {
-      const dropTarget = getClosestDropTarget(e.target, this.rootNode, Infinity);
-      if (dropTarget !== null) {
-        e.preventDefault();
-        this._cleanDragOverAttrs();
-        this.curDragOver = dropTarget;
-        dropTarget.dataset.draggingover = this.dragInfo?.type ?? "_external";
-      }
-    } else if (type === "dragstart") {
-      e.target.dataset.dragging = 1;
-      const rootValue = this.state.val;
-      const txnPath = path.compact().toTransactionPath();
-      const value = txnPath.lookup(rootValue);
-      const dragType = e.target.dataset.dragtype ?? "?";
-      const stack = path.toTransactionPath().buildStack(this.makeStack(rootValue));
-      this.dragInfo = new DragInfo(txnPath, stack, e, value, dragType, e.target);
-    } else if (type === "drop") {
-      e.preventDefault();
-      this._cleanDragOverAttrs();
-    } else {
-      if (this.dragInfo !== null) {
-        delete this.dragInfo.node.dataset.dragging;
-        this.dragInfo = null;
-      }
-      this._cleanDragOverAttrs();
-    }
-  }
-  makeStack(rootValue) {
-    return Stack.root(this.comps, rootValue);
-  }
-  _cleanDragOverAttrs() {
-    if (this.curDragOver !== null) {
-      delete this.curDragOver.dataset.draggingover;
-      this.curDragOver = null;
-    }
-  }
-  render() {
-    const root = this.state.val;
-    const stack = this.makeStack(root);
-    const { renderer, rootNode, _renderOpts, _renderState } = this;
-    const newState = render(
-      renderer.renderRoot(stack, root, this.rootViewName),
-      rootNode,
-      _renderOpts,
-      _renderState
-    );
-    this._renderState = newState;
-    return newState.dom;
-  }
-  onChange(callback) {
-    this.transactor.state.onChange(callback);
-  }
-  // Subscribe to a normalized record for every handler invocation. Returns an
-  // unsubscribe function. See Transactor.observe.
-  observe(callback) {
-    return this.transactor.observe(callback);
-  }
-  compile() {
-    for (const Comp of this.comps.byId.values()) {
-      Comp.compile(this.ParseContext);
-      for (const key in Comp.views)
-        for (const name of Comp.views[key].ctx.genEventNames()) this._eventNames.add(name);
-    }
-    this._compiled = true;
-  }
-  subscribeToEvents(eventNames) {
-    for (const name of eventNames) this.rootNode.addEventListener(name, this, listenerOpts(name));
-  }
-  recompileStyles(opts) {
-    injectCss("tutuca-app", this.comps.compileStyles(), opts?.head ?? document.head);
-  }
-  start(opts) {
-    if (!this._compiled) this.compile();
-    this.subscribeToEvents(this._eventNames);
-    this.onChange((info) => {
-      if (info.val !== info.old) this.render();
-    });
-    this.recompileStyles(opts);
-    if (opts?.noCache) this.renderer.setNullCache();
-    else this.startCacheEvictionInterval();
-    this.render();
-  }
-  stop() {
-    this.stopCacheEvictionInterval();
-    for (const name of this._eventNames)
-      this.rootNode.removeEventListener(name, this, listenerOpts(name));
-  }
-  sendAtRoot(name, args, opts) {
-    this.transactor.pushSend(new Path([]), name, args, opts);
-  }
-  registerComponents(comps, opts) {
-    const scope = this.compStack.enter();
-    scope.registerComponents(comps, opts);
-    return scope;
-  }
-  _transactNextBatch(maxRunTimeMs = 10) {
-    this._transactNextBatchId = null;
-    const startTs = Date.now();
-    const t = this.transactor;
-    while (t.hasPendingTransactions && Date.now() - startTs < maxRunTimeMs) t.transactNext();
-    if (t.hasPendingTransactions) this._scheduleNextTransactionBatchExecution();
-  }
-  _scheduleNextTransactionBatchExecution() {
-    this._transactNextBatchId = setTimeout(() => this._transactNextBatch(), 0);
-  }
-  startCacheEvictionInterval(intervalMs = 3e4) {
-    this._evictCacheId = setInterval(() => this.renderer.cache.evict(), intervalMs);
-  }
-  stopCacheEvictionInterval() {
-    clearInterval(this._evictCacheId);
-    this._evictCacheId = null;
-  }
-};
-function injectCss(nodeId, style, styleTarget = document.head) {
-  const styleNode = document.createElement("style");
-  const currentNodeWithId = styleTarget.querySelector(`#${nodeId}`);
-  if (currentNodeWithId) styleTarget.removeChild(currentNodeWithId);
-  styleNode.id = nodeId;
-  styleNode.innerHTML = style;
-  styleTarget.appendChild(styleNode);
-}
-var NOOP = () => {
-};
-function findTouch(e, id) {
-  for (const t of e.changedTouches) if (t.identifier === id) return t;
-  for (const t of e.touches) if (t.identifier === id) return t;
-  return null;
-}
-var listenerOpts = (name) => name === "touchmove" ? { passive: false } : void 0;
-function makeTouchInfo(id, startX, startY, target, active) {
-  return { id, startX, startY, target, active };
-}
-function hitTest(rootNode, x, y) {
-  const root = rootNode.getRootNode();
-  let el = root.elementFromPoint?.(x, y) ?? null;
-  while (el?.shadowRoot) {
-    const next = el.shadowRoot.elementFromPoint(x, y);
-    if (next === null || next === el) break;
-    el = next;
-  }
-  return el ?? rootNode;
-}
-function getClosestDropTarget(target, rootNode, count) {
-  let node = target;
-  while (count-- > 0 && node !== rootNode) {
-    if (node.dataset?.droptarget !== void 0) return node;
-    node = node.parentNode;
-  }
-  return null;
-}
-var DragInfo = class {
-  constructor(path, stack, e, val, type, node) {
-    this.path = path;
-    this.stack = stack;
-    this.e = e;
-    this.val = val;
-    this.type = type;
-    this.node = node;
-  }
-  lookupBind(name) {
-    return this.stack.lookupBind(name);
-  }
-};
-
-// src/on.js
-var OP_KINDS = ["send", "intent"];
-function phaseOps(phase) {
-  const ops = [];
-  for (const type of OP_KINDS) for (const a of phase[type] ?? []) ops.push({ type, ...a });
-  for (const a of phase.do ?? []) ops.push(a);
-  return ops;
-}
-function resolveArgs(args, self) {
-  return typeof args === "function" ? args(self) ?? [] : args ?? [];
-}
-function dispatchPhase(dispatcher, targetPath, phase, self) {
-  if (!phase) return;
-  for (const op of phaseOps(phase)) {
-    const args = resolveArgs(op.args, self);
-    switch (op.type) {
-      case "send":
-        dispatcher.sendAtPath(targetPath, op.name, args, op.opts);
-        break;
-      case "intent":
-        dispatcher.intentAtPath(targetPath, op.name, args, op.opts);
-        break;
-    }
-  }
-}
-
-// index.js
-var css = String.raw;
-var html = String.raw;
-var macro = (defaults, rawView) => new Macro(defaults, rawView);
-function check2(_app) {
-  return { error: 0, warn: 0, hint: 0, dummyCheck: true };
-}
-async function test(_opts) {
-  return null;
-}
-function collectIterBindings() {
-  console.warn(
-    "collectIterBindings is a no-op in the core tutuca build; use the tutuca-dev build for a functional implementation"
-  );
-  return [];
-}
-function tutuca(nodeOrSelector) {
-  const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
-  const comps = new Components();
-  const renderer = new Renderer(comps);
-  return new App(rootNode, comps, renderer, ParseContext);
-}
-export {
-  FIELD_CLASS,
-  PASS,
-  ParseContext,
-  SEQ_INFO,
-  check2 as check,
-  collectIterBindings,
-  component,
-  css,
-  dispatchPhase,
-  html,
-  injectCss,
-  macro,
-  phaseOps,
-  resolveArgs,
-  rootDispatcher,
-  test,
-  tutuca
-};