@manyducks.co/dolla 2.0.0-alpha.41 → 2.0.0-alpha.43

package/dist/markup-CSJbSI8_.js

@@ -0,0 +1,1529 @@
+var Oe = Object.defineProperty;
+var oe = (t) => {
+  throw TypeError(t);
+};
+var $e = (t, e, s) => e in t ? Oe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var l = (t, e, s) => $e(t, typeof e != "symbol" ? e + "" : e, s), F = (t, e, s) => e.has(t) || oe("Cannot " + s);
+var w = (t, e, s) => (F(t, e, "read from private field"), s ? s.call(t) : e.get(t)), L = (t, e, s) => e.has(t) ? oe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), $ = (t, e, s, n) => (F(t, e, "write to private field"), n ? n.call(t, s) : e.set(t, s), s), ue = (t, e, s) => (F(t, e, "access private method"), s);
+var M = /* @__PURE__ */ ((t) => (t[t.Computed = 1] = "Computed", t[t.Effect = 2] = "Effect", t[t.Tracking = 4] = "Tracking", t[t.Notified = 8] = "Notified", t[t.Recursed = 16] = "Recursed", t[t.Dirty = 32] = "Dirty", t[t.PendingComputed = 64] = "PendingComputed", t[t.PendingEffect = 128] = "PendingEffect", t[t.Propagated = 224] = "Propagated", t))(M || {});
+function ye({
+  updateComputed: t,
+  notifyEffect: e
+}) {
+  let s, n;
+  return {
+    /**
+     * Links a given dependency and subscriber if they are not already linked.
+     * 
+     * @param dep - The dependency to be linked.
+     * @param sub - The subscriber that depends on this dependency.
+     * @returns The newly created link object if the two are not already linked; otherwise `undefined`.
+     */
+    link(r, u) {
+      const c = u.depsTail;
+      if (c !== void 0 && c.dep === r)
+        return;
+      const h = c !== void 0 ? c.nextDep : u.deps;
+      if (h !== void 0 && h.dep === r) {
+        u.depsTail = h;
+        return;
+      }
+      const d = r.subsTail;
+      if (!(d !== void 0 && d.sub === u && a(d, u)))
+        return i(r, u, h, c);
+    },
+    /**
+     * Traverses and marks subscribers starting from the provided link.
+     * 
+     * It sets flags (e.g., Dirty, PendingComputed, PendingEffect) on each subscriber
+     * to indicate which ones require re-computation or effect processing. 
+     * This function should be called after a signal's value changes.
+     * 
+     * @param link - The starting link from which propagation begins.
+     */
+    propagate(r) {
+      let u = 32, c = r, h = 0;
+      e: do {
+        const d = r.sub, p = d.flags;
+        if (!(p & 244) && (d.flags = p | u | 8, !0) || p & 16 && !(p & 4) && (d.flags = p & -17 | u | 8, !0) || !(p & 224) && a(r, d) && (d.flags = p | 16 | u | 8, d.subs !== void 0)) {
+          const x = d.subs;
+          if (x !== void 0) {
+            x.nextSub !== void 0 ? (x.prevSub = c, r = c = x, u = 64, ++h) : (r = x, u = p & 2 ? 128 : 64);
+            continue;
+          }
+          p & 2 && (n !== void 0 ? n.depsTail.nextDep = d.deps : s = d, n = d);
+        } else p & (4 | u) ? !(p & u) && p & 224 && a(r, d) && (d.flags = p | u) : (d.flags = p | u | 8, (p & 10) === 2 && (n !== void 0 ? n.depsTail.nextDep = d.deps : s = d, n = d));
+        if ((r = c.nextSub) !== void 0) {
+          c = r, u = h ? 64 : 32;
+          continue;
+        }
+        for (; h; ) {
+          --h;
+          const re = c.dep.subs;
+          if (c = re.prevSub, re.prevSub = void 0, (r = c.nextSub) !== void 0) {
+            c = r, u = h ? 64 : 32;
+            continue e;
+          }
+        }
+        break;
+      } while (!0);
+    },
+    /**
+     * Prepares the given subscriber to track new dependencies.
+     * 
+     * It resets the subscriber's internal pointers (e.g., depsTail) and
+     * sets its flags to indicate it is now tracking dependency links.
+     * 
+     * @param sub - The subscriber to start tracking.
+     */
+    startTracking(r) {
+      r.depsTail = void 0, r.flags = r.flags & -249 | 4;
+    },
+    /**
+     * Concludes tracking of dependencies for the specified subscriber.
+     * 
+     * It clears or unlinks any tracked dependency information, then
+     * updates the subscriber's flags to indicate tracking is complete.
+     * 
+     * @param sub - The subscriber whose tracking is ending.
+     */
+    endTracking(r) {
+      const u = r.depsTail;
+      if (u !== void 0) {
+        const c = u.nextDep;
+        c !== void 0 && (m(c), u.nextDep = void 0);
+      } else r.deps !== void 0 && (m(r.deps), r.deps = void 0);
+      r.flags &= -5;
+    },
+    /**
+     * Updates the dirty flag for the given subscriber based on its dependencies.
+     * 
+     * If the subscriber has any pending computeds, this function sets the Dirty flag
+     * and returns `true`. Otherwise, it clears the PendingComputed flag and returns `false`.
+     * 
+     * @param sub - The subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     * @returns `true` if the subscriber is marked as Dirty; otherwise `false`.
+     */
+    updateDirtyFlag(r, u) {
+      return o(r.deps) ? (r.flags = u | 32, !0) : (r.flags = u & -65, !1);
+    },
+    /**
+     * Updates the computed subscriber if necessary before its value is accessed.
+     * 
+     * If the subscriber is marked Dirty or PendingComputed, this function runs
+     * the provided updateComputed logic and triggers a shallowPropagate for any
+     * downstream subscribers if an actual update occurs.
+     * 
+     * @param computed - The computed subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     */
+    processComputedUpdate(r, u) {
+      if ((u & 32 || (o(r.deps) || (r.flags = u & -65, !1))) && t(r)) {
+        const c = r.subs;
+        c !== void 0 && f(c);
+      }
+    },
+    /**
+     * Ensures all pending internal effects for the given subscriber are processed.
+     * 
+     * This should be called after an effect decides not to re-run itself but may still
+     * have dependencies flagged with PendingEffect. If the subscriber is flagged with
+     * PendingEffect, this function clears that flag and invokes `notifyEffect` on any
+     * related dependencies marked as Effect and Propagated, processing pending effects.
+     * 
+     * @param sub - The subscriber which may have pending effects.
+     * @param flags - The current flags on the subscriber to check.
+     */
+    processPendingInnerEffects(r, u) {
+      if (u & 128) {
+        r.flags = u & -129;
+        let c = r.deps;
+        do {
+          const h = c.dep;
+          "flags" in h && h.flags & 2 && h.flags & 224 && e(h), c = c.nextDep;
+        } while (c !== void 0);
+      }
+    },
+    /**
+     * Processes queued effect notifications after a batch operation finishes.
+     * 
+     * Iterates through all queued effects, calling notifyEffect on each.
+     * If an effect remains partially handled, its flags are updated, and future
+     * notifications may be triggered until fully handled.
+     */
+    processEffectNotifications() {
+      for (; s !== void 0; ) {
+        const r = s, u = r.depsTail, c = u.nextDep;
+        c !== void 0 ? (u.nextDep = void 0, s = c.sub) : (s = void 0, n = void 0), e(r) || (r.flags &= -9);
+      }
+    }
+  };
+  function i(r, u, c, h) {
+    const d = {
+      dep: r,
+      sub: u,
+      nextDep: c,
+      prevSub: void 0,
+      nextSub: void 0
+    };
+    if (h === void 0 ? u.deps = d : h.nextDep = d, r.subs === void 0)
+      r.subs = d;
+    else {
+      const p = r.subsTail;
+      d.prevSub = p, p.nextSub = d;
+    }
+    return u.depsTail = d, r.subsTail = d, d;
+  }
+  function o(r) {
+    let u = 0, c;
+    e: do {
+      c = !1;
+      const h = r.dep;
+      if ("flags" in h) {
+        const d = h.flags;
+        if ((d & 33) === 33) {
+          if (t(h)) {
+            const p = h.subs;
+            p.nextSub !== void 0 && f(p), c = !0;
+          }
+        } else if ((d & 65) === 65) {
+          const p = h.subs;
+          p.nextSub !== void 0 && (p.prevSub = r), r = h.deps, ++u;
+          continue;
+        }
+      }
+      if (!c && r.nextDep !== void 0) {
+        r = r.nextDep;
+        continue;
+      }
+      if (u) {
+        let d = r.sub;
+        do {
+          --u;
+          const p = d.subs;
+          if (c) {
+            if (t(d)) {
+              (r = p.prevSub) !== void 0 ? (p.prevSub = void 0, f(d.subs), d = r.sub) : d = p.sub;
+              continue;
+            }
+          } else
+            d.flags &= -65;
+          if ((r = p.prevSub) !== void 0) {
+            if (p.prevSub = void 0, r.nextDep !== void 0) {
+              r = r.nextDep;
+              continue e;
+            }
+            d = r.sub;
+          } else {
+            if ((r = p.nextDep) !== void 0)
+              continue e;
+            d = p.sub;
+          }
+          c = !1;
+        } while (u);
+      }
+      return c;
+    } while (!0);
+  }
+  function f(r) {
+    do {
+      const u = r.sub, c = u.flags;
+      (c & 96) === 64 && (u.flags = c | 32 | 8, (c & 10) === 2 && (n !== void 0 ? n.depsTail.nextDep = u.deps : s = u, n = u)), r = r.nextSub;
+    } while (r !== void 0);
+  }
+  function a(r, u) {
+    const c = u.depsTail;
+    if (c !== void 0) {
+      let h = u.deps;
+      do {
+        if (h === r)
+          return !0;
+        if (h === c)
+          break;
+        h = h.nextDep;
+      } while (h !== void 0);
+    }
+    return !1;
+  }
+  function m(r) {
+    do {
+      const u = r.dep, c = r.nextDep, h = r.nextSub, d = r.prevSub;
+      if (h !== void 0 ? h.prevSub = d : u.subsTail = d, d !== void 0 ? d.nextSub = h : u.subs = h, u.subs === void 0 && "deps" in u) {
+        const p = u.flags;
+        p & 32 || (u.flags = p | 32);
+        const x = u.deps;
+        if (x !== void 0) {
+          r = x, u.depsTail.nextDep = c, u.deps = void 0, u.depsTail = void 0;
+          continue;
+        }
+      }
+      r = c;
+    } while (r !== void 0);
+  }
+}
+var {
+  link: ft,
+  propagate: lt,
+  updateDirtyFlag: Ie,
+  startTracking: ve,
+  endTracking: we,
+  processEffectNotifications: at,
+  processComputedUpdate: dt,
+  processPendingInnerEffects: be
+} = ye({
+  updateComputed(t) {
+    ve(t);
+    try {
+      const e = t.currentValue, s = t.getter(e);
+      return e !== s ? (t.currentValue = s, !0) : !1;
+    } finally {
+      we(t);
+    }
+  },
+  notifyEffect(t) {
+    return "isScope" in t ? _e(t) : Ve(t);
+  }
+});
+function je(t) {
+  ve(t);
+  try {
+    t.fn();
+  } finally {
+    we(t);
+  }
+}
+function Ve(t) {
+  const e = t.flags;
+  return e & 32 || e & 64 && Ie(t, e) ? je(t) : be(t, t.flags), !0;
+}
+function _e(t) {
+  return t.flags & 128 ? (be(t, t.flags), !0) : !1;
+}
+function A(t) {
+  const e = typeof t;
+  switch (e) {
+    case "undefined":
+      return e;
+    case "number":
+      return isNaN(t) ? "NaN" : e;
+    case "function":
+      return /^\s*class\s+/.test(t.toString()) ? "class" : e;
+    case "object":
+      return t === null ? "null" : t instanceof Promise ? "promise" : t instanceof Map ? "map" : t instanceof Set ? "set" : Array.isArray(t) ? "array" : e;
+    default:
+      return e;
+  }
+}
+function _(t) {
+  return Array.isArray(t);
+}
+function X(t, e) {
+  return _(e) && e.every((s) => t(s));
+}
+function ht(t, e, s) {
+  if (X(t, e))
+    return !0;
+  throw new TypeError(G(e, s));
+}
+function O(t) {
+  return typeof t == "string";
+}
+function pt(t, e) {
+  if (O(t))
+    return !0;
+  throw new TypeError(G(t, e ?? "Expected a string. Got type: %t, value: %v"));
+}
+function E(t) {
+  return A(t) === "function";
+}
+function qe(t) {
+  return typeof t == "number" && !isNaN(t);
+}
+function mt(...t) {
+  const e = t[0], s = O(t[2]) ? t[2] : `Expected instance of ${e.name}. Got type: %t, value: %v`, n = (i) => {
+    if (i instanceof e)
+      return !0;
+    throw new TypeError(G(i, s));
+  };
+  return t.length < 2 ? n : n(t[1]);
+}
+function J(t) {
+  return t != null && typeof t == "object" && !_(t);
+}
+function gt(t, e) {
+  if (J(t))
+    return !0;
+  throw new TypeError(G(t, e));
+}
+function G(t, e) {
+  var i;
+  const s = A(t), n = ((i = t == null ? void 0 : t.toString) == null ? void 0 : i.call(t)) || String(t);
+  return e.replaceAll("%t", s).replaceAll("%v", n);
+}
+let T, P = [];
+const {
+  link: Q,
+  propagate: Ue,
+  updateDirtyFlag: ze,
+  startTracking: Y,
+  endTracking: ee,
+  processEffectNotifications: Re,
+  processComputedUpdate: Be,
+  processPendingInnerEffects: Ge
+} = ye({
+  updateComputed(t) {
+    const e = g;
+    g = t, P.length = 0, Y(t);
+    try {
+      const s = t.currentValue, n = t.getter(s);
+      return t.equals(s, n) ? !1 : (t.currentValue = n, !0);
+    } finally {
+      g = e, T !== void 0 && (T(P), T = void 0), ee(t);
+    }
+  },
+  notifyEffect(t) {
+    const e = t.flags;
+    return e & M.Dirty || e & M.PendingComputed && ze(t, e) ? Ne(t) : Ge(t, t.flags), !0;
+  }
+});
+let g;
+const C = [];
+let W = !1;
+function Fe() {
+  W || (W = !0, queueMicrotask(() => {
+    W = !1;
+    for (let t = 0; t < C.length; t++) {
+      const e = C[t], s = g;
+      g = e, P.length = 0, Y(e);
+      try {
+        e.fn();
+      } finally {
+        g = s, ee(e), T !== void 0 && (T(P), T = void 0);
+      }
+    }
+    C.length = 0;
+  }));
+}
+function Ne(t) {
+  C.push(t), Fe();
+}
+function We() {
+  Y(this), ee(this), queueMicrotask(() => {
+    C.splice(C.indexOf(this), 1);
+  });
+}
+const xe = [];
+function Ze() {
+  xe.push(g), g = void 0;
+}
+function He() {
+  g = xe.pop();
+}
+var b, j;
+class Me {
+  constructor(e, s) {
+    L(this, b);
+    L(this, j);
+    l(this, "name");
+    $(this, b, {
+      currentValue: e,
+      subs: void 0,
+      subsTail: void 0
+    }), $(this, j, (s == null ? void 0 : s.equals) ?? Object.is), s != null && s.name && (this.name = s.name);
+  }
+  /**
+   * Returns the latest value. The signal is tracked as a dependency if called within `effect` or `compose`.
+   */
+  get() {
+    return g !== void 0 && (Q(w(this, b), g), P.push(this)), w(this, b).currentValue;
+  }
+  /**
+   * Returns the latest value. The signal is NOT tracked if called within `effect` or `compose`.
+   */
+  peek() {
+    return w(this, b).currentValue;
+  }
+  /**
+   * Replaces the current value with `next`.
+   *
+   * @example
+   * const count = atom(0);
+   * count.set(2);
+   * count.set(count.get() + 1);
+   */
+  set(e) {
+    if (!w(this, j).call(this, w(this, b).currentValue, e)) {
+      w(this, b).currentValue = e;
+      const s = w(this, b).subs;
+      s !== void 0 && (Ue(s), Re());
+    }
+  }
+  /**
+   * Passes the current value to `fn` and sets the return value as the next value.
+   *
+   * @example
+   * const count = atom(0);
+   * count.update((current) => current + 1);
+   * count.update((current) => current * 5);
+   *
+   * // Also works very well with Immer `produce` for complex objects.
+   * const items = atom([{ name: "Alice", age: 26 }, { name: "Bob", age: 33 }]);
+   *
+   * // Without Immer:
+   * items.update((current) => {
+   *   // Return a new array with Bob's age increased by 1.
+   *   const newItems = [...current];
+   *   newItems[1] = {
+   *     ...newItems[1],
+   *     age: newItems[1].age + 1
+   *   };
+   *   return newItems;
+   * });
+   *
+   * // With Immer:
+   * import { produce } from "immer";
+   *
+   * items.update(produce((draft) => {
+   *   // Mutate draft to increase Bob's age by 1.
+   *   // Results in a new object with this patch applied.
+   *   draft[1].age++;
+   * }));
+   */
+  update(e) {
+    this.set(e(this.peek()));
+  }
+  /**
+   * @deprecated use `get()`
+   */
+  get value() {
+    return this.peek();
+  }
+  /**
+   * @deprecated use `set()`
+   */
+  set value(e) {
+    this.set(e);
+  }
+}
+b = new WeakMap(), j = new WeakMap();
+var D, V, B, ke;
+class Ee {
+  constructor(e, s) {
+    L(this, B);
+    L(this, D);
+    L(this, V);
+    l(this, "name");
+    $(this, V, e), $(this, D, {
+      currentValue: void 0,
+      equals: (s == null ? void 0 : s.equals) ?? Object.is,
+      subs: void 0,
+      subsTail: void 0,
+      deps: void 0,
+      depsTail: void 0,
+      flags: M.Computed | M.Dirty,
+      getter: ue(this, B, ke).bind(this)
+    }), s != null && s.name && (this.name = s.name);
+  }
+  get() {
+    return g !== void 0 && (Q(w(this, D), g), P.push(this)), this.peek();
+  }
+  peek() {
+    const e = w(this, D), s = e.flags;
+    return s & (M.Dirty | M.PendingComputed) && Be(e, s), e.currentValue;
+  }
+  /**
+   * @deprecated use `get()`
+   */
+  get value() {
+    return this.peek();
+  }
+}
+D = new WeakMap(), V = new WeakMap(), B = new WeakSet(), ke = function(e) {
+  let s = w(this, V).call(this, e);
+  return y(s) && (s = s.get()), s;
+};
+function y(t) {
+  return t instanceof Me || t instanceof Ee;
+}
+function K(t, e) {
+  return new Me(t, e);
+}
+function te(t, e) {
+  return new Ee(t, e);
+}
+function Ke(t, e) {
+  if (E(e))
+    t.update(e);
+  else if (arguments.length > 1)
+    t.set(e);
+  else
+    return (s) => Ke(t, s);
+}
+function I(t) {
+  return y(t) ? t.get() : t;
+}
+function yt(t) {
+  return y(t) ? t.peek() : t;
+}
+function se(t) {
+  Ze(), t(), He();
+}
+function vt(t) {
+  T = t;
+}
+function v(t) {
+  const e = {
+    fn: t,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: M.Effect
+  };
+  return g !== void 0 && Q(e, g), Ne(e), We.bind(e);
+}
+const wt = () => {
+};
+let Z = 1;
+function Se() {
+  return Z = Z % Number.MAX_SAFE_INTEGER + 1, Z.toString(36) + Date.now().toString(36);
+}
+function bt(t, e) {
+  return Object.is(t, e);
+}
+function Nt(t, e) {
+  if (Object.is(t, e)) return !0;
+  const s = A(t);
+  if (s !== A(e))
+    return !1;
+  switch (s) {
+    case "object":
+      let n = 0;
+      for (const i in t) {
+        if (t[i] !== e[i]) return !1;
+        n++;
+      }
+      return Object.keys(e).length === n;
+    case "array":
+      if (t.length !== e.length) return !1;
+      for (let i = 0; i < t.length; i++)
+        if (t[i] !== e[i]) return !1;
+      return !0;
+    case "map":
+      if (t.size !== e.size) return !1;
+      for (const i of t.keys())
+        if (t[i] !== e[i]) return !1;
+      return !0;
+    case "set":
+      if (E(t.symmetricDifference))
+        return t.symmetricDifference(e).size === 0;
+      for (const i of t.keys())
+        if (t[i] !== e.get(i)) return !1;
+      return !0;
+  }
+  return !1;
+}
+function H(t, e) {
+  if (t === e) return !0;
+  if (t && e && typeof t == "object" && typeof e == "object") {
+    if (t.constructor !== e.constructor) return !1;
+    var s, n, i;
+    if (Array.isArray(t)) {
+      if (s = t.length, s != e.length) return !1;
+      for (n = s; n-- !== 0; ) if (!H(t[n], e[n])) return !1;
+      return !0;
+    }
+    if (t instanceof Map && e instanceof Map) {
+      if (t.size !== e.size) return !1;
+      for (n of t.entries()) if (!e.has(n[0])) return !1;
+      for (n of t.entries()) if (!H(n[1], e.get(n[0]))) return !1;
+      return !0;
+    }
+    if (t instanceof Set && e instanceof Set) {
+      if (t.size !== e.size) return !1;
+      for (n of t.entries()) if (!e.has(n[0])) return !1;
+      return !0;
+    }
+    if (ArrayBuffer.isView(t) && ArrayBuffer.isView(e)) {
+      if (s = t.length, s != e.length) return !1;
+      for (n = s; n-- !== 0; ) if (t[n] !== e[n]) return !1;
+      return !0;
+    }
+    if (t.constructor === RegExp) return t.source === e.source && t.flags === e.flags;
+    if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === e.valueOf();
+    if (t.toString !== Object.prototype.toString) return t.toString() === e.toString();
+    if (i = Object.keys(t), s = i.length, s !== Object.keys(e).length) return !1;
+    for (n = s; n-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(e, i[n])) return !1;
+    for (n = s; n-- !== 0; ) {
+      var o = i[n];
+      if (!H(t[o], e[o])) return !1;
+    }
+    return !0;
+  }
+  return t !== t && e !== e;
+}
+function Xe(t, e) {
+  const s = {};
+  for (const n in e)
+    t.includes(n) || (s[n] = e[n]);
+  return s;
+}
+function xt(t) {
+  let e = 0;
+  for (let s = 0; s < t.length; s++)
+    e = (e + t.charCodeAt(s) * 10) % 360;
+  return `oklch(0.68 0.15 ${e}deg)`;
+}
+function Mt(t) {
+  if (t instanceof RegExp)
+    return (n) => t.test(n);
+  const e = {
+    positive: [],
+    negative: []
+  }, s = t.split(",").map((n) => n.trim()).filter((n) => n !== "");
+  for (let n of s) {
+    let i = "positive";
+    n.startsWith("-") && (i = "negative", n = n.slice(1)), n === "*" ? e[i].push(function() {
+      return !0;
+    }) : n.endsWith("*") ? e[i].push(function(o) {
+      return o.startsWith(n.slice(0, n.length - 1));
+    }) : e[i].push(function(o) {
+      return o === n;
+    });
+  }
+  return function(n) {
+    const { positive: i, negative: o } = e;
+    return !(o.some((f) => f(n)) || i.length > 0 && !i.some((f) => f(n)));
+  };
+}
+const k = Symbol.for("DollaMarkupElement"), Et = Symbol.for("DollaRouter");
+function kt(t, e) {
+  return e.outlet();
+}
+function Je(t) {
+  for (var e, s, n = arguments, i = 1, o = "", f = "", a = [0], m = function(c) {
+    i === 1 && (c || (o = o.replace(/^\s*\n\s*|\s*\n\s*$/g, ""))) ? a.push(c ? n[c] : o) : i === 3 && (c || o) ? (a[1] = c ? n[c] : o, i = 2) : i === 2 && o === "..." && c ? a[2] = Object.assign(a[2] || {}, n[c]) : i === 2 && o && !c ? (a[2] = a[2] || {})[o] = !0 : i >= 5 && (i === 5 ? ((a[2] = a[2] || {})[s] = c ? o ? o + n[c] : n[c] : o, i = 6) : (c || o) && (a[2][s] += c ? o + n[c] : o)), o = "";
+  }, r = 0; r < t.length; r++) {
+    r && (i === 1 && m(), m(r));
+    for (var u = 0; u < t[r].length; u++) e = t[r][u], i === 1 ? e === "<" ? (m(), a = [a, "", null], i = 3) : o += e : i === 4 ? o === "--" && e === ">" ? (i = 1, o = "") : o = e + o[0] : f ? e === f ? f = "" : o += e : e === '"' || e === "'" ? f = e : e === ">" ? (m(), i = 1) : i && (e === "=" ? (i = 5, s = o, o = "") : e === "/" && (i < 5 || t[r][u + 1] === ">") ? (m(), i === 3 && (a = a[0]), i = a, (a = a[0]).push(this.apply(null, i.slice(1))), i = 0) : e === " " || e === "	" || e === `
+` || e === "\r" ? (m(), i = 2) : o += e), i === 3 && o === "!--" && (i = 4, a = a[0]);
+  }
+  return m(), a.length > 2 ? a.slice(1) : a[1];
+}
+var le;
+le = k;
+class ce {
+  constructor(e) {
+    l(this, le, !0);
+    l(this, "domNode");
+    this.domNode = e;
+  }
+  get isMounted() {
+    return this.domNode.parentNode != null;
+  }
+  mount(e, s) {
+    e.insertBefore(this.domNode, (s == null ? void 0 : s.nextSibling) ?? null);
+  }
+  unmount(e = !1) {
+    this.domNode.parentNode && !e && this.domNode.parentNode.removeChild(this.domNode);
+  }
+}
+var ae;
+ae = k;
+class Qe {
+  constructor(e) {
+    l(this, ae, !0);
+    l(this, "domNode", document.createTextNode(""));
+    l(this, "children", []);
+    l(this, "elementContext");
+    l(this, "source");
+    l(this, "unsubscribe");
+    this.source = e.source, this.elementContext = e.elementContext;
+  }
+  get isMounted() {
+    return this.domNode.parentNode != null;
+  }
+  mount(e, s) {
+    this.isMounted || (e.insertBefore(this.domNode, (s == null ? void 0 : s.nextSibling) ?? null), this.unsubscribe = v(() => {
+      const n = this.source.get();
+      if (!Pe(n))
+        throw console.error(n), new TypeError(
+          `Dynamic received invalid value to render. Got type: ${A(n)}, value: ${n}`
+        );
+      se(() => {
+        this.update(_(n) ? n : [n]);
+      });
+    }));
+  }
+  unmount(e = !1) {
+    var s, n;
+    (s = this.unsubscribe) == null || s.call(this), this.isMounted && (this.cleanup(e), (n = this.domNode.parentNode) == null || n.removeChild(this.domNode));
+  }
+  cleanup(e) {
+    for (const s of this.children)
+      s.unmount(e);
+    this.children = [];
+  }
+  update(e) {
+    var o, f, a;
+    if (this.cleanup(!1), e == null || e.length === 0 || !this.isMounted)
+      return;
+    const s = e.flatMap((m) => De(m) ? m : S(this.elementContext, ne(m)));
+    for (const m of s) {
+      const r = ((o = this.children.at(-1)) == null ? void 0 : o.domNode) || this.domNode;
+      m.mount(this.domNode.parentNode, r), this.children.push(m);
+    }
+    const n = this.domNode.parentNode, i = ((a = (f = this.children.at(-1)) == null ? void 0 : f.domNode) == null ? void 0 : a.nextSibling) ?? null;
+    n.insertBefore(this.domNode, i);
+  }
+}
+const Ye = (t) => /^on[A-Z]/.test(t);
+var de;
+de = k;
+class et {
+  constructor({ tag: e, props: s, children: n, elementContext: i }) {
+    l(this, de, !0);
+    l(this, "domNode");
+    l(this, "props");
+    l(this, "childMarkup", []);
+    l(this, "children", []);
+    l(this, "unsubscribers", []);
+    l(this, "elementContext");
+    // Track the ref so we can nullify it on unmount.
+    l(this, "ref");
+    // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+    l(this, "canClickAway", !1);
+    if (e.toLowerCase() === "svg" && (i = {
+      ...i,
+      isSVG: !0
+    }), i.isSVG ? this.domNode = document.createElementNS("http://www.w3.org/2000/svg", e) : this.domNode = document.createElement(e), i.root.getEnv() === "development" && i.viewName && (this.domNode.dataset.view = i.viewName), s.ref)
+      if (E(s.ref))
+        this.ref = s.ref, this.ref(this.domNode);
+      else
+        throw new Error("Expected ref to be a function. Got: " + s.ref);
+    this.props = {
+      ...Xe(["ref", "class", "className"], s),
+      class: s.className ?? s.class
+    }, n && (this.childMarkup = n), this.elementContext = i;
+  }
+  get isMounted() {
+    return this.domNode.parentNode != null;
+  }
+  mount(e, s) {
+    if (e == null)
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${e}`);
+    if (!this.isMounted) {
+      this.childMarkup.length > 0 && (this.children = S(this.elementContext, this.childMarkup));
+      for (let n = 0; n < this.children.length; n++) {
+        const i = this.children[n], o = n > 0 ? this.children[n - 1].domNode : void 0;
+        i.mount(this.domNode, o);
+      }
+      this.applyProps(this.domNode, this.props), this.props.style && this.applyStyles(this.domNode, this.props.style, this.unsubscribers), this.props.class && this.applyClasses(this.domNode, this.props.class, this.unsubscribers);
+    }
+    e.insertBefore(this.domNode, (s == null ? void 0 : s.nextSibling) ?? null), setTimeout(() => {
+      this.canClickAway = !0;
+    }, 0);
+  }
+  unmount(e = !1) {
+    var s;
+    if (this.isMounted) {
+      e || (s = this.domNode.parentNode) == null || s.removeChild(this.domNode);
+      for (const n of this.children)
+        n.unmount(!0);
+      this.ref && this.ref(void 0), this.canClickAway = !1;
+      for (const n of this.unsubscribers)
+        n();
+      this.unsubscribers.length = 0;
+    }
+  }
+  attachProp(e, s) {
+    y(e) ? this.unsubscribers.push(
+      v(() => {
+        s(e.get());
+      })
+    ) : s(e);
+  }
+  applyProps(e, s) {
+    for (const n in s) {
+      const i = s[n];
+      if (n === "on:clickoutside" || n === "onClickOutside" || n === "onclickoutside") {
+        const o = (a) => {
+          this.canClickAway && !e.contains(a.target) && (y(i) ? i.peek()(a) : i(a));
+        }, f = { capture: !0 };
+        window.addEventListener("click", o, f), this.unsubscribers.push(() => {
+          window.removeEventListener("click", o, f);
+        });
+      } else if (Ye(n)) {
+        const o = n.slice(2).toLowerCase(), f = y(i) ? (a) => i.peek()(a) : i;
+        e.addEventListener(o, f), this.unsubscribers.push(() => {
+          e.removeEventListener(o, f);
+        });
+      } else if (n.includes("-"))
+        this.attachProp(i, (o) => {
+          o == null ? e.removeAttribute(n) : e.setAttribute(n, String(o));
+        });
+      else if (!tt.includes(n))
+        if (this.elementContext.isSVG)
+          this.attachProp(i, (o) => {
+            o != null ? e.setAttribute(n, String(s[n])) : e.removeAttribute(n);
+          });
+        else
+          switch (n) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(i, (o) => {
+                e[n] = String(o);
+              });
+              break;
+            case "for":
+              this.attachProp(i, (o) => {
+                e.htmlFor = o;
+              });
+              break;
+            case "checked":
+              this.attachProp(i, (o) => {
+                e.checked = o, o ? e.setAttribute("checked", "") : e.removeAttribute("checked");
+              });
+              break;
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(i, (o) => {
+                typeof o == "string" ? e[n] = o : o ? e[n] = "on" : e[n] = "off";
+              });
+              break;
+            default: {
+              if (n.startsWith("prop:")) {
+                const o = n.substring(5);
+                this.attachProp(i, (f) => {
+                  e[o] = f;
+                });
+              } else if (n.startsWith("on:")) {
+                const o = n.substring(3);
+                let f;
+                this.attachProp(i, (a) => {
+                  !a && f ? e.removeEventListener(o, f) : a != null && (f && f !== a && e.removeEventListener(o, f), e.addEventListener(o, a)), f = a;
+                });
+              } else if (n.startsWith("attr:")) {
+                const o = n.substring(5).toLowerCase();
+                this.attachProp(i, (f) => {
+                  f != null ? e.setAttribute(o, String(f)) : e.removeAttribute(o);
+                });
+              } else
+                this.attachProp(i, (o) => {
+                  e[n] = o;
+                });
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(e, s, n) {
+    const i = [];
+    if (y(s)) {
+      let o;
+      const f = v(() => {
+        E(o) && o(), e.style.cssText = "", o = this.applyStyles(e, I(s), n);
+      });
+      n.push(f), i.push(f);
+    } else {
+      const o = Le(s);
+      for (const f in o) {
+        const { value: a, priority: m } = o[f];
+        if (y(a)) {
+          const r = v(() => {
+            a.get() ? e.style.setProperty(f, String(a.get()), m) : e.style.removeProperty(f);
+          });
+          n.push(r), i.push(r);
+        } else a != null && e.style.setProperty(f, String(a));
+      }
+    }
+    return function() {
+      for (const f of i)
+        f(), n.splice(n.indexOf(f), 1);
+    };
+  }
+  applyClasses(e, s, n) {
+    const i = [];
+    if (y(s)) {
+      let o;
+      const f = v(() => {
+        E(o) && o(), e.removeAttribute("class"), o = this.applyClasses(e, I(s), n);
+      });
+      n.push(f), i.push(f);
+    } else {
+      const o = Te(s);
+      for (const f in o) {
+        const a = o[f];
+        if (y(a)) {
+          const m = v(() => {
+            I(a) ? e.classList.add(f) : e.classList.remove(f);
+          });
+          n.push(m), i.push(m);
+        } else a && e.classList.add(f);
+      }
+    }
+    return function() {
+      for (const f of i)
+        f(), n.splice(n.indexOf(f), 1);
+    };
+  }
+}
+function Te(t) {
+  let e = {};
+  if (O(t)) {
+    const s = t.split(" ");
+    for (const n of s)
+      e[n] = !0;
+  } else J(t) ? Object.assign(e, t) : Array.isArray(t) && Array.from(t).filter(Boolean).forEach((s) => {
+    Object.assign(e, Te(s));
+  });
+  return delete e.undefined, e;
+}
+function Le(t) {
+  let e = {};
+  if (O(t)) {
+    const s = t.split(";").filter((n) => n.trim() !== "");
+    for (const n of s) {
+      const [i, o] = n.split(":"), f = {
+        value: o
+      };
+      o.includes("!important") ? (f.priority = "important", f.value = o.replace("!important", "").trim()) : f.value = o.trim(), e[fe(i.trim())] = f;
+    }
+  }
+  if (J(t))
+    for (const s in t)
+      s.startsWith("--") ? e[s] = { value: t[s] } : e[fe(s)] = { value: t[s] };
+  else Array.isArray(t) && Array.from(t).filter((s) => s != null).forEach((s) => {
+    Object.assign(e, Le(s));
+  });
+  return e;
+}
+function fe(t) {
+  return t.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (e, s) => (s ? "-" : "") + e.toLowerCase());
+}
+const tt = ["ref", "children", "class", "style", "data"];
+let st = class {
+  constructor(e) {
+    l(this, "store");
+    this.store = e;
+    const s = Object.getOwnPropertyDescriptors(this.store.logger);
+    for (const n in s)
+      n !== "setName" && Object.defineProperty(this, n, s[n]);
+  }
+  get isMounted() {
+    return this.store.isMounted;
+  }
+  get name() {
+    return this.store.name || this.store.id;
+  }
+  set name(e) {
+    this.store.name = e, this.store.logger.setName(e);
+  }
+  get(e) {
+    if (E(e)) {
+      let s = this.store.elementContext, n;
+      for (; n = s.stores.get(e), n == null && s.parent != null; )
+        s = s.parent;
+      if (n == null)
+        throw new U(`Store '${e.name}' is not provided on this context.`);
+      return n.value;
+    } else
+      throw new U("Invalid store.");
+  }
+  onMount(e) {
+    this.store.lifecycleListeners.mount.push(e);
+  }
+  onUnmount(e) {
+    this.store.lifecycleListeners.unmount.push(e);
+  }
+  effect(e) {
+    const s = this.store;
+    if (s.isMounted) {
+      const n = v(e);
+      return s.lifecycleListeners.unmount.push(n), n;
+    } else {
+      let n, i = !1;
+      return s.lifecycleListeners.mount.push(() => {
+        i || (n = v(e), s.lifecycleListeners.unmount.push(n));
+      }), () => {
+        n != null && (i = !0, n());
+      };
+    }
+  }
+};
+class nt {
+  constructor(e, s) {
+    l(this, "fn");
+    l(this, "_options");
+    /**
+     * Value is guaranteed to be set after `attach` is called.
+     */
+    l(this, "value");
+    l(this, "isMounted", !1);
+    l(this, "elementContext");
+    l(this, "lifecycleListeners", { mount: [], unmount: [] });
+    l(this, "logger");
+    l(this, "id", Se());
+    l(this, "name");
+    this.fn = e, this.name = e.name, this._options = s;
+  }
+  /**
+   * Attaches this Store to the elementContext.
+   * Returns false if there was already an instance attached, and true otherwise.
+   */
+  attach(e) {
+    if (e.stores.has(this.fn))
+      return !1;
+    this.elementContext = e, this.logger = e.root.createLogger(this.name);
+    const s = new st(this);
+    try {
+      this.value = this.fn.call(s, this._options, s);
+    } catch (n) {
+      throw this.logger.crash(n), n;
+    }
+    return e.stores.set(this.fn, this), !0;
+  }
+  handleMount() {
+    this.isMounted = !0;
+    for (const e of this.lifecycleListeners.mount)
+      e();
+    this.lifecycleListeners.mount.length = 0;
+  }
+  handleUnmount() {
+    this.isMounted = !1;
+    for (const e of this.lifecycleListeners.unmount)
+      e();
+    this.lifecycleListeners.unmount.length = 0;
+  }
+}
+class U extends Error {
+}
+class it {
+  constructor(e) {
+    l(this, "view");
+    this.view = e;
+    const s = Object.getOwnPropertyDescriptors(this.view.logger);
+    for (const n in s)
+      n !== "setName" && Object.defineProperty(this, n, s[n]);
+  }
+  get uid() {
+    return this.view.uniqueId;
+  }
+  get isMounted() {
+    return this.view.isMounted;
+  }
+  get name() {
+    return this.view.elementContext.viewName || this.uid;
+  }
+  set name(e) {
+    this.view.elementContext.viewName = e, this.view.logger.setName(e);
+  }
+  provide(e, s) {
+    const n = new nt(e, s);
+    if (n.attach(this.view.elementContext))
+      return this.view.lifecycleListeners.mount.push(() => {
+        n.handleMount();
+      }), this.view.lifecycleListeners.unmount.push(() => {
+        n.handleUnmount();
+      }), n.value;
+    {
+      let o = e.name ? `'${e.name}'` : "this store";
+      return this.view.logger.warn(`An instance of ${o} was already attached to this context.`), this.get(e);
+    }
+  }
+  get(e) {
+    if (E(e)) {
+      let s = this.view.elementContext, n;
+      for (; n = s.stores.get(e), n == null && s.parent != null; )
+        s = s.parent;
+      if (n == null)
+        throw new U(`Store '${e.name}' is not provided on this context.`);
+      return n.value;
+    } else
+      throw new U("Invalid store.");
+  }
+  beforeMount(e) {
+    this.view.lifecycleListeners.beforeMount.push(e);
+  }
+  onMount(e) {
+    this.view.lifecycleListeners.mount.push(e);
+  }
+  beforeUnmount(e) {
+    this.view.lifecycleListeners.beforeUnmount.push(e);
+  }
+  onUnmount(e) {
+    this.view.lifecycleListeners.unmount.push(e);
+  }
+  effect(e) {
+    if (this.view.isMounted) {
+      const s = v(e);
+      return this.view.lifecycleListeners.unmount.push(s), s;
+    } else {
+      let s, n = !1;
+      return this.view.lifecycleListeners.mount.push(() => {
+        n || (s = v(e), this.view.lifecycleListeners.unmount.push(s));
+      }), () => {
+        s != null && (n = !0, s());
+      };
+    }
+  }
+  outlet() {
+    return N("$outlet", { children: this.view.children });
+  }
+}
+var he;
+he = k;
+const ie = class ie {
+  constructor(e, s, n, i = []) {
+    l(this, he, !0);
+    l(this, "uniqueId", Se());
+    l(this, "elementContext");
+    l(this, "logger");
+    l(this, "props");
+    l(this, "fn");
+    l(this, "element");
+    l(this, "childMarkup");
+    l(this, "children", K([]));
+    l(this, "lifecycleListeners", { beforeMount: [], mount: [], beforeUnmount: [], unmount: [] });
+    l(this, "isMounted", !1);
+    this.elementContext = {
+      ...e,
+      parent: e,
+      viewName: s.name,
+      stores: /* @__PURE__ */ new Map()
+    }, this.logger = e.root.createLogger(s.name || "🌇 anonymous view", { uid: this.uniqueId }), this.props = n, this.fn = s, this.childMarkup = i;
+  }
+  /*===============================*\
+  ||         "Public" API          ||
+  \*===============================*/
+  get domNode() {
+    var e;
+    return (e = this.element) == null ? void 0 : e.domNode;
+  }
+  mount(e, s) {
+    const n = this.isMounted;
+    if (!n) {
+      this._initialize();
+      for (const i of this.lifecycleListeners.beforeMount)
+        i();
+    }
+    this.element && this.element.mount(e, s), n || (this.isMounted = !0, requestAnimationFrame(() => {
+      for (const i of this.lifecycleListeners.mount)
+        i();
+    }));
+  }
+  unmount(e = !1) {
+    for (const s of this.lifecycleListeners.beforeUnmount)
+      s();
+    this.element && this.element.unmount(e), this.isMounted = !1;
+    for (const s of this.lifecycleListeners.unmount)
+      s();
+    this.lifecycleListeners.beforeMount.length = 0, this.lifecycleListeners.mount.length = 0, this.lifecycleListeners.beforeUnmount.length = 0, this.lifecycleListeners.unmount.length = 0;
+  }
+  setChildView(e) {
+    this.childMarkup = [];
+    const s = new ie(this.elementContext, e, {});
+    return this.children.set([s]), s;
+  }
+  /*===============================*\
+  ||           Internal            ||
+  \*===============================*/
+  _initialize() {
+    const e = new it(this);
+    let s;
+    try {
+      s = this.fn.call(e, this.props, e), this.childMarkup.length && this.children.set(S(this.elementContext, this.childMarkup));
+    } catch (n) {
+      throw n instanceof Error && this.logger.crash(n), n;
+    }
+    if (s !== null) if (s instanceof Node)
+      this.element = q(S(this.elementContext, N("$node", { value: s })));
+    else if (y(s))
+      this.element = q(
+        S(this.elementContext, N("$dynamic", { source: s }))
+      );
+    else if (R(s) || X(R, s))
+      this.element = q(S(this.elementContext, s));
+    else {
+      const n = new TypeError(
+        `Expected '${this.fn.name}' function to return a DOM node, Markup element, Readable or null. Got: ${A(s)}`
+      );
+      this.logger.crash(n);
+    }
+  }
+};
+let z = ie;
+var pe;
+pe = k;
+class rt {
+  constructor({ elementContext: e, items: s, renderFn: n, keyFn: i }) {
+    l(this, pe, !0);
+    l(this, "domNode", document.createTextNode(""));
+    l(this, "items");
+    l(this, "unsubscribe", null);
+    l(this, "connectedItems", []);
+    l(this, "elementContext");
+    l(this, "renderFn");
+    l(this, "keyFn");
+    this.elementContext = e, this.items = s, this.renderFn = n, this.keyFn = i;
+  }
+  get isMounted() {
+    return this.domNode.parentNode != null;
+  }
+  mount(e, s) {
+    this.isMounted || (e.insertBefore(this.domNode, (s == null ? void 0 : s.nextSibling) ?? null), this.unsubscribe = v(() => {
+      let n = this.items.get();
+      n == null && (n = [], console.log("list received empty value", n, this)), se(() => {
+        this._update(Array.from(n));
+      });
+    }));
+  }
+  unmount(e = !1) {
+    var s;
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = null), !e && this.isMounted && ((s = this.domNode.parentNode) == null || s.removeChild(this.domNode)), this._cleanup(e);
+  }
+  _cleanup(e) {
+    for (const s of this.connectedItems)
+      s.element.unmount(e);
+    this.connectedItems = [];
+  }
+  _update(e) {
+    var f, a, m;
+    if (e.length === 0 || !this.isMounted)
+      return this._cleanup(!1);
+    const s = [];
+    let n = 0;
+    for (const r of e)
+      s.push({
+        key: this.keyFn(r, n),
+        value: r,
+        index: n++
+      });
+    const i = [];
+    for (const r of this.connectedItems)
+      s.find((c) => c.key === r.key) || r.element.unmount(!1);
+    for (const r of s) {
+      const u = this.connectedItems.find((c) => c.key === r.key);
+      if (u)
+        u.item.set(r.value), u.index.set(r.index), i[r.index] = u;
+      else {
+        const c = K(r.value), h = K(r.index);
+        i[r.index] = {
+          key: r.key,
+          item: c,
+          index: h,
+          element: new z(this.elementContext, ot, {
+            item: te(() => c.get()),
+            index: h,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let r = 0; r < i.length; r++) {
+      const u = i[r], c = ((f = i[r - 1]) == null ? void 0 : f.element.domNode) ?? this.domNode;
+      u.element.mount(this.domNode.parentNode, c);
+    }
+    this.connectedItems = i;
+    const o = ((a = i.at(-1)) == null ? void 0 : a.element.domNode) ?? this.domNode;
+    (m = this.domNode.parentNode) == null || m.insertBefore(this.domNode, o.nextSibling);
+  }
+}
+function ot(t, e) {
+  return e.name = "@ListItem", t.renderFn.call(e, t.item, t.index, e);
+}
+var me;
+me = k;
+class Ce {
+  constructor(e) {
+    l(this, me, !0);
+    l(this, "domNode", document.createTextNode(""));
+    l(this, "isMounted", !1);
+    l(this, "source");
+    l(this, "elements", []);
+    l(this, "unsubscribe");
+    this.source = e;
+  }
+  mount(e, s) {
+    this.isMounted || (this.isMounted = !0, e.insertBefore(this.domNode, (s == null ? void 0 : s.nextSibling) ?? null), y(this.source) ? this.unsubscribe = v(() => {
+      const n = I(this.source);
+      se(() => {
+        this.update(n);
+      });
+    }) : this.update(this.elements));
+  }
+  unmount(e = !1) {
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0), this.isMounted && (this.cleanup(e), this.isMounted = !1);
+  }
+  cleanup(e) {
+    for (const s of this.elements)
+      s.unmount(e);
+    this.elements = [];
+  }
+  update(e) {
+    var s, n;
+    if (this.cleanup(!1), e.length > 0) {
+      for (let i = 0; i < e.length; i++) {
+        const o = e[i], f = i > 0 ? this.elements[i - 1] : void 0;
+        o.mount(this.domNode.parentElement, f == null ? void 0 : f.domNode), this.elements.push(o);
+      }
+      (n = this.domNode.parentNode) == null || n.insertBefore(this.domNode, ((s = this.elements.at(-1)) == null ? void 0 : s.domNode) ?? null);
+    }
+  }
+}
+var ge;
+ge = k;
+class ut {
+  constructor(e) {
+    l(this, ge, !0);
+    l(this, "config");
+    l(this, "element");
+    this.config = e;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(e, s) {
+    const { content: n, parent: i } = this.config;
+    De(n) ? this.element = n : this.element = q(S(this.config.elementContext, ne(n))), this.element.mount(i);
+  }
+  unmount(e = !1) {
+    var s;
+    (s = this.element) != null && s.isMounted && this.element.unmount(e);
+  }
+}
+function R(t) {
+  return t instanceof Ae;
+}
+function De(t) {
+  return (t == null ? void 0 : t[k]) === !0;
+}
+function ne(t) {
+  return _(t) || (t = [t]), t.flat(1 / 0).filter((e) => e != null && e !== !1).map((e) => R(e) ? e : e instanceof Node ? N("$node", { value: e }) : y(e) ? N("$dynamic", { source: e }) : N("$text", { value: e }));
+}
+function N(t, e, ...s) {
+  return new Ae(t, e, ...s);
+}
+class Ae {
+  constructor(e, s, ...n) {
+    l(this, "type");
+    l(this, "props");
+    l(this, "children");
+    this.type = e, this.props = s, this.children = ne(n);
+  }
+}
+const Tt = Je.bind(N);
+function Lt(t, e, s) {
+  return N("$dynamic", {
+    source: te(() => {
+      const n = I(t);
+      return n && e ? e : !n && s ? s : null;
+    })
+  });
+}
+function Ct(t, e, s) {
+  return N("$list", { items: te(() => t), keyFn: e, renderFn: s });
+}
+function Dt(t, e) {
+  return N("$portal", { parent: t, content: e });
+}
+function S(t, e) {
+  return (_(e) ? e : [e]).map((n) => {
+    if (E(n.type))
+      return new z(t, n.type, n.props, n.children);
+    if (O(n.type))
+      switch (n.type) {
+        case "$node": {
+          const i = n.props;
+          return new ce(i.value);
+        }
+        case "$text": {
+          const i = n.props;
+          return new ce(document.createTextNode(String(i.value)));
+        }
+        case "$list": {
+          const i = n.props;
+          return new rt({
+            items: i.items,
+            keyFn: i.keyFn,
+            renderFn: i.renderFn,
+            elementContext: t
+          });
+        }
+        case "$dynamic": {
+          const i = n.props;
+          return new Qe({
+            source: i.source,
+            elementContext: t
+          });
+        }
+        case "$outlet": {
+          const i = n.props;
+          return new Ce(i.children);
+        }
+        case "$portal": {
+          const i = n.props;
+          return new ut({
+            content: i.content,
+            parent: i.parent,
+            elementContext: t
+          });
+        }
+        default:
+          if (n.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${n.type}`);
+          return new et({
+            tag: n.type,
+            props: n.props ?? {},
+            children: n.children,
+            elementContext: t
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${n.type}`);
+  });
+}
+function q(t) {
+  return t.length === 1 ? t[0] : new Ce(t);
+}
+function Pe(t) {
+  return t == null || t === !1 || O(t) || qe(t) || R(t) || y(t) || X(Pe, t);
+}
+export {
+  vt as A,
+  bt as B,
+  Dt as C,
+  Ct as D,
+  Et as I,
+  kt as P,
+  nt as S,
+  z as V,
+  ht as a,
+  pt as b,
+  K as c,
+  te as d,
+  gt as e,
+  O as f,
+  J as g,
+  H as h,
+  E as i,
+  I as j,
+  Lt as k,
+  Tt as l,
+  Mt as m,
+  U as n,
+  mt as o,
+  N as p,
+  q,
+  S as r,
+  Nt as s,
+  A as t,
+  wt as u,
+  xt as v,
+  v as w,
+  Ke as x,
+  yt as y,
+  se as z
+};
+//# sourceMappingURL=markup-CSJbSI8_.js.map