@manyducks.co/dolla 2.0.0-alpha.56 → 2.0.0-alpha.58

package/dist/markup-BJx8Fwl2.js

@@ -0,0 +1,1019 @@
+var at = Object.defineProperty;
+var B = (o) => {
+  throw TypeError(o);
+};
+var ht = (o, t, e) => t in o ? at(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var c = (o, t, e) => ht(o, typeof t != "symbol" ? t + "" : t, e), W = (o, t, e) => t.has(o) || B("Cannot " + e);
+var L = (o, t, e) => (W(o, t, "read from private field"), e ? e.call(o) : t.get(o)), D = (o, t, e) => t.has(o) ? B("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(o) : t.set(o, e), $ = (o, t, e, s) => (W(o, t, "write to private field"), s ? s.call(o, e) : t.set(o, e), e);
+import { c as f, t as ut, g as X, b as U, i as tt } from "./typeChecking-BJ-ymQ2F.js";
+import { u as S, f as lt, g as w, j as et, e as g, b as dt, k as ft, l as mt, $ as T, d as pt } from "./logger-C2AJnlaL.js";
+const A = Symbol("name"), u = Symbol("lifecycle"), p = Symbol("parent"), y = Symbol("stores"), b = Symbol("state");
+class bt {
+  constructor(t) {
+    c(this, "context");
+    c(this, "state", 0);
+    c(this, "listeners", /* @__PURE__ */ new Map());
+    c(this, "bound");
+    this.context = t;
+  }
+  /**
+   * Listen for a certain event to be emitted. Listeners are called when the event results in a state change.
+   */
+  on(t, e) {
+    const s = this.listeners.get(t);
+    s ? s.add(e) : this.listeners.set(t, /* @__PURE__ */ new Set([e]));
+  }
+  /**
+   * Stop a particular listener from being called when an event is emitted.
+   */
+  off(t, e) {
+    const s = this.listeners.get(t);
+    s && (s.delete(e), s.size === 0 && this.listeners.delete(t));
+  }
+  /**
+   * Advance the lifecycle state machine.
+   */
+  emit(t) {
+    switch (t) {
+      case 0: {
+        this.state < 1 ? (this.state = 1, this.notify(t)) : this.context.crash(new Error(`Tried to WILL_MOUNT context at state ${this.state}`));
+        break;
+      }
+      case 1: {
+        this.state >= 1 && this.state < 2 ? (this.state = 2, this.notify(t)) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 2: {
+        this.state >= 2 && this.state < 3 ? (this.notify(t), this.state = 3) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 3: {
+        this.state >= 3 && this.state < 4 ? (this.state = 4 % 4, this.notify(t)) : this.context.crash(new Error(`Tried to DID_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 4: {
+        this.state === 0 ? (this.notify(t), this.listeners.clear(), this.bound = void 0, this.state = 5) : this.context.crash(new Error(`Tried to DISPOSE context at state ${this.state}`));
+        break;
+      }
+    }
+  }
+  /**
+   * Bind `context` to this lifecycle; when any event is emitted here it will be emitted for `context` as well.
+   */
+  bind(t) {
+    this.bound ? this.bound.add(t) : this.bound = /* @__PURE__ */ new Set([t]);
+  }
+  /**
+   * Call all the event's listeners and re-emit to bound contexts.
+   */
+  notify(t) {
+    const e = this.listeners.get(t);
+    if (e)
+      for (const s of e)
+        s();
+    if (this.bound)
+      for (const s of this.bound)
+        s[u].emit(t);
+  }
+}
+var R, q, G, H, z, v;
+z = A, H = u, G = p, q = y, R = b;
+const N = class N {
+  constructor(t, e) {
+    D(this, v);
+    c(this, z);
+    c(this, H, new bt(this));
+    c(this, G);
+    c(this, q);
+    c(this, R);
+    $(this, v, t), this[A] = S(t);
+    const s = lt(() => w(L(this, v)), e == null ? void 0 : e.logger), i = Object.getOwnPropertyDescriptors(s);
+    for (const n in i)
+      Object.defineProperty(this, n, i[n]);
+  }
+  get isMounted() {
+    const { state: t } = this[u];
+    return t >= 2 && t < 4;
+  }
+  /**
+   * Returns a new Context with this one as its parent.
+   */
+  static linked(t, e, s) {
+    const i = new N(e, s);
+    return i[p] = t, s != null && s.bindLifecycleToParent && t[u].bind(i), i;
+  }
+  /**
+   * Emit "will mount" lifecycle event to `context`.
+   */
+  static willMount(t) {
+    t[u].emit(
+      0
+      /* WILL_MOUNT */
+    );
+  }
+  /**
+   * Emit "did mount" lifecycle event to `context`.
+   */
+  static didMount(t) {
+    t[u].emit(
+      1
+      /* DID_MOUNT */
+    );
+  }
+  /**
+   * Emit "will unmount" lifecycle event to `context`.
+   */
+  static willUnmount(t) {
+    t[u].emit(
+      2
+      /* WILL_UNMOUNT */
+    );
+  }
+  /**
+   * Emit "did unmount" lifecycle event to `context`.
+   */
+  static didUnmount(t) {
+    t[u].emit(
+      3
+      /* DID_UNMOUNT */
+    );
+  }
+  /**
+   * Emit "dispose" lifecycle event to `context`.
+   */
+  static dispose(t) {
+    t[u].emit(
+      4
+      /* DISPOSE */
+    ), t[b] = void 0, t[y] = void 0;
+  }
+  /**
+   * Traverses _parent contexts until arriving at one that doesn't have a parent itself.
+   * Returns null if this context is the parent.
+   */
+  static getRoot(t) {
+    let e = t[p];
+    for (; e != null && e[p]; )
+      e = e[p];
+    return e ?? null;
+  }
+  /**
+   * Returns the current name of this context.
+   */
+  getName() {
+    return S(L(this, v));
+  }
+  /**
+   * Sets a new name for this context.
+   */
+  setName(t) {
+    $(this, v, t), this[A] = S(t);
+  }
+  /**
+   * Creates an instance of a store and attaches it to this context.
+   */
+  addStore(t, e) {
+    var i;
+    if ((i = this[y]) != null && i.get(t)) {
+      let n = t.name ? `'${t.name}'` : "this store";
+      throw this.crash(new I(`An instance of ${n} was already added on this context.`));
+    }
+    const s = N.linked(this, t.name, {
+      bindLifecycleToParent: !0,
+      logger: { tag: et(), tagName: "uid" }
+    });
+    try {
+      this[y] || (this[y] = /* @__PURE__ */ new Map());
+      const n = t.call(s, e, s);
+      this[y].set(t, n);
+    } catch (n) {
+      throw this.crash(n);
+    }
+    return this;
+  }
+  /**
+   * Retrieves the nearest instance of `store`. If this context doesn't have it, the parent context is checked. This process continues until either:
+   * 1. An instance of the store is found and returned.
+   * 2. No instance is found and an error is thrown.
+   */
+  getStore(t) {
+    var i;
+    if (!f(t))
+      throw new I("Invalid store.");
+    let e = this, s;
+    for (; s = (i = e[y]) == null ? void 0 : i.get(t), s == null && e[p] != null; )
+      e = e[p];
+    if (s == null)
+      throw this.crash(new I(`Store '${t.name}' is not provided by this context.`));
+    return s;
+  }
+  /**
+   * Schedule a callback function to run just before this context is mounted.
+   */
+  beforeMount(t) {
+    return this[u].on(0, t), () => this[u].off(0, t);
+  }
+  /**
+   * Schedule a callback function to run after this context is mounted.
+   */
+  onMount(t) {
+    return this[u].on(1, t), () => this[u].off(1, t);
+  }
+  /**
+   * Schedule a callback function to run just before this context is unmounted.
+   */
+  beforeUnmount(t) {
+    return this[u].on(2, t), () => this[u].off(2, t);
+  }
+  /**
+   * Schedule a callback function to run after this context is unmounted.
+   */
+  onUnmount(t) {
+    return this[u].on(3, t), () => this[u].off(3, t);
+  }
+  effect(t) {
+    const e = () => {
+      try {
+        return t();
+      } catch (s) {
+        this.error(s), s instanceof Error ? this.crash(s) : typeof s == "string" ? this.crash(new Error(s)) : this.crash(new Error("Unknown error thrown in effect callback"));
+      }
+    };
+    if (this[u].state >= 1) {
+      const s = g(e);
+      return this[u].on(3, s), s;
+    } else {
+      let s, i = !1;
+      return this[u].on(0, () => {
+        i || (s = g(e), this[u].on(3, s));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+  getState(t, e) {
+    var s;
+    if (arguments.length > 0) {
+      let i = this, n;
+      for (; n = (s = i[b]) == null ? void 0 : s.get(t), n === void 0 && i[p] != null; )
+        i = i[p];
+      if (n === void 0) {
+        if (arguments.length > 1)
+          return e;
+        throw new Error(`Expected a value for '${String(t)}' but got undefined.`);
+      }
+      return n;
+    } else {
+      let i = this;
+      const n = [];
+      for (; i[b] && n.push(...i[b].entries()), i[p] != null; )
+        i = i[p];
+      return new Map(n.reverse());
+    }
+  }
+  setState() {
+    if (this[b] || (this[b] = /* @__PURE__ */ new Map()), arguments.length === 2)
+      this[b].set(arguments[0], arguments[1]);
+    else if (ut(arguments[0]) === "array")
+      for (const [t, e] of arguments[0])
+        e === void 0 ? this[b].delete(t) : this[b].set(t, e);
+    else
+      throw new Error("Invalid arguments.");
+    return this;
+  }
+};
+v = new WeakMap();
+let l = N;
+function At(o, t) {
+  return new l(o, t);
+}
+class I extends Error {
+}
+const x = Symbol.for("dollaMarkupNode");
+var F;
+F = x;
+class E {
+  constructor(t) {
+    c(this, F, !0);
+    c(this, "root");
+    this.root = t;
+  }
+  isMounted() {
+    return this.root.parentNode != null;
+  }
+  mount(t, e) {
+    t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+  }
+  unmount(t = !1) {
+    this.root.parentNode && !t && this.root.parentNode.removeChild(this.root);
+  }
+  move(t, e) {
+    if ("moveBefore" in t && this.root instanceof Element)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+}
+var Z;
+Z = x;
+class C {
+  constructor(t, e) {
+    c(this, Z, !0);
+    c(this, "root", document.createTextNode(""));
+    c(this, "children", []);
+    c(this, "context");
+    c(this, "$slot");
+    c(this, "unsubscribe");
+    this.context = t, this.$slot = e;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, e) {
+    this.isMounted() || (t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.unsubscribe = g(() => {
+      try {
+        const s = this.$slot();
+        S(() => {
+          this.update(X(s) ? s : [s]);
+        });
+      } catch (s) {
+        this.context.crash(s);
+      }
+    }));
+  }
+  unmount(t = !1) {
+    var e, s;
+    (e = this.unsubscribe) == null || e.call(this), this.isMounted() && (this.cleanup(t), (s = this.root.parentNode) == null || s.removeChild(this.root));
+  }
+  move(t, e) {
+    var s, i, n;
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+        for (let r = 0; r < this.children.length; r++)
+          this.children[r].move(t, ((s = this.children[r - 1]) == null ? void 0 : s.root) ?? this.root);
+        t.moveBefore(this.root, ((n = (i = this.children.at(-1)) == null ? void 0 : i.root) == null ? void 0 : n.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+  cleanup(t) {
+    for (const e of this.children)
+      e.isMounted() && e.unmount(t);
+    this.children.length = 0;
+  }
+  update(t) {
+    var s;
+    if (this.cleanup(!1), t.length === 0 || !this.isMounted()) return;
+    const e = _(this.context, t);
+    for (const i of e) {
+      const n = ((s = this.children.at(-1)) == null ? void 0 : s.root) || this.root;
+      i.mount(this.root.parentElement, n), this.children.push(i);
+    }
+    this.moveMarker();
+  }
+  /**
+   * Move marker node to end of children.
+   */
+  moveMarker() {
+    var s, i;
+    const t = this.root.parentElement, e = ((i = (s = this.children.at(-1)) == null ? void 0 : s.root) == null ? void 0 : i.nextSibling) ?? null;
+    "moveBefore" in t ? t.moveBefore(this.root, e) : t.insertBefore(this.root, e);
+  }
+}
+const st = Symbol("View");
+var K;
+K = x;
+class it {
+  constructor(t, e, s) {
+    c(this, K, !0);
+    c(this, "uniqueId", et());
+    c(this, "context");
+    c(this, "props");
+    c(this, "view");
+    c(this, "node");
+    this.context = l.linked(t, e.name ?? "anonymous view", {
+      logger: {
+        tag: this.uniqueId,
+        tagName: "uid"
+      }
+    }), this.context.setState(st, this), this.props = s, this.view = e;
+  }
+  get root() {
+    var t;
+    return (t = this.node) == null ? void 0 : t.root;
+  }
+  isMounted() {
+    var t;
+    return ((t = this.node) == null ? void 0 : t.isMounted()) ?? !1;
+  }
+  mount(t, e) {
+    const s = this.isMounted();
+    if (!s) {
+      const { context: i, props: n, view: r } = this;
+      try {
+        const a = r.call(i, n, i);
+        a != null && a !== !1 && (this.node = ct(a, i));
+      } catch (a) {
+        throw a instanceof Error && i.crash(a), a;
+      }
+      l.willMount(this.context);
+    }
+    this.node && this.node.mount(t, e), s || l.didMount(this.context);
+  }
+  unmount(t = !1) {
+    l.willUnmount(this.context), this.node && this.node.unmount(t), l.didUnmount(this.context), l.dispose(this.context);
+  }
+  move(t, e) {
+    var s;
+    (s = this.node) == null || s.move(t, e);
+  }
+}
+const gt = (o) => /^on[A-Z]/.test(o), P = Symbol("HTML.isSVG");
+var Y;
+Y = x;
+class wt {
+  constructor(t, e, s) {
+    c(this, Y, !0);
+    c(this, "root");
+    c(this, "parentContext");
+    c(this, "context");
+    c(this, "tag");
+    c(this, "props");
+    c(this, "childNodes", []);
+    c(this, "unsubscribers", []);
+    // Track the ref so we can nullify it on unmount.
+    c(this, "ref");
+    // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+    c(this, "canClickAway", !1);
+    if (this.parentContext = t, this.tag = e, this.props = s, this.context = l.linked(this.parentContext, V.bind(this)), e.toLowerCase() === "svg" && this.context.setState(P, !0), this.context.getState(P, !1) ? this.root = document.createElementNS("http://www.w3.org/2000/svg", e) : this.root = document.createElement(e), dt() === "development") {
+      const n = this.context.getState(st, null);
+      n && (this.root.dataset.view = n.context.getName());
+    }
+    if (s.mixin) {
+      const n = X(s.mixin) ? s.mixin : [s.mixin];
+      for (const r of n)
+        r(
+          this.root,
+          l.linked(this.context, V.bind(this), {
+            bindLifecycleToParent: !0,
+            logger: { tagName: r.name === "mixin" ? void 0 : "mixin", tag: r.name }
+          })
+        );
+    }
+    const i = s.className ?? s.class;
+    if (this.applyProps(this.root, ft(["class", "className", "ref", "mixin", "children"], s)), s.style && this.applyStyles(this.root, s.style, this.unsubscribers), i && this.applyClasses(this.root, i, this.unsubscribers), s.ref)
+      if (f(s.ref))
+        this.ref = s.ref, this.ref(this.root);
+      else
+        throw new Error("Expected ref to be a function. Got: " + s.ref);
+    s.children && (this.childNodes = _(this.context, s.children));
+  }
+  isMounted() {
+    return this.context.isMounted;
+  }
+  mount(t, e) {
+    const s = this.isMounted();
+    if (!s) {
+      l.willMount(this.context);
+      for (let i = 0; i < this.childNodes.length; i++) {
+        const n = this.childNodes[i], r = i > 0 ? this.childNodes[i - 1].root : void 0;
+        n.mount(this.root, r);
+      }
+    }
+    t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.canClickAway = !0, s || l.didMount(this.context);
+  }
+  unmount(t = !1) {
+    var e;
+    l.willUnmount(this.context), t || (e = this.root.parentNode) == null || e.removeChild(this.root);
+    for (const s of this.childNodes)
+      s.unmount(!0);
+    this.canClickAway = !1;
+    for (const s of this.unsubscribers)
+      s();
+    this.unsubscribers.length = 0, this.ref && this.ref(void 0), l.didUnmount(this.context), l.dispose(this.context);
+  }
+  move(t, e) {
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+  attachProp(t, e) {
+    f(t) ? this.unsubscribers.push(
+      g(() => {
+        try {
+          e(t());
+        } catch (s) {
+          this.context.error(s), this.context.crash(s);
+        }
+      })
+    ) : e(t);
+  }
+  applyProps(t, e) {
+    const s = this.context;
+    for (const i in e) {
+      const n = e[i];
+      if (i === "on:clickoutside" || i === "onClickOutside" || i === "onclickoutside") {
+        const r = (d) => {
+          this.canClickAway && !t.contains(d.target) && n(d);
+        }, a = { capture: !0 };
+        window.addEventListener("click", r, a), this.unsubscribers.push(() => {
+          window.removeEventListener("click", r, a);
+        });
+      } else if (f(n) && gt(i)) {
+        const r = i.slice(2).toLowerCase(), a = n;
+        t.addEventListener(r, a), this.unsubscribers.push(() => {
+          t.removeEventListener(r, a);
+        });
+      } else if (i.startsWith("on") && f(n) && vt.includes(i.substring(2)))
+        t[i] = n, this.unsubscribers.push(() => {
+          t[i] = void 0;
+        });
+      else if (i.includes("-"))
+        this.attachProp(n, (r) => {
+          r == null ? t.removeAttribute(i) : t.setAttribute(i, String(r));
+        });
+      else if (!yt.includes(i))
+        if (s.getState(P, !1))
+          this.attachProp(n, (r) => {
+            r != null ? t.setAttribute(i, String(e[i])) : t.removeAttribute(i);
+          });
+        else
+          switch (i) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(n, (r) => {
+                t[i] = String(r);
+              });
+              break;
+            case "for":
+              this.attachProp(n, (r) => {
+                t.htmlFor = r;
+              });
+              break;
+            case "innerHTML":
+              this.attachProp(n, (r) => {
+                t.innerHTML = r;
+              });
+              break;
+            case "title":
+              this.attachProp(n, (r) => {
+                r == null ? t.removeAttribute(i) : t.setAttribute(i, String(r));
+              });
+            case "checked":
+              this.attachProp(n, (r) => {
+                t.checked = r, r ? t.setAttribute("checked", "") : t.removeAttribute("checked");
+              });
+              break;
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(n, (r) => {
+                typeof r == "string" ? t[i] = r : r ? t[i] = "on" : t[i] = "off";
+              });
+              break;
+            default: {
+              if (i.startsWith("prop:")) {
+                const r = i.substring(5);
+                this.attachProp(n, (a) => {
+                  t[r] = a;
+                });
+              } else if (i.startsWith("on:")) {
+                const r = i.substring(3);
+                let a;
+                f(n) ? (t.addEventListener(r, n), this.unsubscribers.push(() => {
+                  t.removeEventListener(r, n);
+                })) : this.attachProp(n, (d) => {
+                  !d && a ? t.removeEventListener(r, a) : d != null && (a && a !== d && t.removeEventListener(r, a), t.addEventListener(r, d)), a = d;
+                });
+              } else if (i.startsWith("attr:")) {
+                const r = i.substring(5).toLowerCase();
+                this.attachProp(n, (a) => {
+                  a != null ? t.setAttribute(r, String(a)) : t.removeAttribute(r);
+                });
+              } else
+                this.attachProp(n, (r) => {
+                  t[i] = r;
+                });
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(t, e, s) {
+    const i = [];
+    if (f(e)) {
+      let n;
+      const r = g(() => {
+        f(n) && n(), t.style.cssText = "", n = this.applyStyles(t, w(e), s);
+      });
+      s.push(r), i.push(r);
+    } else {
+      const n = ot(e);
+      for (const r in n) {
+        const { value: a, priority: d } = n[r];
+        if (f(a)) {
+          const h = g(() => {
+            w(a) ? t.style.setProperty(r, String(w(a)), d) : t.style.removeProperty(r);
+          });
+          s.push(h), i.push(h);
+        } else a != null && t.style.setProperty(r, String(a));
+      }
+    }
+    return function() {
+      for (const r of i)
+        r(), s.splice(s.indexOf(r), 1);
+    };
+  }
+  applyClasses(t, e, s) {
+    const i = [];
+    if (f(e)) {
+      let n;
+      const r = g(() => {
+        f(n) && n(), t.removeAttribute("class"), n = this.applyClasses(t, w(e), s);
+      });
+      s.push(r), i.push(r);
+    } else {
+      const n = nt(e);
+      for (const r in n) {
+        const a = n[r];
+        if (f(a)) {
+          const d = g(() => {
+            w(a) ? t.classList.add(r) : t.classList.remove(r);
+          });
+          s.push(d), i.push(d);
+        } else a && t.classList.add(r);
+      }
+    }
+    return function() {
+      for (const r of i)
+        r(), s.splice(s.indexOf(r), 1);
+    };
+  }
+}
+function nt(o) {
+  let t = {};
+  if (U(o)) {
+    const e = o.split(" ");
+    for (const s of e)
+      t[s] = !0;
+  } else tt(o) ? Object.assign(t, o) : Array.isArray(o) && Array.from(o).filter(Boolean).forEach((e) => {
+    Object.assign(t, nt(e));
+  });
+  return delete t.undefined, t;
+}
+function ot(o) {
+  let t = {};
+  if (U(o)) {
+    const e = o.split(";").filter((s) => s.trim() !== "");
+    for (const s of e) {
+      const [i, n] = s.split(":"), r = {
+        value: n
+      };
+      n.includes("!important") ? (r.priority = "important", r.value = n.replace("!important", "").trim()) : r.value = n.trim(), t[j(i.trim())] = r;
+    }
+  }
+  if (tt(o))
+    for (const e in o)
+      e.startsWith("--") ? t[e] = { value: o[e] } : t[j(e)] = { value: o[e] };
+  else Array.isArray(o) && Array.from(o).filter((e) => e != null).forEach((e) => {
+    Object.assign(t, ot(e));
+  });
+  return t;
+}
+function V() {
+  if (this.root == null) return this.tag;
+  let o = this.root.tagName.toLowerCase();
+  if (this.root.id && (o += `#${this.root.id}`), this.root.classList.length > 0)
+    for (const t of this.root.classList.values())
+      o += `.${t}`;
+  return o;
+}
+function j(o) {
+  return o.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, e) => (e ? "-" : "") + t.toLowerCase());
+}
+const yt = ["ref", "children", "class", "style", "data", "mixin"], vt = [
+  // Element
+  "animationcancel",
+  "animationend",
+  "animationiteration",
+  "animationstart",
+  "auxclick",
+  "beforeinput",
+  "beforematch",
+  "beforexrselect",
+  "blur",
+  "click",
+  "compositionend",
+  "compositionstart",
+  "compositionupdate",
+  "contentvisibilityautostatechange",
+  "contextmenu",
+  "copy",
+  "cut",
+  "dblclick",
+  "focus",
+  "focusin",
+  "focusout",
+  "fullscreenchange",
+  "fullscreenerror",
+  "gotpointercapture",
+  "input",
+  "keydown",
+  "keyup",
+  "lostpointercapture",
+  "mousedown",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "paste",
+  "pointercancel",
+  "pointerdown",
+  "pointerenter",
+  "pointerleave",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerrawupdate",
+  "pointerup",
+  "scroll",
+  "scrollend",
+  "scrollsnapchange",
+  "scrollsnapchanging",
+  "securitypolicyviolation",
+  "touchcancel",
+  "touchend",
+  "touchmove",
+  "touchstart",
+  "transitioncancel",
+  "transitionend",
+  "transitionrun",
+  "transitionstart",
+  "webkitmouseforcechanged",
+  "webkitmouseforcedown",
+  "webkitmouseforceup",
+  "webkimouseforcewillbegin",
+  "wheel",
+  // HTMLElement
+  "beforetoggle",
+  "change",
+  "command",
+  "drag",
+  "dragend",
+  "dragenter",
+  "dragleave",
+  "dragover",
+  "dragstart",
+  "drop",
+  "error",
+  "load",
+  "toggle",
+  // HTMLInputElement
+  "cancel",
+  "invalid",
+  "search",
+  "select",
+  "selectionchange",
+  // HTMLFormElement
+  "formdata",
+  "reset",
+  "submit"
+];
+var J;
+J = x;
+class xt {
+  constructor(t, e, s) {
+    c(this, J, !0);
+    c(this, "context");
+    c(this, "content");
+    c(this, "parent");
+    c(this, "element");
+    this.context = t, this.content = e, this.parent = s;
+  }
+  isMounted() {
+    return this.element ? this.element.isMounted() : !1;
+  }
+  mount(t, e) {
+    this.element = ct(this.content, this.context), this.element.mount(this.parent);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.element) != null && e.isMounted() && this.element.unmount(!1);
+  }
+  move(t, e) {
+  }
+}
+var Q;
+Q = x;
+class kt {
+  constructor(t, e, s, i) {
+    c(this, Q, !0);
+    c(this, "root", document.createTextNode(""));
+    c(this, "context");
+    c(this, "items");
+    c(this, "key");
+    c(this, "render");
+    c(this, "unsubscribe", null);
+    c(this, "connectedItems", /* @__PURE__ */ new Map());
+    this.context = t, this.items = e, this.key = s, this.render = i;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, e) {
+    this.isMounted() || (t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.unsubscribe = g(() => {
+      let s = this.items();
+      s == null && (s = [], this.context.warn("repeat() received empty value for items", s)), S(() => {
+        this._update(Array.from(s));
+      });
+    }));
+  }
+  unmount(t = !1) {
+    var e;
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = null), !t && this.isMounted() && ((e = this.root.parentNode) == null || e.removeChild(this.root)), this._cleanup(t);
+  }
+  move(t, e) {
+    return this.mount(t, e);
+  }
+  _cleanup(t) {
+    for (const e of this.connectedItems.values())
+      e.node.unmount(t);
+    this.connectedItems.clear();
+  }
+  _update(t) {
+    var r, a, d;
+    if (t.length === 0 || !this.isMounted())
+      return this._cleanup(!1);
+    const e = /* @__PURE__ */ new Map();
+    let s = 0;
+    for (const h of t) {
+      const m = this.key(h, s);
+      e.set(m, {
+        key: m,
+        value: h,
+        index: s++
+      });
+    }
+    const i = [];
+    for (const h of this.connectedItems.values())
+      !e.has(h.key) && h.node.isMounted() && h.node.unmount(!1);
+    mt(() => {
+      for (const h of e.values()) {
+        const m = this.connectedItems.get(h.key);
+        if (m && m.node.isMounted())
+          m.$item(h.value), m.$index(h.index), i[h.index] = m;
+        else {
+          const k = T(h.value, { equals: pt }), M = T(h.index);
+          i[h.index] = {
+            key: h.key,
+            $item: k,
+            $index: M,
+            node: new it(this.context, Mt, {
+              $item: () => k(),
+              $index: () => M(),
+              render: this.render
+            })
+          };
+        }
+      }
+    });
+    for (let h = 0; h < i.length; h++) {
+      const m = i[h], k = ((r = i[h - 1]) == null ? void 0 : r.node.root) ?? this.root, M = this.connectedItems.get(m.key);
+      M && M.node.isMounted() ? m.node.move(this.root.parentElement, k) : m.node.mount(this.root.parentElement, k);
+    }
+    this.connectedItems.clear();
+    for (const h of i)
+      this.connectedItems.set(h.key, h);
+    const n = ((a = i.at(-1)) == null ? void 0 : a.node.root) ?? this.root;
+    (d = this.root.parentNode) == null || d.insertBefore(this.root, n.nextSibling);
+  }
+}
+function Mt(o, t) {
+  return t.setName("@RepeatItemView"), o.render.call(t, o.$item, o.$index, t);
+}
+class rt {
+  constructor(t, e) {
+    /**
+     * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
+     * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
+     */
+    c(this, "type");
+    /**
+     * Data that will be passed to a new MarkupNode instance when it is constructed.
+     * Includes a `children` prop if children were passed.
+     */
+    c(this, "props");
+    this.type = t, this.props = e;
+  }
+}
+function St(o) {
+  return (o == null ? void 0 : o[x]) === !0;
+}
+function O(o, t) {
+  return new rt(o, t ?? {});
+}
+function Et(o, t, e) {
+  return O("$dynamic", {
+    source: T(() => {
+      const s = w(o);
+      return s && t ? t : !s && e ? e : null;
+    })
+  });
+}
+function It(o, t, e) {
+  return Et(o, e, t);
+}
+function Pt(o, t, e) {
+  return O("$repeat", { items: () => w(o), key: t, render: e });
+}
+function Tt(o, t) {
+  return O("$portal", { parent: o, content: t });
+}
+function ct(o, t = new l("$")) {
+  const e = _(t, [o]);
+  return e.length === 1 ? e[0] : new C(t, () => e);
+}
+function _(o, ...t) {
+  const e = t.flat(1 / 0), s = [];
+  for (const i of e)
+    if (!(i == null || i === !1)) {
+      if (i instanceof Node) {
+        s.push(new E(i));
+        continue;
+      }
+      if (i instanceof rt)
+        if (f(i.type)) {
+          s.push(new it(o, i.type, i.props));
+          continue;
+        } else if (U(i.type))
+          switch (i.type) {
+            case "$dom": {
+              const n = i.props;
+              s.push(new E(n.value));
+              continue;
+            }
+            case "$text": {
+              const n = i.props;
+              s.push(new E(document.createTextNode(String(n.value))));
+              continue;
+            }
+            case "$repeat": {
+              const n = i.props;
+              s.push(new kt(o, n.items, n.key, n.render));
+              continue;
+            }
+            case "$dynamic": {
+              const n = i.props;
+              s.push(new C(o, n.source));
+              continue;
+            }
+            case "$portal": {
+              const n = i.props;
+              s.push(new xt(o, n.content, n.parent));
+              continue;
+            }
+            default:
+              s.push(new wt(o, i.type, i.props));
+              continue;
+          }
+        else
+          throw new TypeError(`Expected a string or view function. Got: ${i.type}`);
+      if (St(i)) {
+        s.push(i);
+        continue;
+      }
+      if (f(i)) {
+        s.push(new C(o, i));
+        continue;
+      }
+      s.push(new E(document.createTextNode(String(i))));
+    }
+  return s;
+}
+export {
+  l as C,
+  C as D,
+  rt as M,
+  it as V,
+  Pt as a,
+  At as c,
+  O as m,
+  Tt as p,
+  ct as r,
+  It as u,
+  Et as w
+};
+//# sourceMappingURL=markup-BJx8Fwl2.js.map