@hyperfixi/engine 3.3.0

package/dist/common.js

@@ -0,0 +1,3020 @@
+"use strict";
+(() => {
+  // src/util.ts
+  var isP = (v) => typeof v === "object" && v !== null && "then" in v && typeof v.then === "function";
+  var then1 = (v, f) => isP(v) ? v.then(f) : f(v);
+  var all = (vals, f) => vals.some(isP) ? Promise.all(vals).then(f) : f(vals);
+  var obj = (v) => v != null;
+  var fn = (v) => typeof v === "function";
+  var get = (o, key) => obj(o) ? o[key] : void 0;
+  var set = (o, key, value) => {
+    if (obj(o)) o[key] = value;
+  };
+  var isEl = (v) => v instanceof Element;
+  var isTarget = (v) => fn(get(v, "addEventListener"));
+  var num = (v) => v;
+
+  // src/runtime.ts
+  var config = {
+    attributes: "_, script, data-script",
+    defaultTransition: "all 500ms ease-in",
+    disableSelector: "[disable-scripting], [data-disable-scripting]",
+    hideShowStrategies: {},
+    fetchThrowsOn: [/^4/, /^5/]
+  };
+  var conversions = Object.assign(/* @__PURE__ */ Object.create(null), {
+    String: (v) => String(v),
+    Int: (v) => parseInt(String(v)),
+    Float: (v) => parseFloat(String(v)),
+    Number: (v) => Number(v),
+    Fragment: (v) => toFragment(v)
+  });
+  var dynamicResolvers = [];
+  var host = {
+    process(_node) {
+    },
+    /** A scripted element is being initialised, or was found again. Templates use it. */
+    enter(_elt) {
+    }
+  };
+  var store = /* @__PURE__ */ new WeakMap();
+  var peekData = (elt) => store.get(elt);
+  var dropData = (elt) => store.delete(elt);
+  function dataOf(elt) {
+    let d = store.get(elt);
+    if (!d) store.set(elt, d = {});
+    return d;
+  }
+  var rx = {
+    /** True while an effect is evaluating: reads are then recorded as its dependencies. */
+    tracking: false,
+    readGlobal(_name) {
+    },
+    readElement(_name, _element) {
+    },
+    readProperty(_object, _name) {
+    },
+    readAttribute(_element, _name) {
+    },
+    /** A selector was queried under `root`: any DOM change inside it re-runs the reader. */
+    readQuery(_root) {
+    },
+    wroteGlobal(_name) {
+    },
+    wroteElement(_name, _element) {
+    },
+    /** A property was assigned, or the object was mutated in place. */
+    wroteProperty(_object) {
+    },
+    stop(_element) {
+    }
+  };
+  var tracked = (value) => {
+    if (rx.tracking && typeof value === "object" && value !== null)
+      rx.readProperty(value, "__mutation__");
+    return value;
+  };
+  var mutatingMethods = {
+    Array: ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"],
+    Set: ["add", "delete", "clear"],
+    Map: ["set", "delete", "clear"]
+  };
+  function maybeNotify(target, method) {
+    const type = get(get(target, "constructor"), "name");
+    if (typeof type === "string" && mutatingMethods[type]?.includes(method)) rx.wroteProperty(target);
+  }
+  var getRootNode = (node) => {
+    if (node instanceof Node) {
+      const root = node.getRootNode();
+      if (root instanceof Document || root instanceof ShadowRoot) return root;
+    }
+    return document;
+  };
+  var escapeSelector = (s) => s.replace(/[:&()[\]/]/g, (c) => "\\" + c);
+  function query(root, css) {
+    if (rx.tracking) rx.readQuery(root);
+    return root.querySelectorAll(css);
+  }
+  var ElementCollection = class {
+    constructor(raw, relativeTo, escape = false) {
+      this.raw = raw;
+      this.relativeTo = relativeTo;
+      this.escape = escape;
+    }
+    get css() {
+      return this.escape ? escapeSelector(this.raw) : this.raw;
+    }
+    get className() {
+      return this.raw.slice(1);
+    }
+    get length() {
+      return this.select().length;
+    }
+    contains(node) {
+      for (const e of this) if (e.contains(node)) return true;
+      return false;
+    }
+    select() {
+      return query(getRootNode(this.relativeTo), this.css);
+    }
+    [Symbol.iterator]() {
+      return this.select()[Symbol.iterator]();
+    }
+  };
+  var shouldAutoIterate = (v) => v instanceof ElementCollection || Array.isArray(v) || v instanceof NodeList || v instanceof HTMLCollection || v instanceof FileList;
+  function implicitLoop(value, f) {
+    if (shouldAutoIterate(value)) for (const v of value) f(v);
+    else f(value);
+  }
+  var flatGet = (root, getter) => {
+    if (root == null) return;
+    const value = getter(root);
+    if (value !== void 0) return value;
+    if (shouldAutoIterate(root)) return Array.from(root, getter);
+  };
+  var resolveProperty = (root, prop) => {
+    if (rx.tracking) rx.readProperty(root, prop);
+    return flatGet(root, (o) => get(o, prop));
+  };
+  var resolveAttribute = (root, name) => {
+    if (rx.tracking) rx.readAttribute(root, name);
+    return flatGet(root, (o) => isEl(o) ? o.getAttribute(name) : void 0);
+  };
+  var resolveStyle = (root, prop) => flatGet(root, (o) => get(get(o, "style"), prop));
+  var resolveComputedStyle = (root, prop) => flatGet(root, (o) => isEl(o) ? getComputedStyle(o).getPropertyValue(prop) : void 0);
+  var setAttribute = (target, name, value) => implicitLoop(target, (elt) => {
+    if (!isEl(elt)) return;
+    if (value == null) elt.removeAttribute(name);
+    else elt.setAttribute(name, String(value));
+  });
+  var setStyle = (target, prop, value) => implicitLoop(target, (elt) => set(get(elt, "style"), prop, value));
+  var setProperty = (target, prop, value) => implicitLoop(target, (elt) => {
+    set(elt, prop, value);
+    rx.wroteProperty(elt);
+  });
+  function nullCheck(value, source) {
+    if (value == null) throw new Error(`'${source}' is null`);
+  }
+  var isEmpty = (v) => v == null || get(v, "length") === 0;
+  function doesExist(v) {
+    if (v == null) return false;
+    if (shouldAutoIterate(v)) {
+      for (const _ of v) return true;
+      return false;
+    }
+    return true;
+  }
+  function typeCheck(value, typeName, nullOk) {
+    if (value == null && nullOk) return true;
+    if (Object.prototype.toString.call(value).slice(8, -1) === typeName) return true;
+    const ctor = get(globalThis, typeName);
+    return fn(ctor) && value instanceof ctor;
+  }
+  function convert(value, type) {
+    for (const resolver of dynamicResolvers) {
+      const converted = resolver(type, value);
+      if (converted !== void 0) return converted;
+    }
+    if (value == null) return null;
+    const conversion = conversions[type];
+    if (conversion) return conversion(value);
+    throw new Error("Unknown conversion : " + type);
+  }
+  function toFragment(value) {
+    const frag = document.createDocumentFragment();
+    if (value == null) frag.append("null");
+    else
+      implicitLoop(value, (v) => {
+        if (v instanceof Node) frag.append(v);
+        else {
+          const template = document.createElement("template");
+          template.innerHTML = v === null ? "" : String(v);
+          frag.append(template.content);
+        }
+      });
+    return frag;
+  }
+  function replaceInDom(target, value) {
+    implicitLoop(target, (elt) => {
+      if (!isEl(elt)) return;
+      const parent = elt.parentElement;
+      elt.replaceWith(value instanceof Node ? value.cloneNode(true) : toFragment(value));
+      if (parent) host.process(parent);
+    });
+  }
+  function triggerEvent(target, name, detail = {}, sender) {
+    if (!isTarget(target)) return true;
+    detail.sender = sender;
+    const event = Object.assign(
+      new Event(name, { bubbles: true, cancelable: true, composed: true }),
+      {
+        detail
+      }
+    );
+    return target.dispatchEvent(event);
+  }
+  var scopeOf = (elt, name = "elementScope") => (dataOf(elt).scopes ??= {})[name] ??= {};
+  var ambient = Object.create(null, {
+    selection: { get: () => getSelection()?.toString(), enumerable: true },
+    clipboard: {
+      get: () => navigator.clipboard.readText(),
+      set: (value) => void navigator.clipboard.writeText(String(value))
+    }
+  });
+  function makeContext(owner, feature2, me, event) {
+    const detail = get(event, "detail");
+    const locals = Object.create(ambient);
+    for (let elt = isEl(owner) ? owner : null; elt; elt = elt.parentElement) {
+      Object.assign(locals, peekData(elt)?.features);
+    }
+    return {
+      meta: { owner, feature: feature2 },
+      locals,
+      me,
+      you: void 0,
+      result: void 0,
+      beingTested: null,
+      event,
+      target: get(event, "target") ?? null,
+      detail: detail ?? null,
+      sender: get(detail, "sender") ?? null,
+      body: typeof document === "undefined" ? null : document.body
+    };
+  }
+  var RESERVED = ["meta", "it", "result", "locals", "event", "target", "detail", "sender", "body"];
+  var elementScope = (ctx) => {
+    const owner = ctx.meta.owner;
+    const behavior = ctx.meta.feature?.behavior;
+    return obj(owner) ? scopeOf(owner, behavior ? behavior + "Scope" : void 0) : {};
+  };
+  function inherited(name, ctx, start) {
+    let elt = isEl(start) ? start : isEl(ctx.meta.owner) ? ctx.meta.owner : null;
+    while (elt) {
+      const scope = peekData(elt)?.scopes?.elementScope;
+      if (scope && name in scope) return { value: scope[name], element: elt };
+      const domScope = elt.getAttribute("dom-scope");
+      if (domScope === "isolated") break;
+      const closest = domScope?.match(/^closest\s+(.+)/);
+      const parentOf = domScope?.match(/^parent\s+of\s+(.+)/);
+      if (closest) elt = elt.parentElement?.closest(closest[1]) ?? null;
+      else if (parentOf) elt = elt.closest(parentOf[1])?.parentElement ?? null;
+      else elt = elt.parentElement;
+    }
+    return { value: void 0, element: null };
+  }
+  function resolveSymbol(name, ctx, scope, target) {
+    if (name === "me" || name === "my" || name === "I") return ctx.me;
+    if (name === "it" || name === "its") return ctx.beingTested ?? ctx.result;
+    if (name === "result") return ctx.result;
+    if (name === "you" || name === "your" || name === "yourself") return ctx.you;
+    const owner = ctx.meta.owner;
+    const global = () => {
+      if (rx.tracking) rx.readGlobal(name);
+      return tracked(get(globalThis, name));
+    };
+    if (scope === "global") return global();
+    if (scope === "element") {
+      if (rx.tracking) rx.readElement(name, owner);
+      return tracked(elementScope(ctx)[name]);
+    }
+    if (scope === "inherited") {
+      const found = inherited(name, ctx, target);
+      if (rx.tracking) rx.readElement(name, found.element ?? (isEl(target) ? target : owner));
+      return tracked(found.value);
+    }
+    const filterContext = ctx.meta.context;
+    if (filterContext != null) {
+      const fromEvent = get(filterContext, name);
+      if (fromEvent !== void 0) return fromEvent;
+      const fromDetail = get(get(filterContext, "detail"), name);
+      if (fromDetail !== void 0) return fromDetail;
+    }
+    const local = RESERVED.includes(name) ? get(ctx, name) : ctx.locals[name];
+    if (local !== void 0) return local;
+    const fromElement = elementScope(ctx)[name];
+    if (fromElement !== void 0) {
+      if (rx.tracking) rx.readElement(name, owner);
+      return tracked(fromElement);
+    }
+    return global();
+  }
+  function setSymbol(name, ctx, scope, value, target) {
+    if (scope === "global") {
+      set(globalThis, name, value);
+      rx.wroteGlobal(name);
+    } else if (scope === "element") {
+      elementScope(ctx)[name] = value;
+      rx.wroteElement(name, ctx.meta.owner);
+    } else if (scope === "inherited") {
+      const found = inherited(name, ctx, target).element;
+      const owner = found ?? (isEl(target) ? target : ctx.meta.owner);
+      if (obj(owner)) scopeOf(owner)[name] = value;
+      rx.wroteElement(name, owner);
+    } else if (!RESERVED.includes(name) && ctx.locals[name] !== void 0) {
+      ctx.locals[name] = value;
+    } else if (elementScope(ctx)[name] !== void 0) {
+      elementScope(ctx)[name] = value;
+      rx.wroteElement(name, ctx.meta.owner);
+    } else if (!RESERVED.includes(name)) {
+      ctx.locals[name] = value;
+    } else set(ctx, name, value);
+  }
+  function runList(cmds, ctx, from = 0) {
+    for (let i = from; i < cmds.length; i++) {
+      const result = cmds[i].run(ctx);
+      if (isP(result)) return result.then((signal) => signal || runList(cmds, ctx, i + 1));
+      if (result) return result;
+    }
+  }
+  function guard(f, rescue) {
+    try {
+      const result = f();
+      return isP(result) ? result.then(void 0, rescue) : result;
+    } catch (e) {
+      return rescue(e);
+    }
+  }
+  function runBlock(ctx, body, handlers) {
+    const { errorSymbol, errorHandler, finallyHandler } = handlers;
+    const main = () => guard(
+      () => then1(runList(body, ctx), (signal) => {
+        const kind = get(signal, "k");
+        if (kind === "break" || kind === "continue") {
+          throw new Error(`Command \`${kind}\` cannot be used outside of a \`repeat\` loop.`);
+        }
+        return signalOf(signal);
+      }),
+      (error) => {
+        if (!errorHandler || !errorSymbol) throw error;
+        ctx.locals[errorSymbol] = error;
+        return runList(errorHandler, ctx);
+      }
+    );
+    if (!finallyHandler) return main();
+    const cleanUp = () => guard(
+      () => then1(runList(finallyHandler, ctx), () => {
+      }),
+      (error) => console.error(" Exception in finally block: ", error)
+    );
+    return guard(
+      () => then1(main(), (signal) => then1(cleanUp(), () => signalOf(signal))),
+      (error) => then1(cleanUp(), () => {
+        throw error;
+      })
+    );
+  }
+  var signalOf = (v) => {
+    const kind = get(v, "k");
+    if (kind === "return") return { k: "return", value: get(v, "value") };
+    if (kind === "break" || kind === "continue") return { k: kind };
+  };
+  function implicitLoopWhen(targets, when, ctx, yes, no) {
+    const elements = [];
+    implicitLoop(targets, (elt) => elements.push(elt));
+    const conditions = elements.map((elt) => {
+      ctx.beingTested = elt;
+      return when.ev(ctx);
+    });
+    ctx.beingTested = null;
+    const apply = (results) => {
+      ctx.result = elements.filter((elt, i) => {
+        (results[i] ? yes : no)(elt);
+        return results[i];
+      });
+    };
+    return conditions.some(isP) ? Promise.all(conditions).then(apply) : apply(conditions);
+  }
+
+  // src/tokenizer.ts
+  var OPS = new Set(
+    "+ - * / . .. \\ : % | ! ? # & $ ; , ( ) < > <= >= == === != !== { } [ ] = ~ ^".split(" ")
+  );
+  var ESCAPES = { b: "\b", f: "\f", n: "\n", r: "\r", t: "	", v: "\v" };
+  var alpha = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+  var digit = (c) => c >= "0" && c <= "9";
+  var space = (c) => c === " " || c === "	" || c === "\r" || c === "\n";
+  var cssChar = (c) => alpha(c) || digit(c) || c === "-" || c === "_" || c === ":";
+  var identChar = (c) => alpha(c) || digit(c) || c === "_" || c === "$";
+  function tokenize(src, template = false) {
+    const tokens = [];
+    let pos = 0;
+    let column = 0;
+    let line = 1;
+    let last = "<START>";
+    let braces = 0;
+    const cur = () => src.charAt(pos);
+    const at = (offset) => src.charAt(pos + offset);
+    const eat = () => {
+      last = src.charAt(pos++);
+      if (last === "\n") {
+        line++;
+        column = 0;
+      } else column++;
+      return last;
+    };
+    const make = (type) => ({
+      type,
+      value: "",
+      start: pos,
+      end: pos + 1,
+      line,
+      column
+    });
+    const done = (token, value) => {
+      token.value = value;
+      token.end = pos;
+      return token;
+    };
+    const eatWhile = (test) => {
+      let value = "";
+      while (cur() && test(cur())) value += eat();
+      return value;
+    };
+    const inTemplate = () => template && braces === 0;
+    const afterValue = () => alpha(last) || digit(last) || ")\"'`}]".includes(last);
+    const reference = (type, keepBrace) => {
+      const token = make(type);
+      let value = eat();
+      if (cur() === "{") {
+        token.template = true;
+        value += eat();
+        value += eatWhile((c) => c !== "}");
+        if (cur() !== "}")
+          throw new Error("Unterminated " + (keepBrace ? "class" : "id") + " reference");
+        const brace = eat();
+        if (keepBrace) value += brace;
+      } else if (keepBrace) {
+        while (cssChar(cur()) || cur() === "\\") {
+          if (cur() === "\\") eat();
+          value += eat();
+        }
+      } else value += eatWhile(cssChar);
+      return done(token, value);
+    };
+    const string2 = () => {
+      const token = make("STRING");
+      const quote = eat();
+      token.template = quote === "`";
+      let value = "";
+      while (cur() && cur() !== quote) {
+        if (cur() === "\\") {
+          eat();
+          const next = eat();
+          if (next in ESCAPES) value += ESCAPES[next];
+          else if (token.template && next === "$") value += "\\$";
+          else if (next === "x") {
+            const hex = cur() && at(1) ? parseInt(eat() + eat(), 16) : NaN;
+            if (Number.isNaN(hex)) {
+              throw new Error(
+                `Invalid hexadecimal escape at [Line: ${token.line}, Column: ${token.column}]`
+              );
+            }
+            value += String.fromCharCode(hex);
+          } else value += next;
+        } else value += eat();
+      }
+      if (cur() !== quote) {
+        throw new Error(`Unterminated string at [Line: ${token.line}, Column: ${token.column}]`);
+      }
+      eat();
+      return done(token, value);
+    };
+    const identifier = () => {
+      const token = make("IDENTIFIER");
+      let value = eat() + eatWhile(identChar);
+      if (cur() === "!" && value === "beep") value += eat();
+      return done(token, value);
+    };
+    const templateIdentifier = () => {
+      const token = make("IDENTIFIER");
+      let value = eat();
+      let escaped = value === "\\";
+      if (escaped) value = "";
+      while (identChar(cur()) || "\\{}".includes(cur() || " ")) {
+        if (cur() === "$" && !escaped) break;
+        if (cur() === "\\") {
+          escaped = true;
+          eat();
+        } else {
+          escaped = false;
+          value += eat();
+        }
+      }
+      return done(token, value);
+    };
+    const number = () => {
+      const token = make("NUMBER");
+      let value = eat() + eatWhile(digit);
+      if (cur() === "." && digit(at(1))) value += eat();
+      value += eatWhile(digit);
+      if (cur() === "e" || cur() === "E") {
+        if (digit(at(1))) value += eat();
+        else if (at(1) === "-") value += eat() + eat();
+      }
+      return done(token, value + eatWhile(digit));
+    };
+    const op = () => {
+      const token = make("OP");
+      token.op = true;
+      let value = eat();
+      while (cur() && OPS.has(value + cur())) value += eat();
+      return done(token, value);
+    };
+    const attributeRef2 = () => {
+      const token = make("ATTRIBUTE_REF");
+      let value = eat();
+      if (value === "[") {
+        value += eatWhile((c) => c !== "]");
+        if (cur() === "]") value += eat();
+      } else {
+        value += eatWhile(cssChar);
+        if (cur() === "=") {
+          value += eat();
+          if (cur() === '"' || cur() === "'") value += string2().value;
+          else if (identChar(cur())) value += identifier().value;
+        }
+      }
+      return done(token, value);
+    };
+    const quoteStartsString = () => {
+      const prev = tokens.at(-1);
+      if (!prev) return true;
+      if (prev.type === "IDENTIFIER" || prev.type === "CLASS_REF" || prev.type === "ID_REF")
+        return false;
+      return !(prev.op && (prev.value === ">" || prev.value === ")"));
+    };
+    const isComment = () => {
+      const c = cur();
+      const end = at(2);
+      return (c === "-" || c === "/") && at(1) === c && (space(end) || end === "" || end === c);
+    };
+    while (pos < src.length) {
+      const c = cur();
+      const next = at(1);
+      if (isComment()) {
+        eatWhile((ch) => ch !== "\r" && ch !== "\n");
+        eat();
+      } else if (space(c)) {
+        tokens.push(done(make("WHITESPACE"), eatWhile(space)));
+      } else if (!afterValue() && c === "." && (alpha(next) || next === "{" || next === "-")) {
+        tokens.push(reference("CLASS_REF", true));
+      } else if (!afterValue() && c === "#" && (alpha(next) || next === "{")) {
+        tokens.push(reference("ID_REF", false));
+      } else if (c === "@" || c === "[" && next === "@") {
+        tokens.push(attributeRef2());
+      } else if (c === "*" && alpha(next)) {
+        const token = make("STYLE_REF");
+        tokens.push(done(token, eat() + eatWhile((ch) => alpha(ch) || ch === "-")));
+      } else if (inTemplate() && (alpha(c) || c === "\\")) {
+        tokens.push(templateIdentifier());
+      } else if (!inTemplate() && (alpha(c) || c === "_" || c === "$")) {
+        tokens.push(identifier());
+      } else if (digit(c)) {
+        tokens.push(number());
+      } else if (!inTemplate() && (c === '"' || c === "`")) {
+        tokens.push(string2());
+      } else if (!inTemplate() && c === "'") {
+        tokens.push(quoteStartsString() ? string2() : op());
+      } else if (OPS.has(c)) {
+        if (last === "$" && c === "{") braces++;
+        if (c === "}") braces--;
+        tokens.push(op());
+      } else if (inTemplate() || c === "`") {
+        const token = make("RESERVED");
+        tokens.push(done(token, eat()));
+      } else {
+        throw new Error("Unknown token: " + c + " ");
+      }
+    }
+    return tokens;
+  }
+
+  // src/expressions.ts
+  function expr(p) {
+    p.match("the");
+    return logical(p);
+  }
+  function logical(p) {
+    let left = comparison(p);
+    let first;
+    const next = () => p.match("and") ?? p.match("or");
+    for (let t = next(); t; t = next()) {
+      first ??= t.value;
+      if (first !== t.value)
+        p.err("You must parenthesize logical operations with different operators");
+      left = logicalNode(t.value, left, comparison(p));
+    }
+    return left;
+  }
+  function logicalNode(operator, left, right) {
+    const or = operator === "or";
+    return {
+      type: "logicalOperator",
+      operator,
+      left,
+      right,
+      start: left.start,
+      end: right.end,
+      // Short-circuits, and stays synchronous unless an operand is a promise.
+      ev: (ctx) => then1(left.ev(ctx), (l) => !!l === or ? l : right.ev(ctx))
+    };
+  }
+  var MATH = {
+    "+": (a, b) => Array.isArray(a) ? a.concat(b) : num(a) + num(b),
+    "-": (a, b) => num(a) - num(b),
+    "*": (a, b) => num(a) * num(b),
+    "/": (a, b) => num(a) / num(b),
+    mod: (a, b) => num(a) % num(b)
+  };
+  function math(p) {
+    let left = collection(p);
+    let first;
+    const next = () => p.matchAnyOp("+", "-", "*", "/") ?? p.match("mod");
+    for (let t = next(); t; t = next()) {
+      first ??= t.value;
+      if (first !== t.value) p.err("You must parenthesize math operations with different operators");
+      const l = left;
+      const r = collection(p);
+      const op = MATH[t.value];
+      const node = {
+        type: "mathOperator",
+        operator: t.value,
+        left: l,
+        right: r,
+        start: l.start,
+        end: r.end,
+        ev: (ctx) => all([l.ev(ctx), r.ev(ctx)], ([a, b]) => op(a, b))
+      };
+      left = node;
+    }
+    return left;
+  }
+  function collection(p) {
+    let root = unary(p);
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const rule of p.g.collections) {
+        const next = rule(p, root);
+        if (next) {
+          root = next;
+          changed = true;
+          break;
+        }
+      }
+    }
+    return root;
+  }
+  function unary(p) {
+    p.match("the");
+    const start = p.pos();
+    if (p.match("not")) return unaryNode(p, "logicalNot", start, unary(p), (v) => !v);
+    if (p.match("no")) return unaryNode(p, "noExpression", start, collection(p), isEmpty);
+    for (const rule of p.g.unaries) {
+      const node = rule(p);
+      if (node) return indirect(p, node);
+    }
+    return postfix(p);
+  }
+  function unaryNode(p, type, start, root, f, chain = type !== "negativeNumber") {
+    const node = {
+      type,
+      root,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => then1(root.ev(ctx), (v) => f(v, ctx))
+    };
+    return chain ? indirect(p, node) : node;
+  }
+  var UNITS = "em ex cap ch ic rem lh rlh vw vh vi vb vmin vmax cm mm Q pc pt px".split(" ");
+  function postfix(p) {
+    const root = negative(p);
+    const unit = p.matchAny(...UNITS) ?? p.matchOp("%");
+    if (unit) return postfixNode(p, "stringPostfixExpression", root, unit.value);
+    const factor = p.matchAny("s", "seconds") ? 1e3 : p.matchAny("ms", "milliseconds") ? 1 : 0;
+    if (factor) return postfixNode(p, "timeExpression", root, factor);
+    for (const rule of p.g.postfixes) {
+      const node = rule(p, root);
+      if (node) return node;
+    }
+    return root;
+  }
+  function postfixNode(p, type, root, suffix) {
+    const apply = (v) => typeof suffix === "number" ? num(v) * suffix : `${v}${suffix}`;
+    const node = {
+      type,
+      root,
+      suffix,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => then1(root.ev(ctx), apply)
+    };
+    if (root.stat) node.stat = () => apply(evalStatic(root));
+    return node;
+  }
+  function negative(p) {
+    const start = p.pos();
+    if (p.matchOp("-")) return unaryNode(p, "negativeNumber", start, negative(p), (v) => -num(v));
+    return primary(p);
+  }
+  function primary(p) {
+    const node = leaf(p);
+    if (node) return indirect(p, node);
+    return p.err("Unexpected value: " + p.cur().value);
+  }
+  function assignable(p) {
+    p.match("the");
+    return writable(p, primary(p));
+  }
+  function writable(p, node) {
+    const inner = unwrap(node);
+    if (!inner.put) {
+      p.err(`A target expression must be writable.  The expression type '${inner.type}' is not.`);
+    }
+    return inner;
+  }
+  function unwrap(node) {
+    let inner = node;
+    while (inner.type === "parenthesized" && "expr" in inner && isExpr(inner.expr))
+      inner = inner.expr;
+    return inner;
+  }
+  var isExpr = (v) => fn(get(v, "ev"));
+  function evalStatic(node) {
+    if (node.stat) return node.stat();
+    throw new Error("This expression cannot be evaluated statically: " + node.type);
+  }
+  function comparisonOperator(p) {
+    const symbol2 = p.matchAnyOp("<", ">", "<=", ">=", "==", "===", "!=", "!==");
+    if (symbol2) return { operator: symbol2.value, right: true, isType: false };
+    const is = (operator, right = true, isType = false) => ({ operator, right, isType });
+    const equalTo = () => p.match("equal") && p.match("to");
+    const orEqual = (strict, loose) => {
+      p.req("than");
+      if (!p.match("or")) return is(strict);
+      p.req("equal");
+      p.req("to");
+      return is(loose);
+    };
+    if (p.match("is") || p.match("am")) {
+      const not2 = !!p.match("not");
+      const prefix2 = not2 ? "not " : "";
+      if (p.match("in")) return is(prefix2 + "in");
+      if (p.match("a") || p.match("an")) return is(prefix2 + "a", false, true);
+      if (p.match("empty")) return is(prefix2 + "empty", false);
+      if (p.match("between")) return is(prefix2 + "between");
+      if (!not2 && p.match("less")) return orEqual("<", "<=");
+      if (!not2 && p.match("greater")) return orEqual(">", ">=");
+      if (p.match("really")) {
+        equalTo();
+        return is(not2 ? "!==" : "===");
+      }
+      if (p.match("equal")) {
+        p.match("to");
+        return is(not2 ? "!=" : "==");
+      }
+      return is(not2 ? "is not" : "is");
+    }
+    if (p.match("equals")) return is("==");
+    if (p.match("really")) {
+      p.req("equals");
+      return is("===");
+    }
+    if (p.matchAny("exist", "exists")) return is("exist", false);
+    const not = !!p.matchAny("do", "does");
+    if (not) p.req("not");
+    const prefix = not ? "not " : "";
+    const verb = (bare, third) => p.match(bare) ?? (not && bare !== "match" && bare !== "contain" ? void 0 : p.match(third));
+    if (verb("match", "matches")) return is(prefix + "match");
+    if (verb("contain", "contains")) return is(prefix + "contain");
+    if (not && p.match("exist")) return is("not exist", false);
+    if (verb("include", "includes")) return is(prefix + "include");
+    if (p.match(not ? "start" : "starts")) {
+      p.req("with");
+      return is(prefix + "start with");
+    }
+    if (p.match(not ? "end" : "ends")) {
+      p.req("with");
+      return is(prefix + "end with");
+    }
+    if (verb("precede", "precedes")) return is(prefix + "precede");
+    if (verb("follow", "follows")) return is(prefix + "follow");
+    if (not) p.expected("matches", "contains", "starts with", "ends with", "precede", "follow");
+  }
+  function comparison(p) {
+    const left = math(p);
+    const op = comparisonOperator(p);
+    if (!op) return left;
+    const { operator } = op;
+    let typeName;
+    let nullOk = true;
+    let right;
+    let css;
+    if (op.isType) {
+      typeName = p.reqType("IDENTIFIER").value;
+      nullOk = !p.matchOp("!");
+    } else if (op.right) {
+      right = math(p);
+      if (operator.endsWith("match")) css = right.css;
+    }
+    let right2;
+    if (operator.endsWith("between")) {
+      p.req("and");
+      right2 = math(p);
+    }
+    let ignoringCase = false;
+    if (p.match("ignoring")) {
+      p.req("case");
+      ignoringCase = true;
+    }
+    const lower = (v) => ignoringCase && typeof v === "string" ? v.toLowerCase() : v;
+    const flag = right?.type === "symbol" && "scope" in right && right.scope === "local" && right.name !== "undefined" && right.name !== "null" ? right.name : void 0;
+    const node = {
+      type: "comparisonOperator",
+      operator,
+      left,
+      right,
+      right2,
+      typeName,
+      ignoringCase,
+      start: left.start,
+      end: p.endPos(),
+      ev: (ctx) => all([left.ev(ctx), css ?? right?.ev(ctx), right2?.ev(ctx)], ([l, r, r2]) => {
+        if (typeName) {
+          const ok = typeCheck(l, typeName, nullOk);
+          return operator === "a" ? ok : !ok;
+        }
+        if (flag && r === void 0 && (operator === "is" || operator === "is not")) {
+          const set3 = !!resolveProperty(l, flag);
+          return operator === "is" ? set3 : !set3;
+        }
+        return compare(operator, lower(l), lower(r), r2);
+      })
+    };
+    return node;
+  }
+  function contains(container, value) {
+    const method = get(container, "contains") ?? get(container, "includes");
+    if (!fn(method)) throw new Error("The value does not have a contains or includes method on it");
+    return !!Reflect.apply(method, container, [value]);
+  }
+  function matches(target, pattern) {
+    const method = get(target, "match") ?? get(target, "matches");
+    if (!fn(method)) throw new Error("The value does not have a match or matches method on it");
+    return !!Reflect.apply(method, target, [pattern]);
+  }
+  var position = (a, b, bit) => a instanceof Node && b instanceof Node && (a.compareDocumentPosition(b) & bit) !== 0;
+  function compare(operator, l, r, r2) {
+    if (operator === "not between") return num(l) < num(r) || num(l) > num(r2);
+    if (operator.startsWith("not ")) return !compare(operator.slice(4), l, r, r2);
+    switch (operator) {
+      case "is":
+      case "==":
+        return l == r;
+      case "is not":
+      case "!=":
+        return l != r;
+      case "===":
+        return l === r;
+      case "!==":
+        return l !== r;
+      case "<":
+        return num(l) < num(r);
+      case ">":
+        return num(l) > num(r);
+      case "<=":
+        return num(l) <= num(r);
+      case ">=":
+        return num(l) >= num(r);
+      case "match":
+        return l != null && matches(l, r);
+      case "in":
+        return r != null && contains(r, l);
+      case "contain":
+      case "include":
+        return l != null && contains(l, r);
+      case "start with":
+        return l != null && String(l).startsWith(String(r));
+      case "end with":
+        return l != null && String(l).endsWith(String(r));
+      case "between":
+        return num(l) >= num(r) && num(l) <= num(r2);
+      case "precede":
+        return position(l, r, Node.DOCUMENT_POSITION_FOLLOWING);
+      case "follow":
+        return position(l, r, Node.DOCUMENT_POSITION_PRECEDING);
+      case "empty":
+        return isEmpty(l);
+      case "exist":
+        return doesExist(l);
+    }
+    throw new Error("Unknown comparison : " + operator);
+  }
+  function leaf(p) {
+    const t = p.cur();
+    switch (t.type) {
+      case "NUMBER":
+        p.consume();
+        return literal("number", parseFloat(t.value), t);
+      case "STRING":
+        return string(p);
+      case "ID_REF":
+        return idRef(p);
+      case "CLASS_REF":
+        return classRef(p);
+      case "ATTRIBUTE_REF":
+        return attributeRef(p);
+      case "STYLE_REF":
+        return styleRef(p);
+    }
+    if (t.op) {
+      if (t.value === "(") return paren(p);
+      if (t.value === "[") return arrayLiteral(p);
+      if (t.value === "{") return objectLiteral(p);
+      if (t.value === "<") return queryRef(p);
+    }
+    const bool = p.match("true") ?? p.match("false");
+    if (bool) return literal("boolean", bool.value === "true", bool);
+    const nil = p.match("null");
+    if (nil) return literal("null", null, nil);
+    for (const rule of p.g.leaves) {
+      const node = rule(p);
+      if (node) return node;
+    }
+    return symbol(p);
+  }
+  function literal(type, value, t) {
+    return { type, value, start: t.start, end: t.end, ev: () => value, stat: () => value };
+  }
+  function paren(p) {
+    const start = p.pos();
+    p.consume();
+    const inner = p.withoutFollows(() => expr(p));
+    p.reqOp(")");
+    return { type: "parenthesized", expr: inner, start, end: p.endPos(), ev: (ctx) => inner.ev(ctx) };
+  }
+  var interpolate = (parts, ctx) => all(
+    parts.map((part) => typeof part === "string" ? part : part.ev(ctx)),
+    (values) => values.map((v) => v === void 0 ? "" : `${v}`).join("")
+  );
+  function templateParts(p, raw) {
+    const inner = p.child(tokenize(raw, true), raw);
+    const parts = [];
+    let text = "";
+    do {
+      text += inner.lastWs();
+      const t = inner.cur();
+      if (t.value === "$") {
+        inner.consume();
+        const brace = inner.matchOp("{");
+        parts.push(text, expr(inner));
+        text = "";
+        if (brace) inner.reqOp("}");
+      } else if (t.value === "\\") {
+        inner.consume();
+        inner.consume();
+      } else if (inner.hasMore()) {
+        text += inner.consume().value;
+      }
+    } while (inner.hasMore());
+    parts.push(text + inner.lastWs());
+    return parts;
+  }
+  function string(p) {
+    const t = p.consume();
+    const value = t.value;
+    const node = { type: "string", value, start: t.start, end: t.end, ev: () => value };
+    if (t.template) {
+      const parts = node.parts = templateParts(p, value);
+      node.ev = (ctx) => interpolate(parts, ctx);
+    } else node.stat = () => value;
+    return node;
+  }
+  function arrayLiteral(p) {
+    const start = p.pos();
+    p.consume();
+    const values = [];
+    if (!p.matchOp("]")) {
+      do
+        values.push(expr(p));
+      while (p.matchOp(","));
+      p.reqOp("]");
+    }
+    return {
+      type: "arrayLiteral",
+      values,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => all(
+        values.map((v) => v.ev(ctx)),
+        (vals) => vals
+      )
+    };
+  }
+  function objectLiteral(p) {
+    const start = p.pos();
+    p.consume();
+    const keys = [];
+    const values = [];
+    const atClose = () => p.cur().op && p.cur().value === "}";
+    if (!p.matchOp("}")) {
+      do {
+        const quoted = p.matchType("STRING");
+        if (quoted) keys.push(quoted.value);
+        else if (p.matchOp("[")) {
+          keys.push(expr(p));
+          p.reqOp("]");
+        } else {
+          let key = "";
+          for (let t = p.matchType("IDENTIFIER") ?? p.matchOp("-"); t; t = p.matchType("IDENTIFIER") ?? p.matchOp("-")) {
+            key += t.value;
+          }
+          keys.push(key);
+        }
+        p.reqOp(":");
+        values.push(expr(p));
+      } while (p.matchOp(",") && !atClose());
+      p.reqOp("}");
+    }
+    return {
+      type: "objectLiteral",
+      keys,
+      values,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => all(
+        [...keys.map((k) => typeof k === "string" ? k : k.ev(ctx)), ...values.map((v) => v.ev(ctx))],
+        (vals) => Object.fromEntries(keys.map((_, i) => [String(vals[i]), vals[keys.length + i]]))
+      )
+    };
+  }
+  function namedArgumentList(p) {
+    if (!p.matchOp("(")) return;
+    const start = p.last.start;
+    const node = nakedNamedArguments(p, start);
+    p.reqOp(")");
+    node.end = p.endPos();
+    return node;
+  }
+  function nakedNamedArguments(p, start = p.pos()) {
+    const names = [];
+    const values = [];
+    if (p.cur().type === "IDENTIFIER") {
+      do {
+        names.push(p.reqType("IDENTIFIER").value);
+        p.reqOp(":");
+        values.push(expr(p));
+      } while (p.matchOp(","));
+    }
+    return {
+      type: "namedArgumentList",
+      names,
+      values,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => all(
+        values.map((v) => v.ev(ctx)),
+        (vals) => Object.fromEntries([
+          ["_namedArgList_", true],
+          ...names.map((n, i) => [n, vals[i]])
+        ])
+      )
+    };
+  }
+  function stringLike(p) {
+    return p.matchType("STRING")?.value ?? p.consumeUntil(void 0, "WHITESPACE").map((t) => t.value).join("");
+  }
+  function symbol(p) {
+    const start = p.pos();
+    let declared;
+    if (p.match("global")) declared = "global";
+    else if (p.match("element")) {
+      declared = "element";
+      if (p.matchOp("'")) p.req("s");
+    } else if (p.match("dom")) declared = "inherited";
+    else if (p.match("local")) declared = "local";
+    const colon = p.matchOp(":");
+    const caret = !colon && p.matchOp("^");
+    const id = p.matchType("IDENTIFIER");
+    if (!id?.value) return;
+    const name = (colon ? ":" : caret ? "^" : "") + id.value;
+    const prefixes = { $: "global", ":": "element", "^": "inherited" };
+    const scope = declared ?? prefixes[name[0]] ?? "local";
+    let on2;
+    if (scope === "inherited" && p.match("on")) {
+      on2 = p.withFollow(["to", "into", "before", "after", "then"], () => expr(p));
+    }
+    return {
+      type: "symbol",
+      name,
+      scope,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => resolveSymbol(name, ctx, scope, on2?.ev(ctx)),
+      lhs: () => void 0,
+      put: (ctx, _lhs, value) => setSymbol(name, ctx, scope, value, on2?.ev(ctx))
+    };
+  }
+  var templated = (p, t) => {
+    const raw = t.value.substring(2);
+    return expr(p.child(tokenize(raw), raw));
+  };
+  function idRef(p) {
+    const t = p.consume();
+    const find = (ctx, id) => getRootNode(ctx.me).getElementById(String(id));
+    const node = {
+      type: "idRef",
+      start: t.start,
+      end: t.end,
+      ev: () => null,
+      lhs: () => void 0,
+      put: (ctx, _lhs, value) => then1(node.ev(ctx), (target) => target && replaceInDom(target, value))
+    };
+    if (t.template) {
+      const inner = node.expr = templated(p, t);
+      node.ev = (ctx) => then1(inner.ev(ctx), (id) => find(ctx, id));
+    } else {
+      const id = node.value = t.value.substring(1);
+      node.css = t.value;
+      node.ev = (ctx) => find(ctx, id);
+    }
+    return node;
+  }
+  function classRef(p) {
+    const t = p.matchType("CLASS_REF");
+    if (!t) return;
+    const node = {
+      type: "classRef",
+      start: t.start,
+      end: t.end,
+      ev: () => null,
+      lhs: () => void 0,
+      put: (ctx, _lhs, value) => then1(
+        node.ev(ctx),
+        (c) => replaceInDom(Array.from(c instanceof ElementCollection ? c : []), value)
+      )
+    };
+    if (t.template) {
+      const inner = node.expr = templated(p, t);
+      node.ev = (ctx) => then1(inner.ev(ctx), (name) => new ElementCollection("." + name, ctx.me, true));
+    } else {
+      const css = node.css = t.value;
+      node.className = css.slice(1);
+      node.ev = (ctx) => new ElementCollection(css, ctx.me, true);
+    }
+    return node;
+  }
+  var TemplatedQuery = class extends ElementCollection {
+    constructor(relativeTo, parts) {
+      super("", relativeTo);
+      this.parts = parts;
+    }
+    get css() {
+      let i = 0;
+      return this.parts.map((part) => isEl(part) ? `[data-hs-query-id='${i++}']` : `${part ?? ""}`).join("");
+    }
+    select() {
+      const elements = this.parts.filter(isEl);
+      elements.forEach((e, i) => e.setAttribute("data-hs-query-id", String(i)));
+      const found = super.select();
+      elements.forEach((e) => e.removeAttribute("data-hs-query-id"));
+      return found;
+    }
+  };
+  function queryRef(p) {
+    const start = p.pos();
+    p.consume();
+    const css = p.consumeUntil("/").map((t) => t.type === "STRING" ? `"${t.value}"` : t.value).join("");
+    p.reqOp("/");
+    p.reqOp(">");
+    const node = {
+      type: "queryRef",
+      css,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => new ElementCollection(css, ctx.me),
+      lhs: () => void 0,
+      put: (ctx, _lhs, value) => then1(
+        node.ev(ctx),
+        (c) => replaceInDom(Array.from(c instanceof ElementCollection ? c : []), value)
+      )
+    };
+    if (/\$[^=]/.test(css)) {
+      const parts = node.parts = templateParts(p, css);
+      node.ev = (ctx) => all(
+        parts.map((part) => typeof part === "string" ? part : part.ev(ctx)),
+        (values) => new TemplatedQuery(ctx.me, values)
+      );
+    }
+    return node;
+  }
+  function attributeRef(p) {
+    const t = p.matchType("ATTRIBUTE_REF");
+    if (!t) return;
+    const inner = t.value.startsWith("[") ? t.value.slice(2, -1) : t.value.slice(1);
+    const [name, quoted] = inner.split("=");
+    const value = quoted && /^["']/.test(quoted) ? quoted.slice(1, -1) : quoted;
+    return {
+      type: "attributeRef",
+      name,
+      value,
+      css: `[${inner}]`,
+      start: t.start,
+      end: t.end,
+      ev: (ctx) => resolveAttribute(ctx.you || ctx.me, name),
+      lhs: () => void 0,
+      put: (ctx, _lhs, v) => setAttribute(ctx.you || ctx.me, name, v)
+    };
+  }
+  function styleRef(p) {
+    const t = p.matchType("STYLE_REF");
+    if (!t) return;
+    const computed = t.value.startsWith("*computed-");
+    const name = t.value.slice(computed ? 10 : 1);
+    return {
+      type: computed ? "computedStyleRef" : "styleRef",
+      name,
+      start: t.start,
+      end: t.end,
+      ev: (ctx) => (computed ? resolveComputedStyle : resolveStyle)(ctx.you || ctx.me, name),
+      lhs: () => void 0,
+      put: (ctx, _lhs, v) => setStyle(ctx.you || ctx.me, name, v)
+    };
+  }
+  function styleLiteral(p) {
+    const start = p.pos();
+    if (!p.matchOp("{")) return;
+    const parts = [""];
+    const exprs = [];
+    while (p.hasMore()) {
+      if (p.matchOp("\\")) p.consume();
+      else if (p.matchOp("}")) break;
+      else if (p.match("$")) {
+        const brace = p.matchOp("{");
+        exprs.push(expr(p));
+        if (brace) p.reqOp("}");
+        parts.push("");
+      } else parts[parts.length - 1] += p.text(p.consume());
+      parts[parts.length - 1] += p.lastWs();
+    }
+    return {
+      type: "styleLiteral",
+      parts,
+      exprs,
+      start,
+      end: p.endPos(),
+      ev: (ctx) => all(
+        exprs.map((e) => e.ev(ctx)),
+        (vals) => parts.map((part, i) => part + (i in vals ? `${vals[i]}` : "")).join("")
+      )
+    };
+  }
+  function implicitMe(p) {
+    const at = p.endPos();
+    return { type: "implicitMeTarget", start: at, end: at, ev: (ctx) => ctx.you || ctx.me };
+  }
+  function dotOrColonPath(p) {
+    const root = p.matchType("IDENTIFIER");
+    if (!root) return;
+    const path = [root.value];
+    const separator = p.matchOp(".") ?? p.matchOp(":");
+    if (separator) {
+      do
+        path.push(p.reqType("IDENTIFIER", "NUMBER").value);
+      while (p.matchOp(separator.value));
+    }
+    return path.join(separator?.value ?? "");
+  }
+  function eventName(p, message = "Expected event name") {
+    return p.matchType("STRING")?.value ?? dotOrColonPath(p) ?? p.err(message);
+  }
+  function indirect(p, root) {
+    return propertyAccess(p, root) ?? ofExpression(p, root) ?? // Before `possessive`, as in upstream's build: `my @a` is an attribute access, and that
+    // takes nothing after it. `my @a as Int`, `my @a.length` and `my @a[0]` are errors there
+    // (`(my @a) as Int` is the spelling); read as a possessive they would parse here alone.
+    attributeAccess(p, root) ?? possessive(p, root) ?? inExpression(p, root) ?? asExpression(p, root) ?? functionCall(p, root) ?? arrayIndex(p, root) ?? extraIndirect(p, root) ?? root;
+  }
+  function extraIndirect(p, root) {
+    for (const rule of p.g.indirects) {
+      const node = rule(p, root);
+      if (node) return node;
+    }
+  }
+  function propertyAccess(p, root) {
+    if (!p.matchOp(".")) return;
+    const prop = p.reqType("IDENTIFIER").value;
+    const rootText = p.text(root);
+    const node = {
+      type: "propertyAccess",
+      root,
+      prop,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => then1(node.root.ev(ctx), (r) => resolveProperty(r, prop)),
+      lhs: (ctx) => node.root.ev(ctx),
+      put: (_ctx, lhs, value) => {
+        nullCheck(lhs, rootText);
+        setProperty(lhs, prop, value);
+      },
+      del: (_ctx, lhs) => {
+        nullCheck(lhs, rootText);
+        implicitLoop(lhs, (o) => {
+          if (obj(o)) delete o[prop];
+          rx.wroteProperty(o);
+        });
+      }
+    };
+    return indirect(p, node);
+  }
+  function ofExpression(p, root) {
+    if (!p.match("of")) return;
+    const owner = unary(p);
+    let child;
+    let innermost = root;
+    while (innermost.root) {
+      child = innermost;
+      innermost = innermost.root;
+    }
+    const kinds = {
+      symbol: "property",
+      attributeRef: "attribute",
+      styleRef: "style",
+      computedStyleRef: "computed"
+    };
+    const kind = kinds[innermost.type];
+    const name = innermost.name;
+    if (!kind || name === void 0)
+      return p.err("Cannot take a property of a non-symbol: " + innermost.type);
+    const ownerText = p.text(owner);
+    const read = {
+      property: resolveProperty,
+      attribute: resolveAttribute,
+      style: resolveStyle,
+      computed: resolveComputedStyle
+    }[kind];
+    const node = {
+      type: "ofExpression",
+      root: owner,
+      name,
+      kind,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => then1(node.root.ev(ctx), (r) => read(r, name)),
+      lhs: (ctx) => node.root.ev(ctx),
+      put: (_ctx, lhs, value) => {
+        nullCheck(lhs, ownerText);
+        if (kind === "attribute") setAttribute(lhs, name, value);
+        else if (kind === "property") setProperty(lhs, name, value);
+        else setStyle(lhs, name, value);
+      },
+      del: (_ctx, lhs) => {
+        nullCheck(lhs, ownerText);
+        implicitLoop(lhs, (o) => {
+          if (kind === "attribute") {
+            if (isEl(o)) o.removeAttribute(name);
+          } else if (kind === "property") {
+            if (obj(o)) delete o[name];
+            rx.wroteProperty(o);
+          } else if (o instanceof HTMLElement) o.style.removeProperty(name);
+        });
+      }
+    };
+    if (child) {
+      child.root = node;
+      return indirect(p, root);
+    }
+    return indirect(p, node);
+  }
+  function possessive(p, root) {
+    const apostrophe = p.matchOp("'");
+    const pronoun = root.type === "symbol" && ["my", "its", "your"].includes(root.name ?? "") && ["IDENTIFIER", "ATTRIBUTE_REF", "STYLE_REF"].includes(p.cur().type);
+    if (!apostrophe && !pronoun) return;
+    if (apostrophe) p.req("s");
+    const attribute = attributeRef(p) ?? styleRef(p);
+    const prop = attribute ? void 0 : p.reqType("IDENTIFIER").value;
+    const rootText = p.text(root);
+    const read = (r) => {
+      if (prop !== void 0) return resolveProperty(r, prop);
+      if (attribute?.type === "attributeRef") return resolveAttribute(r, attribute.name);
+      if (attribute?.type === "computedStyleRef") return resolveComputedStyle(r, attribute.name);
+      return attribute && resolveStyle(r, attribute.name);
+    };
+    const node = {
+      type: "possessive",
+      root,
+      prop,
+      attribute,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => then1(node.root.ev(ctx), read),
+      lhs: (ctx) => node.root.ev(ctx),
+      put: (_ctx, lhs, value) => {
+        nullCheck(lhs, rootText);
+        if (prop !== void 0) setProperty(lhs, prop, value);
+        else if (attribute?.type === "attributeRef") setAttribute(lhs, attribute.name, value);
+        else if (attribute) setStyle(lhs, attribute.name, value);
+      }
+    };
+    return indirect(p, node);
+  }
+  function inExpression(p, root) {
+    if (!p.match("in")) return;
+    const target = unary(p);
+    const find = (r, within) => {
+      if (r == null) return [];
+      const found = [];
+      const css = get(r, "css");
+      if (typeof css === "string") {
+        implicitLoop(within, (t) => isEl(t) && found.push(...query(t, css)));
+      } else if (isEl(r)) {
+        let inside = false;
+        implicitLoop(within, (t) => {
+          if (t instanceof Node && t.contains(r)) inside = true;
+        });
+        if (inside) return r;
+      } else {
+        implicitLoop(r, (a) => implicitLoop(within, (b) => a === b && found.push(a)));
+      }
+      return found;
+    };
+    const node = {
+      type: "inExpression",
+      root,
+      target,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => all([node.root.ev(ctx), target.ev(ctx)], ([r, t]) => find(r, t)),
+      lhs: (ctx) => node.ev(ctx),
+      put: (_ctx, lhs, value) => replaceInDom(lhs, value)
+    };
+    let filtered;
+    if (p.peek("where")) for (const rule of p.g.collections) filtered ??= rule(p, node);
+    return indirect(p, filtered ?? node);
+  }
+  function asExpression(p, root) {
+    if (!p.match("as")) return;
+    if (!p.match("a")) p.match("an");
+    const make = (inner) => {
+      const conversion = dotOrColonPath(p) ?? p.err("Expected dotOrColonPath");
+      const node2 = {
+        type: "asExpression",
+        root: inner,
+        conversion,
+        start: inner.start,
+        end: p.endPos(),
+        ev: (ctx) => then1(node2.root.ev(ctx), (v) => convert(v, conversion))
+      };
+      return node2;
+    };
+    let node = make(root);
+    while (p.matchOp("|")) node = make(node);
+    return indirect(p, node);
+  }
+  function functionCall(p, root) {
+    if (!p.matchOp("(")) return;
+    const args = [];
+    if (!p.matchOp(")")) {
+      do
+        args.push(expr(p));
+      while (p.matchOp(","));
+      p.reqOp(")");
+    }
+    const rootText = p.text(root);
+    const ownerText = root.root ? p.text(root.root) : "";
+    const node = {
+      type: "functionCall",
+      root,
+      args,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => {
+        const callee = node.root;
+        const method = callee.prop;
+        const owner = method === void 0 ? void 0 : callee.root;
+        return all(
+          [(owner ?? callee).ev(ctx), ...args.map((a) => a.ev(ctx))],
+          ([target, ...values]) => {
+            if (!owner || method === void 0) return call(target, void 0, values, ctx, rootText);
+            nullCheck(target, ownerText);
+            const result = call(get(target, method), target, values, ctx, rootText);
+            maybeNotify(target, method);
+            return result;
+          }
+        );
+      }
+    };
+    return indirect(p, node);
+  }
+  function call(f, receiver, args, ctx, source) {
+    if (!fn(f)) {
+      nullCheck(f, source);
+      throw new Error(`'${source}' is not a function`);
+    }
+    if (get(f, "hyperfunc")) args.push(ctx);
+    return Reflect.apply(f, receiver, args);
+  }
+  function attributeAccess(p, root) {
+    const attribute = attributeRef(p);
+    return attribute && attributeAccessNode(p, root, attribute);
+  }
+  function attributeAccessNode(p, root, attribute) {
+    const rootText = p.text(root);
+    const node = {
+      type: "attributeRefAccess",
+      root,
+      attribute,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => then1(node.root.ev(ctx), (r) => resolveAttribute(r, attribute.name)),
+      lhs: (ctx) => node.root.ev(ctx),
+      put: (_ctx, lhs, value) => {
+        nullCheck(lhs, rootText);
+        setAttribute(lhs, attribute.name, value);
+      }
+    };
+    return node;
+  }
+  function arrayIndex(p, root) {
+    if (!p.matchOp("[")) return;
+    const andBefore = !!p.matchOp("..");
+    const first = expr(p);
+    let andAfter = false;
+    let second;
+    if (!andBefore && p.matchOp("..")) {
+      andAfter = true;
+      if (!(p.cur().op && p.cur().value === "]")) second = expr(p);
+    }
+    p.reqOp("]");
+    const rootText = p.text(root);
+    const fromEnd = (list, i) => num(i) < 0 ? num(get(list, "length")) + num(i) : num(i);
+    const slice = (list, from, to) => {
+      const method = get(list, "slice");
+      return fn(method) ? Reflect.apply(method, list, [from, to]) : void 0;
+    };
+    const node = {
+      type: "arrayIndex",
+      root,
+      first,
+      second,
+      andBefore,
+      andAfter,
+      start: root.start,
+      end: p.endPos(),
+      ev: (ctx) => all([node.root.ev(ctx), first.ev(ctx), second?.ev(ctx)], ([list, i, j]) => {
+        if (list == null) return null;
+        if (andBefore) return slice(list, 0, fromEnd(list, i) + 1);
+        if (andAfter)
+          return j == null ? slice(list, num(i)) : slice(list, num(i), fromEnd(list, j) + 1);
+        return get(list, String(i));
+      }),
+      lhs: (ctx) => all([node.root.ev(ctx), first.ev(ctx)], (pair) => pair),
+      put: (_ctx, lhs, value) => {
+        const [list, i] = Array.isArray(lhs) ? lhs : [];
+        nullCheck(list, rootText);
+        if (obj(list)) list[String(i)] = value;
+      },
+      del: (_ctx, lhs) => {
+        if (andBefore || andAfter) throw new Error("Cannot remove a slice - use a single index");
+        const [list, i] = Array.isArray(lhs) ? lhs : [];
+        nullCheck(list, rootText);
+        if (Array.isArray(list)) list.splice(fromEnd(list, i), 1);
+        else if (obj(list)) delete list[String(i)];
+        rx.wroteProperty(list);
+      }
+    };
+    return indirect(p, node);
+  }
+
+  // src/statements.ts
+  function command(p) {
+    const start = p.pos();
+    if (p.matchOp("(")) {
+      const grouped = command(p) ?? p.err("Expected command");
+      p.reqOp(")");
+      return grouped;
+    }
+    const t = p.cur();
+    const rule = p.g.commands[t.value];
+    let cmd;
+    if (rule) cmd = p.match(t.value) && rule(p, t.value, start);
+    else if (t.type === "IDENTIFIER") cmd = p.g.pseudo?.(p, start);
+    if (!cmd || !p.match("unless")) return cmd;
+    const inner = cmd;
+    const condition = expr(p);
+    const unless = {
+      type: "unlessStatementModifier",
+      command: inner,
+      condition,
+      start,
+      end: p.endPos(),
+      run: (ctx) => then1(condition.ev(ctx), (skip) => skip ? void 0 : inner.run(ctx))
+    };
+    return unless;
+  }
+  function commandList(p) {
+    const list = [];
+    while (p.hasMore()) {
+      const cmd = command(p);
+      if (!cmd) break;
+      list.push(cmd);
+      p.match("then");
+    }
+    return list;
+  }
+  function feature(p) {
+    const start = p.pos();
+    if (p.matchOp("(")) {
+      const grouped = feature(p);
+      p.reqOp(")");
+      return grouped;
+    }
+    const t = p.cur();
+    const rule = p.g.features[t.value];
+    if (!rule || !p.match(t.value)) return p.err("Expected feature");
+    return rule(p, start);
+  }
+  function program(p) {
+    const start = p.pos();
+    const features = [];
+    while (p.hasMore()) {
+      const t = p.cur();
+      if (p.featureStart(t) || t.value === "(") {
+        features.push(feature(p));
+        p.match("end");
+      } else if (t.value === "end") break;
+      else p.err();
+    }
+    return { type: "hyperscript", features, start, end: p.endPos() };
+  }
+  function errorAndFinally(p) {
+    const handlers = {};
+    if (p.match("catch")) {
+      handlers.errorSymbol = p.reqType("IDENTIFIER").value;
+      handlers.errorHandler = commandList(p);
+    }
+    if (p.match("finally")) handlers.finallyHandler = commandList(p);
+    return handlers;
+  }
+  function eventArgs(p) {
+    const args = [];
+    const second = p.tok(1).value;
+    const third = p.tok(2).value;
+    if (p.cur().value === "(" && (second === ")" || third === "," || third === ")")) {
+      p.matchOp("(");
+      do
+        args.push(p.reqType("IDENTIFIER").value);
+      while (p.matchOp(","));
+      p.reqOp(")");
+    }
+    return args;
+  }
+
+  // src/commands/control.ts
+  function ifCommand(g) {
+    g.commands.if = (p, _keyword, start) => {
+      const condition = expr(p);
+      p.match("then");
+      const trueBranch = commandList(p);
+      let falseBranch;
+      let chained = false;
+      const otherwise = p.match("else") ?? p.match("otherwise");
+      if (otherwise) {
+        chained = p.peek("if")?.line === otherwise.line;
+        if (chained) {
+          const nested = command(p);
+          falseBranch = nested ? [nested] : [];
+        } else falseBranch = commandList(p);
+      }
+      if (p.hasMore() && !chained) p.req("end");
+      const node = {
+        type: "ifCommand",
+        condition,
+        trueBranch,
+        falseBranch,
+        start,
+        end: p.endPos(),
+        run: (ctx) => then1(
+          condition.ev(ctx),
+          (yes) => yes ? runList(trueBranch, ctx) : falseBranch && runList(falseBranch, ctx)
+        )
+      };
+      return node;
+    };
+  }
+  var EXIT = { k: "return", value: null };
+  function halt(g) {
+    g.commands.halt = (p, _keyword, start) => {
+      let keepExecuting = false;
+      if (p.match("the")) {
+        p.req("event");
+        if (p.matchOp("'")) p.req("s");
+        keepExecuting = true;
+      }
+      const bubbling = !!p.match("bubbling");
+      const haltDefault = !bubbling && !!p.match("default");
+      const node = {
+        type: "haltCommand",
+        keepExecuting,
+        bubbling,
+        haltDefault,
+        start,
+        end: p.endPos(),
+        run: (ctx) => {
+          const event = ctx.event;
+          if (event instanceof Event) {
+            if (!haltDefault) event.stopPropagation();
+            if (!bubbling) event.preventDefault();
+          }
+          if (!keepExecuting) return EXIT;
+        }
+      };
+      return node;
+    };
+  }
+
+  // src/commands/dom.ts
+  function classRefs(p) {
+    const first = classRef(p);
+    if (!first) return;
+    const refs = [first];
+    for (let next = classRef(p); next; next = classRef(p)) refs.push(next);
+    return refs;
+  }
+  var classNames = (refs, ctx) => (refs ?? []).map((ref) => then1(ref.ev(ctx), (c) => String(get(c, "className"))));
+  var cssProperties = (css) => css.split(";").map((declaration) => declaration.split(":")[0].trim()).filter(Boolean);
+  var styleOf = (elt) => elt instanceof HTMLElement || elt instanceof SVGElement ? elt.style : void 0;
+  var eachTarget = (targets, when, ctx, apply, undo) => when ? implicitLoopWhen(
+    targets,
+    when,
+    ctx,
+    (t) => isEl(t) && apply(t),
+    (t) => isEl(t) && undo(t)
+  ) : implicitLoop(targets, (t) => isEl(t) && apply(t));
+  var setAttribute2 = (elt, { name, value }, on2) => on2 ? elt.setAttribute(name, String(value)) : elt.removeAttribute(name);
+  var mark = (on2, targets, when, ctx, names, attribute) => attribute ? eachTarget(
+    targets,
+    when,
+    ctx,
+    (t) => setAttribute2(t, attribute, on2),
+    (t) => setAttribute2(t, attribute, !on2)
+  ) : all(
+    names.map(
+      (name) => eachTarget(
+        targets,
+        when,
+        ctx,
+        (t) => t.classList.toggle(String(name), on2),
+        (t) => t.classList.toggle(String(name), !on2)
+      )
+    ),
+    () => {
+    }
+  );
+  function subject(p) {
+    const refs = classRefs(p);
+    const attribute = refs ? void 0 : attributeRef(p);
+    return { refs, attribute, css: refs || attribute ? void 0 : styleLiteral(p) };
+  }
+  function add(g) {
+    g.commands.add = (p, _keyword, start) => {
+      const { refs, attribute, css } = subject(p);
+      let value;
+      if (!refs && !attribute && !css) {
+        value = p.withFollow(["to"], () => expr(p));
+        if (p.cur().value !== "to")
+          p.err("Expected either a class reference or attribute expression");
+      }
+      const to = p.match("to") ? expr(p) : implicitMe(p);
+      const whenClause = p.match("when") ? expr(p) : void 0;
+      const when = refs || attribute ? whenClause : void 0;
+      const toText = p.text(to);
+      const node = {
+        type: "addCommand",
+        classRefs: refs,
+        attributeRef: attribute,
+        css,
+        value,
+        to,
+        when,
+        start,
+        end: p.endPos(),
+        run: (ctx) => all(
+          [to.ev(ctx), css?.ev(ctx), value?.ev(ctx), ...classNames(refs, ctx)],
+          ([target, cssText, item, ...names]) => {
+            nullCheck(target, toText);
+            if (value) {
+              if (Array.isArray(target)) target.push(item);
+              else if (target instanceof Set) target.add(item);
+              else if (target instanceof Map)
+                throw new Error("Use 'set myMap[key] to value' for Maps");
+              else throw new Error("Cannot add to " + typeof target);
+              rx.wroteProperty(target);
+            } else if (!css) return mark(true, target, when, ctx, names, attribute);
+            else {
+              implicitLoop(target, (t) => {
+                const style = styleOf(t);
+                if (style) style.cssText += cssText;
+              });
+            }
+          }
+        )
+      };
+      return node;
+    };
+  }
+  var isDomTarget = (v) => v instanceof Node || v instanceof NodeList || v instanceof HTMLCollection;
+  function remove(g) {
+    g.commands.remove = (p, _keyword, start) => {
+      const { refs, attribute, css } = subject(p);
+      const element = refs || attribute || css ? void 0 : expr(p);
+      const from = p.match("from") ? expr(p) : element ? void 0 : implicitMe(p);
+      let when;
+      if (p.match("when")) {
+        if (element) p.err("'when' clause is not supported when removing elements");
+        when = expr(p);
+      }
+      const fromText = from ? p.text(from) : "";
+      const elementText = element ? p.text(element) : "";
+      const removeValue = (ctx, value, container) => {
+        if (container == null && element?.del && element.lhs && !isDomTarget(value)) {
+          const target = element;
+          return then1(element.lhs(ctx), (lhs) => target.del?.(ctx, lhs));
+        }
+        nullCheck(value, elementText);
+        if (Array.isArray(container)) {
+          const index = container.indexOf(value);
+          if (index > -1) container.splice(index, 1);
+          rx.wroteProperty(container);
+        } else if (container instanceof Set || container instanceof Map) {
+          container.delete(value);
+          rx.wroteProperty(container);
+        } else {
+          implicitLoop(value, (t) => {
+            if (isEl(t) && t.parentElement && (container == null || container instanceof Node && container.contains(t))) {
+              t.parentElement.removeChild(t);
+            }
+          });
+        }
+      };
+      const node = {
+        type: "removeCommand",
+        classRefs: refs,
+        attributeRef: attribute,
+        css,
+        element,
+        from,
+        when,
+        start,
+        end: p.endPos(),
+        run: (ctx) => all(
+          [from?.ev(ctx), css?.ev(ctx), element?.ev(ctx), ...classNames(refs, ctx)],
+          ([container, cssText, value, ...names]) => {
+            if (element) return removeValue(ctx, value, container);
+            nullCheck(container, fromText);
+            if (css) {
+              const properties = cssProperties(String(cssText));
+              implicitLoop(
+                container,
+                (t) => properties.forEach((property) => styleOf(t)?.removeProperty(property))
+              );
+            } else return mark(false, container, when, ctx, names, attribute);
+          }
+        )
+      };
+      return node;
+    };
+  }
+  var byStyle = (property, hidden, shown) => (op, elt, arg) => {
+    if (arg) elt.style[property] = arg;
+    else if (op === "toggle")
+      elt.style[property] = getComputedStyle(elt)[property] === hidden ? shown : hidden;
+    else elt.style[property] = op === "hide" ? hidden : shown;
+  };
+  var strategies = {
+    display(op, elt, arg) {
+      if (!arg && elt instanceof HTMLDialogElement) {
+        if (op === "hide" || op === "toggle" && elt.open) elt.close();
+        else if (!elt.open) elt.show();
+        return;
+      }
+      const data = dataOf(elt);
+      if (arg) elt.style.display = arg;
+      else if (op === "toggle")
+        strategies.display(getComputedStyle(elt).display === "none" ? "show" : "hide", elt);
+      else if (op === "hide") {
+        data.originalDisplay ??= elt.style.display;
+        elt.style.display = "none";
+      } else if (data.originalDisplay && data.originalDisplay !== "none")
+        elt.style.display = data.originalDisplay;
+      else elt.style.removeProperty("display");
+    },
+    visibility: byStyle("visibility", "hidden", "visible"),
+    opacity: byStyle("opacity", "0", "1"),
+    hidden(op, elt) {
+      const hide = op === "toggle" ? !elt.hasAttribute("hidden") : op === "hide";
+      if (hide) elt.setAttribute("hidden", "");
+      else elt.removeAttribute("hidden");
+    }
+  };
+  function strategy(p, name) {
+    const chosen = name ?? config.defaultHideShowStrategy ?? "display";
+    return config.hideShowStrategies[chosen] ?? strategies[chosen] ?? p.err("Unknown show/hide strategy : " + chosen);
+  }
+  function toggle(g) {
+    g.commands.toggle = (p, _keyword, start) => {
+      p.matchAny("the", "my");
+      const node = { type: "toggleCommand", start, end: start, run: () => {
+      } };
+      let visibility;
+      if (p.cur().type === "STYLE_REF") {
+        const styleProp2 = node.styleProp = p.consume().value.slice(1);
+        visibility = strategy(p, styleProp2);
+        node.on = p.match("of") ? p.withFollow(["with", "between"], () => expr(p)) : implicitMe(p);
+      } else if (p.match("between")) {
+        const first = classRef(p);
+        if (first) {
+          p.req("and");
+          node.between = [first, classRef(p) ?? p.err("Expected classRef")];
+        } else {
+          const attribute2 = attributeRef(p) ?? p.err("Expected either a class reference or attribute expression");
+          p.req("and");
+          node.between = [attribute2, attributeRef(p) ?? p.err("Expected attributeRef")];
+        }
+      } else if (!(node.classRefs = classRefs(p)) && !(node.attributeRef = attributeRef(p))) {
+        const element = p.g.toggleElement;
+        if (!element) node.target = p.withFollow(["between"], () => assignable(p));
+        else {
+          const target2 = p.withFollow(["between", "as"], () => unary(p));
+          if (!p.peek("between")) return element(p, target2, start);
+          node.target = writable(p, target2);
+        }
+      }
+      if (!node.styleProp && !node.target) node.on = p.match("on") ? expr(p) : implicitMe(p);
+      if (p.match("between")) {
+        const values = node.betweenValues = p.withFollow(["and"], () => {
+          const list = [expr(p)];
+          while (p.matchOp(",")) list.push(expr(p));
+          return list;
+        });
+        p.req("and");
+        values.push(expr(p));
+      }
+      if (node.target && !node.betweenValues)
+        p.err("toggle <expression> requires 'between' with values");
+      if (p.peek("for") && !p.peek("in", 2)) {
+        p.match("for");
+        node.time = expr(p);
+      } else if (p.match("until")) {
+        node.until = eventName(p);
+        if (p.match("from")) node.from = expr(p);
+      }
+      node.end = p.endPos();
+      const { on: on2, target, betweenValues, between, attributeRef: attribute, styleProp } = node;
+      const onText = on2 ? p.text(on2) : "";
+      const next = (values, current) => values[(values.findIndex((v) => v == current) + 1) % values.length];
+      const flip = (ctx, targets, values, names) => {
+        if (betweenValues && target?.lhs && target.put) {
+          const write = target;
+          return all(
+            [target.ev(ctx), target.lhs(ctx)],
+            ([current, lhs]) => write.put?.(ctx, lhs, next(values, current))
+          );
+        }
+        if (betweenValues && styleProp) {
+          return implicitLoop(targets, (t) => {
+            const style = styleOf(t);
+            if (!style || !isEl(t)) return;
+            const current = style.getPropertyValue(styleProp) || getComputedStyle(t).getPropertyValue(styleProp);
+            style.setProperty(styleProp, String(next(values, current)));
+          });
+        }
+        nullCheck(targets, onText);
+        implicitLoop(targets, (t) => {
+          if (!isEl(t)) return;
+          if (visibility) {
+            if (t instanceof HTMLElement) visibility("toggle", t);
+          } else if (between) {
+            const [a, b] = between;
+            if (a.type === "classRef" && b.type === "classRef") {
+              const [first, second] = [String(a.className), String(b.className)];
+              const had = t.classList.contains(first);
+              t.classList.toggle(first, !had);
+              t.classList.toggle(second, had);
+            } else if (a.type === "attributeRef" && b.type === "attributeRef") {
+              const hadFirst = t.getAttribute(a.name) === String(a.value);
+              setAttribute2(t, hadFirst ? a : b, false);
+              setAttribute2(t, hadFirst ? b : a, true);
+            }
+          } else if (attribute) setAttribute2(t, attribute, !t.hasAttribute(attribute.name));
+          else names.forEach((name) => t.classList.toggle(String(name)));
+        });
+      };
+      node.run = (ctx) => all(
+        [
+          on2?.ev(ctx),
+          node.time?.ev(ctx),
+          node.from?.ev(ctx),
+          all(
+            (betweenValues ?? []).map((v) => v.ev(ctx)),
+            (v) => v
+          ),
+          ...classNames(node.classRefs, ctx)
+        ],
+        ([targets, time, source, values, ...names]) => {
+          const once = () => flip(ctx, targets, Array.isArray(values) ? values : [], names);
+          if (node.time) {
+            return new Promise((resolve) => {
+              once();
+              setTimeout(() => {
+                once();
+                resolve();
+              }, num(time));
+            });
+          }
+          if (node.until) {
+            const until = node.until;
+            const eventSource = source || ctx.me;
+            return new Promise((resolve) => {
+              if (isTarget(eventSource)) {
+                eventSource.addEventListener(
+                  until,
+                  () => {
+                    once();
+                    resolve();
+                  },
+                  { once: true }
+                );
+              }
+              once();
+            });
+          }
+          return then1(once(), () => {
+          });
+        }
+      );
+      return node;
+    };
+  }
+
+  // src/commands/dom-more.ts
+  function hideShow(g) {
+    for (const op of ["hide", "show"]) {
+      g.commands[op] = (p, _keyword, start) => {
+        const next = p.cur();
+        const target = next.value === "when" || next.value === "with" || p.commandBoundary(next) ? implicitMe(p) : expr(p);
+        let name;
+        if (p.match("with")) name = p.reqType("IDENTIFIER", "STYLE_REF").value.replace(/^\*/, "");
+        let arg;
+        if (op === "show" && p.matchOp(":")) {
+          arg = p.consumeUntil(void 0, "WHITESPACE").map((t) => t.value).join("");
+        }
+        const when = p.match("when") ? expr(p) : void 0;
+        const apply = strategy(p, name);
+        const targetText = p.text(target);
+        const act = (which) => (elt) => {
+          if (elt instanceof HTMLElement) apply(which, elt, which === "show" ? arg : void 0);
+        };
+        const node = {
+          type: `${op}Command`,
+          target,
+          strategy: name,
+          arg,
+          when,
+          start,
+          end: p.endPos(),
+          run: (ctx) => then1(target.ev(ctx), (elements) => {
+            nullCheck(elements, targetText);
+            if (when)
+              return implicitLoopWhen(
+                elements,
+                when,
+                ctx,
+                act(op),
+                act(op === "hide" ? "show" : "hide")
+              );
+            implicitLoop(elements, act(op));
+          })
+        };
+        return node;
+      };
+    }
+  }
+  var MEASUREMENTS = "x y left top right bottom width height bounds scrollLeft scrollTop scrollLeftMax scrollTopMax scrollWidth scrollHeight scroll".split(
+    " "
+  );
+
+  // src/commands/events.ts
+  function send(g) {
+    g.commands.send = g.commands.trigger = (p, keyword, start) => {
+      const event = eventName(p);
+      const details = namedArgumentList(p);
+      const to = p.match(keyword === "trigger" ? "on" : "to") ? expr(p) : implicitMe(p);
+      const toText = p.text(to);
+      const node = {
+        type: "sendCommand",
+        event,
+        details,
+        to,
+        start,
+        end: p.endPos(),
+        run: (ctx) => all([to.ev(ctx), details?.ev(ctx)], ([targets, detail]) => {
+          nullCheck(targets, toText);
+          implicitLoop(
+            targets,
+            (target) => triggerEvent(target, event, obj(detail) ? detail : {}, ctx.me)
+          );
+        })
+      };
+      return node;
+    };
+  }
+  function wait(g) {
+    g.commands.wait = (p, _keyword, start) => {
+      const node = { type: "waitCommand", start, end: start, run: () => {
+      } };
+      if (p.match("for")) {
+        p.match("a");
+        const events = node.events = [];
+        do {
+          const t = p.cur();
+          if (t.type === "NUMBER" || t.op && t.value === "(") events.push(expr(p));
+          else events.push({ event: eventName(p), args: eventArgs(p) });
+        } while (p.match("or"));
+        const from = node.from = p.match("from") ? expr(p) : void 0;
+        const fromText = from ? p.text(from) : "me";
+        node.run = (ctx) => then1(from ? from.ev(ctx) : ctx.me, (source) => {
+          if (!isTarget(source)) throw new Error("Not a valid event target: " + fromText);
+          return new Promise((resolve) => {
+            for (const spec of events) {
+              if ("event" in spec) {
+                source.addEventListener(
+                  spec.event,
+                  (event) => {
+                    ctx.result = event;
+                    for (const arg of spec.args) {
+                      ctx.locals[arg] = get(event, arg) || get(get(event, "detail"), arg) || null;
+                    }
+                    resolve();
+                  },
+                  { once: true }
+                );
+              } else {
+                then1(
+                  spec.ev(ctx),
+                  (ms) => setTimeout(() => {
+                    ctx.result = ms;
+                    resolve();
+                  }, num(ms))
+                );
+              }
+            }
+          });
+        });
+      } else {
+        let time;
+        if (p.match("a")) p.req("tick");
+        else time = node.time = expr(p);
+        node.run = (ctx) => then1(
+          time?.ev(ctx),
+          (ms) => new Promise((resolve) => setTimeout(resolve, time ? num(ms) : 0))
+        );
+      }
+      node.end = p.endPos();
+      return node;
+    };
+  }
+
+  // src/commands/misc.ts
+  function log(g) {
+    g.commands.log = (p, _keyword, start) => {
+      const values = [expr(p)];
+      while (p.matchOp(",")) values.push(expr(p));
+      const logger = p.match("with") ? expr(p) : void 0;
+      const node = {
+        type: "logCommand",
+        values,
+        logger,
+        start,
+        end: p.endPos(),
+        run: (ctx) => all([logger?.ev(ctx), ...values.map((v) => v.ev(ctx))], ([out, ...vals]) => {
+          if (fn(out)) out(...vals);
+          else console.log(...vals);
+        })
+      };
+      return node;
+    };
+  }
+  function get_(g) {
+    g.commands.get = g.commands.call = (p, keyword, start) => {
+      const value = expr(p);
+      if (keyword === "call" && value.type !== "functionCall") p.err("Must be a function invocation");
+      const node = {
+        type: "getCommand",
+        value,
+        start,
+        end: p.endPos(),
+        run: (ctx) => then1(value.ev(ctx), (v) => {
+          ctx.result = v;
+        })
+      };
+      return node;
+    };
+  }
+  function pseudoCommand(g) {
+    g.pseudo = (p, start) => {
+      const next = p.tok(1);
+      if (!(next.op && (next.value === "." || next.value === "("))) return;
+      const value = primary(p);
+      if (value.type !== "functionCall") p.err("Pseudo-commands must be function calls");
+      const callee = value.root;
+      const args = "args" in value && Array.isArray(value.args) ? value.args : [];
+      let target;
+      if (callee && !callee.root) {
+        if (p.matchAny("the", "to", "on", "with", "into", "from", "at")) target = expr(p);
+        else if (p.match("me")) target = implicitMe(p);
+      }
+      const method = callee?.name ?? "";
+      const targetText = target ? p.text(target) : "";
+      const valueText = p.text(value);
+      const receiver = target;
+      const node = {
+        type: "pseudoCommand",
+        value,
+        target,
+        start,
+        end: p.endPos(),
+        run: (ctx) => {
+          if (!receiver) {
+            return then1(value.ev(ctx), (v) => {
+              ctx.result = v;
+            });
+          }
+          return all([receiver.ev(ctx), ...args.map((a) => a.ev(ctx))], ([owner, ...vals]) => {
+            nullCheck(owner, targetText);
+            ctx.result = call(get(owner, method), owner, vals, ctx, valueText);
+            maybeNotify(owner, method);
+          });
+        }
+      };
+      return node;
+    };
+  }
+
+  // src/commands/setters.ts
+  function set2(g) {
+    g.commands.set = (p, _keyword, start) => parseSet(p, start);
+  }
+  function parseSet(p, start) {
+    {
+      if (p.cur().op && p.cur().value === "{") {
+        const object = objectLiteral(p);
+        p.req("on");
+        const target2 = expr(p);
+        const node2 = {
+          type: "setCommand",
+          target: target2,
+          object,
+          start,
+          end: p.endPos(),
+          run: (ctx) => all(
+            [object.ev(ctx), target2.ev(ctx)],
+            ([props, onto]) => void Object.assign(Object(onto), props)
+          )
+        };
+        return node2;
+      }
+      const target = p.withFollow(["to"], () => assignable(p));
+      p.req("to");
+      const value = expr(p);
+      const node = {
+        type: "setCommand",
+        target,
+        value,
+        start,
+        end: p.endPos(),
+        // `set` writes its target and nothing else: `it` is left alone.
+        run: (ctx) => all([target.lhs?.(ctx), value.ev(ctx)], ([lhs, v]) => target.put?.(ctx, lhs, v))
+      };
+      return node;
+    }
+  }
+  function increment(g) {
+    for (const keyword of ["increment", "decrement"]) {
+      const sign = keyword === "increment" ? 1 : -1;
+      g.commands[keyword] = (p, _keyword, start) => {
+        const target = p.withFollow(sign < 0 ? ["by"] : [], () => assignable(p));
+        const amount = p.match("by") ? expr(p) : void 0;
+        const node = {
+          type: `${keyword}Command`,
+          target,
+          amount,
+          start,
+          end: p.endPos(),
+          run: (ctx) => all([target.ev(ctx), amount?.ev(ctx), target.lhs?.(ctx)], ([current, by, lhs]) => {
+            const value = (current ? parseFloat(String(current)) : 0) + sign * (amount ? parseFloat(String(by)) : 1);
+            ctx.result = value;
+            target.put?.(ctx, lhs, value);
+          })
+        };
+        return node;
+      };
+    }
+  }
+  function setContent(elt, value) {
+    elt.replaceChildren(toFragment(value));
+    host.process(elt);
+  }
+  var WRITES = [
+    "arrayIndex",
+    "propertyAccess",
+    "possessive",
+    "ofExpression",
+    "attributeRef",
+    "styleRef",
+    "attributeRefAccess"
+  ];
+  var OPERATIONS = {
+    into: "into",
+    before: "before",
+    after: "after",
+    start: "start",
+    end: "end"
+  };
+  var INSERT = { before: "before", after: "after", start: "prepend", end: "append" };
+  function put(g) {
+    g.commands.put = (p, _keyword, start) => {
+      const value = expr(p);
+      let word = p.matchAny("into", "before", "after");
+      if (!word && p.match("at")) {
+        p.match("the");
+        word = p.matchAny("start", "end");
+        p.req("of");
+      }
+      const operation = OPERATIONS[(word ?? p.expected("into", "before", "at start of", "at end of", "after")).value];
+      const target = unwrap(expr(p));
+      const targetText = p.text(target);
+      const into = (ctx, v) => {
+        if (target.type === "symbol") {
+          return then1(target.ev(ctx), (current) => {
+            if (isEl(current) || current instanceof Document) setContent(current, v);
+            else target.put?.(ctx, void 0, v);
+          });
+        }
+        if (WRITES.includes(target.type)) {
+          return then1(target.lhs?.(ctx), (lhs) => target.put?.(ctx, lhs, v));
+        }
+        return then1(target.ev(ctx), (root) => {
+          nullCheck(root, targetText);
+          implicitLoop(root, (elt) => {
+            if (isEl(elt) || elt instanceof Document) setContent(elt, v);
+          });
+        });
+      };
+      const insert = (ctx, v, method) => then1(target.ev(ctx), (root) => {
+        nullCheck(root, targetText);
+        if (Array.isArray(root)) {
+          if (method === "prepend") root.unshift(v);
+          else root.push(v);
+          rx.wroteProperty(root);
+          return;
+        }
+        implicitLoop(root, (elt) => {
+          if (!isEl(elt)) return;
+          elt[method](v instanceof Node ? v : toFragment(v));
+          host.process(elt.parentElement ?? elt);
+        });
+      });
+      const node = {
+        type: "putCommand",
+        value,
+        operation,
+        target,
+        start,
+        end: p.endPos(),
+        run: (ctx) => then1(
+          value.ev(ctx),
+          (v) => operation === "into" ? into(ctx, v) : insert(ctx, v, INSERT[operation])
+        )
+      };
+      return node;
+    };
+  }
+
+  // src/parser.ts
+  var ParseError = class extends Error {
+    constructor(message, token, source, expected) {
+      super(message);
+      this.token = token;
+      this.source = source;
+      this.expected = expected;
+    }
+    /** What the author wrote, when a plugin rewrote the script before it was parsed. */
+    written;
+  };
+  var createGrammar = () => ({
+    commands: /* @__PURE__ */ Object.create(null),
+    features: /* @__PURE__ */ Object.create(null),
+    leaves: [],
+    indirects: [],
+    unaries: [],
+    postfixes: [],
+    collections: []
+  });
+  var Parser = class _Parser {
+    constructor(g, tokens, src) {
+      this.g = g;
+      this.tokens = tokens;
+      this.src = src;
+      const end = src.length;
+      this.eof = { type: "EOF", value: "<<<EOF>>>", start: end, end, line: 0, column: 0 };
+      this.last = this.eof;
+      this.skipWs();
+    }
+    i = 0;
+    follows = [];
+    eof;
+    /** The last token consumed by a match. */
+    last;
+    child(tokens, src) {
+      return new _Parser(this.g, tokens, src);
+    }
+    // ----- access ------------------------------------------------------------
+    /** The nth token from here; whitespace is skipped unless `ws`. */
+    tok(n = 0, ws = false) {
+      let j = this.i;
+      for (; ; ) {
+        if (!ws) while (this.tokens[j]?.type === "WHITESPACE") j++;
+        if (n-- === 0) return this.tokens[j] ?? this.eof;
+        j++;
+      }
+    }
+    cur() {
+      return this.tokens[this.i] ?? this.eof;
+    }
+    hasMore() {
+      return this.i < this.tokens.length;
+    }
+    /** Start offset of the current token — what a rule records as its node's `start`. */
+    pos() {
+      return this.cur().start;
+    }
+    /** End offset of the last consumed token — a node's `end`. */
+    endPos() {
+      return this.last.end;
+    }
+    text(node) {
+      return this.src.substring(node.start, node.end);
+    }
+    // ----- matching ----------------------------------------------------------
+    match(value, type = "IDENTIFIER") {
+      if (this.follows.includes(value)) return;
+      const t = this.cur();
+      if (t.value === value && t.type === type) return this.consume();
+    }
+    matchOp(value) {
+      const t = this.cur();
+      if (t.op && t.value === value) return this.consume();
+    }
+    matchType(...types) {
+      if (types.includes(this.cur().type)) return this.consume();
+    }
+    matchAny(...values) {
+      for (const value of values) {
+        const t = this.match(value);
+        if (t) return t;
+      }
+    }
+    matchAnyOp(...values) {
+      for (const value of values) {
+        const t = this.matchOp(value);
+        if (t) return t;
+      }
+    }
+    req(value) {
+      return this.match(value) ?? this.expected(value);
+    }
+    reqOp(value) {
+      return this.matchOp(value) ?? this.expected(value);
+    }
+    reqType(...types) {
+      return this.matchType(...types) ?? this.expected(...types);
+    }
+    /** Is the nth token from here this identifier (or this `type`)? Consumes nothing. */
+    peek(value, n = 0, type = "IDENTIFIER") {
+      const t = this.tok(n);
+      if (t.value === value && t.type === type) return t;
+    }
+    // ----- consuming ---------------------------------------------------------
+    consume() {
+      if (!this.hasMore()) return this.eof;
+      this.last = this.tokens[this.i++];
+      this.skipWs();
+      return this.last;
+    }
+    skipWs() {
+      while (this.tokens[this.i]?.type === "WHITESPACE") this.i++;
+    }
+    /** Raw tokens (whitespace included) up to a token with this value or type. */
+    consumeUntil(value, type) {
+      const out = [];
+      let t = this.cur();
+      while ((type == null || t.type !== type) && (value == null || t.value !== value) && t.type !== "EOF") {
+        out.push(t);
+        this.i++;
+        t = this.cur();
+      }
+      this.skipWs();
+      return out;
+    }
+    /** The whitespace just before the current token, if any. */
+    lastWs() {
+      const t = this.tokens[this.i - 1];
+      return t?.type === "WHITESPACE" ? t.value : "";
+    }
+    // ----- follow set: words a nested rule must leave for its caller ----------
+    pushFollow(...words) {
+      this.follows.push(...words);
+      return words.length;
+    }
+    popFollow(count = 1) {
+      this.follows.length -= count;
+    }
+    /** Parse with `words` reserved for the caller, e.g. the `to` of `set x to y`. */
+    withFollow(words, f) {
+      const count = this.pushFollow(...words);
+      try {
+        return f();
+      } finally {
+        this.popFollow(count);
+      }
+    }
+    /** Parse with no reserved words — inside parentheses the outer rule's words are free again. */
+    withoutFollows(f) {
+      const saved = this.follows;
+      this.follows = [];
+      try {
+        return f();
+      } finally {
+        this.follows = saved;
+      }
+    }
+    // ----- errors ------------------------------------------------------------
+    err(message, expected) {
+      const token = this.cur();
+      throw new ParseError(message ?? "Unexpected Token : " + token.value, token, this.src, expected);
+    }
+    expected(...expected) {
+      this.err(
+        expected.length === 1 ? `Expected '${expected[0]}' but found '${this.cur().value}'` : "Expected one of: " + expected.map((e) => `'${e}'`).join(", "),
+        expected
+      );
+    }
+    // ----- statement boundaries ------------------------------------------------
+    commandStart(token) {
+      return token.value in this.g.commands;
+    }
+    featureStart(token) {
+      return token.value in this.g.features;
+    }
+    commandBoundary(token) {
+      return ["end", "then", "else", "otherwise", ")"].includes(token.value) || this.commandStart(token) || this.featureStart(token) || token.type === "EOF";
+    }
+  };
+  function formatError(e) {
+    const lines = e.source.split("\n");
+    const index = e.token.line ? e.token.line - 1 : lines.length - 1;
+    const line = lines[index] ?? "";
+    const column = e.token.line ? e.token.column : Math.max(0, line.length - 1);
+    const gutter = String(index + 1).length;
+    const pad = " ".repeat(gutter + 5 + column);
+    return `  ${index + 1} | ${line}
+` + pad + "^".repeat(Math.max(1, e.token.value.length)) + "\n" + pad + e.message + "\n";
+  }
+
+  // src/engine.ts
+  var grammar = createGrammar();
+  function register(...modules) {
+    for (const module of modules) module(grammar);
+  }
+  var parser = (src) => new Parser(grammar, tokenize(src), src);
+  function parseProgram(src) {
+    const p = parser(src);
+    const parsed = program(p);
+    if (p.hasMore()) p.err();
+    return parsed;
+  }
+  function parse(src) {
+    const p = parser(src);
+    const first = p.cur();
+    const parsed = p.commandStart(first) ? { kind: "commands", commands: commandList(p) } : p.featureStart(first) ? { kind: "features", program: program(p) } : { kind: "expression", expression: expr(p) };
+    if (p.hasMore()) p.err();
+    return parsed;
+  }
+  function evaluate(src, overrides) {
+    let parsed;
+    try {
+      parsed = parse(src);
+    } catch (e) {
+      if (e instanceof ParseError) throw new Error(e.message + "\n\n" + formatError(e));
+      throw e;
+    }
+    const body = document.body;
+    if (parsed.kind === "features") {
+      for (const feature2 of parsed.program.features) feature2.install(body, body);
+      return;
+    }
+    const ctx = Object.assign(makeContext(body, void 0, body, null), overrides);
+    if (parsed.kind === "expression") return parsed.expression.ev(ctx);
+    return then1(runList(parsed.commands, ctx), (signal) => {
+      const returned = get(signal, "k") === "return" ? get(signal, "value") : void 0;
+      return returned !== void 0 ? returned : ctx.result;
+    });
+  }
+  var attributes = () => config.attributes.replaceAll(" ", "").split(",");
+  var isScript = (elt) => elt instanceof HTMLScriptElement && elt.type === "text/hyperscript";
+  function scriptOf(elt) {
+    for (const name of attributes()) {
+      if (elt.hasAttribute(name)) return elt.getAttribute(name);
+    }
+    return isScript(elt) ? elt.innerText : null;
+  }
+  var hash = (s) => {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i);
+    return h;
+  };
+  var transforms = [];
+  function initElement(elt) {
+    if (elt.closest(config.disableSelector)) return;
+    const written = scriptOf(elt);
+    if (!written) return;
+    const scriptHash = hash(written);
+    if (peekData(elt)?.initialized) {
+      if (peekData(elt)?.scriptHash === scriptHash) return host.enter(elt);
+      cleanup(elt);
+    }
+    if (!triggerEvent(elt, "hyperscript:before:init")) return;
+    Object.assign(dataOf(elt), { initialized: true, scriptHash });
+    const target = isScript(elt) ? document.body : elt;
+    let src = written;
+    try {
+      for (const transform of transforms) src = transform(src, elt) ?? src;
+      const { features } = parseProgram(src);
+      host.enter(elt);
+      for (const feature2 of features) feature2.install(target, elt);
+      elt.setAttribute("data-hyperscript-powered", "true");
+      triggerEvent(elt, "hyperscript:after:init");
+      setTimeout(() => triggerEvent(target, "load", { hyperscript: true }), 1);
+    } catch (e) {
+      if (e instanceof ParseError) {
+        if (src !== written) e.written = written;
+        triggerEvent(elt, "hyperscript:parse-error", { errors: [e] });
+        const from = e.written ? `
+  rewritten from: ${e.written}
+` : "";
+        console.error("hyperscript: 1 parse error(s) on:", elt, "\n\n" + formatError(e) + from);
+      } else {
+        triggerEvent(elt, "exception", { error: e });
+        console.error("hyperscript errors were found on the following element:", elt, "\n\n", e);
+      }
+    }
+  }
+  var beforeProcess = [];
+  var afterProcess = [];
+  function processNode(node) {
+    if (!(node instanceof Element || node instanceof Document || node instanceof DocumentFragment))
+      return;
+    for (const hook of beforeProcess) hook(node);
+    const selector = attributes().map((a) => `[${a}]`).join(", ") + ", [type='text/hyperscript']";
+    if (node instanceof Element && node.matches(selector)) initElement(node);
+    node.querySelectorAll(selector).forEach(initElement);
+    for (const hook of afterProcess) hook(node);
+  }
+  function cleanup(elt) {
+    const data = peekData(elt);
+    if (!data) return;
+    triggerEvent(elt, "hyperscript:before:cleanup");
+    for (const { target, event, handler } of data.listeners ?? [])
+      target.removeEventListener(event, handler);
+    for (const observer of data.observers ?? []) observer.disconnect();
+    for (const timer of data.timers ?? []) clearTimeout(timer);
+    rx.stop(elt);
+    elt.querySelectorAll("[data-hyperscript-powered]").forEach(cleanup);
+    triggerEvent(elt, "hyperscript:after:cleanup");
+    elt.removeAttribute("data-hyperscript-powered");
+    dropData(elt);
+  }
+  host.process = processNode;
+  function hostParse(src) {
+    try {
+      const parsed = parse(src);
+      if (parsed.kind === "features") return { ...parsed.program, errors: [] };
+      return { ...parsed.kind === "commands" ? parsed.commands[0] : parsed.expression, errors: [] };
+    } catch (e) {
+      if (e instanceof ParseError) return { errors: [e] };
+      throw e;
+    }
+  }
+  var api = Object.assign(evaluate, {
+    // Upstream's shape: `config.conversions.Foo = …` and `config.conversions.dynamicResolvers.push(…)`.
+    config: Object.assign(config, { conversions: Object.assign(conversions, { dynamicResolvers }) }),
+    /** `use(plugin)`: the plugin receives this object. */
+    use(plugin) {
+      plugin(api);
+    },
+    addBeforeProcessHook: (hook) => void beforeProcess.push(hook),
+    addAfterProcessHook: (hook) => void afterProcess.push(hook),
+    /** Not in upstream: rewrite a script as it is read, leaving the attribute as written. */
+    addSourceTransform: (transform) => void transforms.push(transform),
+    evaluate,
+    parse: hostParse,
+    process: processNode,
+    /** Upstream's older name for `process`. */
+    processNode,
+    cleanup,
+    /** The part of upstream's `internals` that pages and tests reach for. */
+    internals: { runtime: { cleanup, processNode } },
+    version: false ? "dev" : "3.3.0"
+  });
+  function boot() {
+    Object.assign(globalThis, { _hyperscript: api });
+    if (typeof document === "undefined") return;
+    const start = () => {
+      processNode(document.documentElement);
+      document.dispatchEvent(new Event("hyperscript:ready"));
+    };
+    if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", start);
+    else setTimeout(start);
+  }
+
+  // src/on.ts
+  function queueFor(elt, feature2) {
+    if (typeof elt !== "object" || elt === null) return { queue: [], executing: false };
+    const queues = dataOf(elt).eventQueues ??= /* @__PURE__ */ new Map();
+    let queue = queues.get(feature2);
+    if (!queue) queues.set(feature2, queue = { queue: [], executing: false });
+    return queue;
+  }
+  function execute(ctx, feature2) {
+    const info = queueFor(ctx.me, feature2);
+    if (info.executing && !feature2.every) {
+      if (feature2.queue === "none" || feature2.queue === "first" && info.queue.length > 0) return;
+      if (feature2.queue !== "all") info.queue.length = 0;
+      info.queue.push(ctx);
+      return;
+    }
+    info.executing = true;
+    const finish = (failure) => {
+      info.executing = false;
+      const queued = info.queue.shift();
+      if (queued) setTimeout(() => execute(queued, feature2), 1);
+      if (failure) {
+        const { error } = failure;
+        console.error(get(error, "message") ?? error);
+        console.error(get(error, "stack"));
+        triggerEvent(ctx.me, "exception", { error });
+      }
+    };
+    guard(
+      () => then1(runBlock(ctx, feature2.body, feature2), () => finish()),
+      (error) => finish({ error })
+    );
+  }
+  function install(feature2, elt) {
+    if (!isTarget(elt)) return;
+    const data = dataOf(elt);
+    const listeners = data.listeners ??= [];
+    const observers = data.observers ??= [];
+    const timers = data.timers ??= /* @__PURE__ */ new Set();
+    for (const spec of feature2.events) {
+      const state = { execCount: 0 };
+      const targets = spec.elsewhere ? [document] : spec.from ? spec.from.ev(makeContext(elt, feature2, elt, null)) : [elt];
+      implicitLoop(targets, (target) => {
+        if (!isTarget(target)) {
+          console.warn(
+            "'%s' feature ignored because target does not exists:",
+            feature2.displayName,
+            elt
+          );
+          return;
+        }
+        let name = spec.on;
+        if (spec.mutationSpec && target instanceof Node) {
+          name = "hyperscript:mutation";
+          const observer = new MutationObserver(
+            (mutationList) => triggerEvent(target, name, { mutationList, observer })
+          );
+          observer.observe(target, spec.mutationSpec);
+          observers.push(observer);
+        }
+        if (spec.intersectionSpec && target instanceof Element) {
+          name = "hyperscript:intersection";
+          const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+              triggerEvent(target, name, {
+                observer,
+                entry,
+                intersecting: entry.isIntersecting,
+                isIntersecting: entry.isIntersecting,
+                intersectionRatio: entry.intersectionRatio
+              });
+            }
+          }, spec.intersectionSpec);
+          observer.observe(target);
+          observers.push(observer);
+        }
+        if (spec.resizeSpec && target instanceof Element) {
+          name = "hyperscript:resize";
+          const observer = new ResizeObserver((entries) => {
+            for (const entry of entries) {
+              const { width, height } = entry.contentRect;
+              triggerEvent(target, name, { width, height, contentRect: entry.contentRect, entry });
+            }
+          });
+          observer.observe(target);
+          observers.push(observer);
+        }
+        const handler = (event) => {
+          if (elt instanceof Node && target !== elt && !elt.isConnected) {
+            target.removeEventListener(name, handler);
+            return;
+          }
+          const ctx = makeContext(elt, feature2, elt, event);
+          if (spec.elsewhere && elt instanceof Node && event.target instanceof Node && elt.contains(event.target))
+            return;
+          if (spec.from) ctx.result = target;
+          for (const arg of spec.args) {
+            const fromEvent = get(event, arg);
+            if (fromEvent !== void 0) ctx.locals[arg] = fromEvent;
+            else if (ctx.detail != null) ctx.locals[arg] = get(ctx.detail, arg);
+          }
+          if (spec.filter) {
+            ctx.meta.context = event;
+            try {
+              if (!spec.filter.ev(ctx)) return;
+            } finally {
+              ctx.meta.context = void 0;
+            }
+          }
+          if (spec.inExpr?.css) {
+            let match = event.target instanceof Element ? event.target : null;
+            while (match && !match.matches(spec.inExpr.css)) match = match.parentElement;
+            if (!match) return;
+            ctx.result = match;
+          }
+          state.execCount++;
+          if (spec.startCount) {
+            const count = state.execCount;
+            if (spec.endCount ? count < spec.startCount || count > spec.endCount : spec.unbounded ? count < spec.startCount : count !== spec.startCount)
+              return;
+          }
+          if (spec.debounceTime) {
+            if (state.debounced) {
+              clearTimeout(state.debounced);
+              timers.delete(state.debounced);
+            }
+            timers.add(
+              state.debounced = setTimeout(() => execute(ctx, feature2), spec.debounceTime)
+            );
+            return;
+          }
+          if (spec.throttleTime) {
+            if (state.lastExec && Date.now() < state.lastExec + spec.throttleTime) return;
+            state.lastExec = Date.now();
+          }
+          execute(ctx, feature2);
+        };
+        target.addEventListener(name, handler);
+        listeners.push({ target, event: name, handler });
+      });
+    }
+  }
+  function mutationSpec(p) {
+    if (!p.match("of")) {
+      return {
+        attributes: true,
+        characterData: true,
+        childList: true,
+        attributeOldValue: true,
+        characterDataOldValue: true
+      };
+    }
+    const spec = {};
+    do {
+      if (p.match("anything"))
+        Object.assign(spec, {
+          attributes: true,
+          subtree: true,
+          characterData: true,
+          childList: true
+        });
+      else if (p.match("childList")) spec.childList = true;
+      else if (p.match("attributes")) spec.attributes = true;
+      else if (p.match("subtree")) spec.subtree = true;
+      else if (p.match("characterData")) spec.characterData = true;
+      else if (p.cur().type === "ATTRIBUTE_REF") {
+        const attribute = p.consume().value;
+        if (!attribute.startsWith("@")) p.err("Only shorthand attribute references are allowed here");
+        (spec.attributeFilter ??= []).push(attribute.substring(1));
+      } else p.err("Unknown mutation config specification");
+    } while (p.match("or"));
+    if (spec.attributes || spec.attributeFilter) spec.attributeOldValue = true;
+    if (spec.characterData) spec.characterDataOldValue = true;
+    return spec;
+  }
+  function intersectionSpec(p) {
+    const spec = {};
+    if (p.match("with")) {
+      const root = evalStatic(expr(p));
+      if (root instanceof Element) spec.root = root;
+    }
+    if (p.match("having")) {
+      do {
+        if (p.match("margin")) spec.rootMargin = stringLike(p);
+        else if (p.match("threshold")) spec.threshold = Number(evalStatic(expr(p)));
+        else p.err("Unknown intersection config specification");
+      } while (p.match("and"));
+    }
+    return spec;
+  }
+  function eventSpec(p, first) {
+    const on2 = eventName(p);
+    const args = eventArgs(p);
+    let filter;
+    if (p.matchOp("[")) {
+      filter = expr(p);
+      p.reqOp("]");
+    }
+    let startCount;
+    let endCount;
+    let unbounded = false;
+    if (first) startCount = 1;
+    else if (p.cur().type === "NUMBER") {
+      startCount = parseInt(p.consume().value);
+      if (p.match("to")) endCount = parseInt(p.consume().value);
+      else if (p.match("and")) {
+        unbounded = true;
+        p.req("on");
+      }
+    }
+    const spec = {
+      on: on2,
+      args,
+      filter,
+      startCount,
+      endCount,
+      unbounded,
+      elsewhere: false,
+      resizeSpec: on2 === "resize"
+    };
+    if (on2 === "intersection") spec.intersectionSpec = intersectionSpec(p);
+    else if (on2 === "mutation") spec.mutationSpec = mutationSpec(p);
+    if (p.match("from")) {
+      if (p.match("elsewhere")) spec.elsewhere = true;
+      else spec.from = p.withFollow(["or"], () => expr(p));
+    }
+    if (!spec.from && !spec.elsewhere && p.match("elsewhere")) spec.elsewhere = true;
+    if (p.match("in")) spec.inExpr = unary(p);
+    const time = () => {
+      p.req("at");
+      return Number(evalStatic(unary(p)));
+    };
+    if (p.match("debounced")) spec.debounceTime = time();
+    else if (p.match("throttled")) spec.throttleTime = time();
+    return spec;
+  }
+  function on(g) {
+    g.features.on = (p, start) => {
+      const every = !!p.match("every");
+      const first = !every && !!p.match("first");
+      const events = [];
+      do
+        events.push(eventSpec(p, first));
+      while (p.match("or"));
+      let queue = "last";
+      if (!every && p.match("queue")) {
+        if (p.match("all")) queue = "all";
+        else if (p.match("first")) queue = "first";
+        else if (p.match("none")) queue = "none";
+        else p.req("last");
+      }
+      const body = commandList(p);
+      const feature2 = {
+        type: "onFeature",
+        displayName: "on " + events.map((e) => e.on).join(" or "),
+        events,
+        body,
+        every,
+        queue,
+        ...errorAndFinally(p),
+        start,
+        end: p.endPos(),
+        install: (target) => install(feature2, target)
+      };
+      return feature2;
+    };
+  }
+
+  // src/bundles/common.ts
+  register(on, add, remove, toggle, hideShow, set2, put, increment, ifCommand, halt, send, wait, log, get_, pseudoCommand);
+  boot();
+})();