@manyducks.co/dolla 2.0.0-alpha.34 → 2.0.0-alpha.35

package/dist/markup-BWJWLvDF.js

@@ -0,0 +1,1634 @@
+var Ue = Object.defineProperty;
+var me = (n) => {
+  throw TypeError(n);
+};
+var Ge = (n, e, t) => e in n ? Ue(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var l = (n, e, t) => Ge(n, typeof e != "symbol" ? e + "" : e, t), _e = (n, e, t) => e.has(n) || me("Cannot " + t);
+var T = (n, e, t) => (_e(n, e, "read from private field"), t ? t.call(n) : e.get(n)), L = (n, e, t) => e.has(n) ? me("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), I = (n, e, t, s) => (_e(n, e, "write to private field"), s ? s.call(n, t) : e.set(n, t), t);
+var D = /* @__PURE__ */ ((n) => (n[n.Computed = 1] = "Computed", n[n.Effect = 2] = "Effect", n[n.Tracking = 4] = "Tracking", n[n.Notified = 8] = "Notified", n[n.Recursed = 16] = "Recursed", n[n.Dirty = 32] = "Dirty", n[n.PendingComputed = 64] = "PendingComputed", n[n.PendingEffect = 128] = "PendingEffect", n[n.Propagated = 224] = "Propagated", n))(D || {});
+function ze({
+  updateComputed: n,
+  notifyEffect: e
+}) {
+  let t, s;
+  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 f = u.depsTail;
+      if (f !== void 0 && f.dep === r)
+        return;
+      const h = f !== void 0 ? f.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, f);
+    },
+    /**
+     * 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, f = r, h = 0;
+      e: do {
+        const d = r.sub, m = d.flags;
+        if (!(m & 244) && (d.flags = m | u | 8, !0) || m & 16 && !(m & 4) && (d.flags = m & -17 | u | 8, !0) || !(m & 224) && a(r, d) && (d.flags = m | 16 | u | 8, d.subs !== void 0)) {
+          const _ = d.subs;
+          if (_ !== void 0) {
+            _.nextSub !== void 0 ? (_.prevSub = f, r = f = _, u = 64, ++h) : (r = _, u = m & 2 ? 128 : 64);
+            continue;
+          }
+          m & 2 && (s !== void 0 ? s.depsTail.nextDep = d.deps : t = d, s = d);
+        } else m & (4 | u) ? !(m & u) && m & 224 && a(r, d) && (d.flags = m | u) : (d.flags = m | u | 8, (m & 10) === 2 && (s !== void 0 ? s.depsTail.nextDep = d.deps : t = d, s = d));
+        if ((r = f.nextSub) !== void 0) {
+          f = r, u = h ? 64 : 32;
+          continue;
+        }
+        for (; h; ) {
+          --h;
+          const g = f.dep.subs;
+          if (f = g.prevSub, g.prevSub = void 0, (r = f.nextSub) !== void 0) {
+            f = 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 f = u.nextDep;
+        f !== void 0 && (p(f), u.nextDep = void 0);
+      } else r.deps !== void 0 && (p(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))) && n(r)) {
+        const f = r.subs;
+        f !== void 0 && c(f);
+      }
+    },
+    /**
+     * 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 f = r.deps;
+        do {
+          const h = f.dep;
+          "flags" in h && h.flags & 2 && h.flags & 224 && e(h), f = f.nextDep;
+        } while (f !== 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 (; t !== void 0; ) {
+        const r = t, u = r.depsTail, f = u.nextDep;
+        f !== void 0 ? (u.nextDep = void 0, t = f.sub) : (t = void 0, s = void 0), e(r) || (r.flags &= -9);
+      }
+    }
+  };
+  function i(r, u, f, h) {
+    const d = {
+      dep: r,
+      sub: u,
+      nextDep: f,
+      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 m = r.subsTail;
+      d.prevSub = m, m.nextSub = d;
+    }
+    return u.depsTail = d, r.subsTail = d, d;
+  }
+  function o(r) {
+    let u = 0, f;
+    e: do {
+      f = !1;
+      const h = r.dep;
+      if ("flags" in h) {
+        const d = h.flags;
+        if ((d & 33) === 33) {
+          if (n(h)) {
+            const m = h.subs;
+            m.nextSub !== void 0 && c(m), f = !0;
+          }
+        } else if ((d & 65) === 65) {
+          const m = h.subs;
+          m.nextSub !== void 0 && (m.prevSub = r), r = h.deps, ++u;
+          continue;
+        }
+      }
+      if (!f && r.nextDep !== void 0) {
+        r = r.nextDep;
+        continue;
+      }
+      if (u) {
+        let d = r.sub;
+        do {
+          --u;
+          const m = d.subs;
+          if (f) {
+            if (n(d)) {
+              (r = m.prevSub) !== void 0 ? (m.prevSub = void 0, c(d.subs), d = r.sub) : d = m.sub;
+              continue;
+            }
+          } else
+            d.flags &= -65;
+          if ((r = m.prevSub) !== void 0) {
+            if (m.prevSub = void 0, r.nextDep !== void 0) {
+              r = r.nextDep;
+              continue e;
+            }
+            d = r.sub;
+          } else {
+            if ((r = m.nextDep) !== void 0)
+              continue e;
+            d = m.sub;
+          }
+          f = !1;
+        } while (u);
+      }
+      return f;
+    } while (!0);
+  }
+  function c(r) {
+    do {
+      const u = r.sub, f = u.flags;
+      (f & 96) === 64 && (u.flags = f | 32 | 8, (f & 10) === 2 && (s !== void 0 ? s.depsTail.nextDep = u.deps : t = u, s = u)), r = r.nextSub;
+    } while (r !== void 0);
+  }
+  function a(r, u) {
+    const f = u.depsTail;
+    if (f !== void 0) {
+      let h = u.deps;
+      do {
+        if (h === r)
+          return !0;
+        if (h === f)
+          break;
+        h = h.nextDep;
+      } while (h !== void 0);
+    }
+    return !1;
+  }
+  function p(r) {
+    do {
+      const u = r.dep, f = 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 m = u.flags;
+        m & 32 || (u.flags = m | 32);
+        const _ = u.deps;
+        if (_ !== void 0) {
+          r = _, u.depsTail.nextDep = f, u.deps = void 0, u.depsTail = void 0;
+          continue;
+        }
+      }
+      r = f;
+    } while (r !== void 0);
+  }
+}
+function q(n) {
+  const e = typeof n;
+  switch (e) {
+    case "undefined":
+      return e;
+    case "number":
+      return isNaN(n) ? "NaN" : e;
+    case "function":
+      return /^\s*class\s+/.test(n.toString()) ? "class" : e;
+    case "object":
+      return n === null ? "null" : n instanceof Promise ? "promise" : n instanceof Map ? "map" : n instanceof Set ? "set" : Array.isArray(n) ? "array" : e;
+    default:
+      return e;
+  }
+}
+function $(n) {
+  return Array.isArray(n);
+}
+function De(...n) {
+  const e = n[0], t = (s) => $(s) && s.every((i) => e(i));
+  return n.length < 2 ? t : t(n[1]);
+}
+function Tt(...n) {
+  const e = n[0], t = P(n[2]) ? n[2] : "Expected an array of valid items. Got type: %t, value: %v", s = (i) => {
+    if ($(i) && i.every((o) => e(o)))
+      return !0;
+    throw new TypeError(K(i, t));
+  };
+  return n.length < 2 ? s : s(n[1]);
+}
+function P(n) {
+  return typeof n == "string";
+}
+function Nt(n, e) {
+  if (P(n))
+    return !0;
+  throw new TypeError(K(n, e ?? "Expected a string. Got type: %t, value: %v"));
+}
+function A(n) {
+  return typeof n == "function" && !Be(n);
+}
+function Fe(n) {
+  return typeof n == "number" && !isNaN(n);
+}
+function Be(n) {
+  return typeof n == "function" && /^\s*class\s+/.test(n.toString());
+}
+function At(...n) {
+  const e = n[0], t = P(n[2]) ? n[2] : `Expected instance of ${e.name}. Got type: %t, value: %v`, s = (i) => {
+    if (i instanceof e)
+      return !0;
+    throw new TypeError(K(i, t));
+  };
+  return n.length < 2 ? s : s(n[1]);
+}
+function te(n) {
+  return n != null && typeof n == "object" && !$(n);
+}
+function Dt(n, e) {
+  if (te(n))
+    return !0;
+  throw new TypeError(K(n, e));
+}
+function K(n, e) {
+  var i;
+  const t = q(n), s = ((i = n == null ? void 0 : n.toString) == null ? void 0 : i.call(n)) || String(n);
+  return e.replaceAll("%t", t).replaceAll("%v", s);
+}
+const ne = Symbol.for("DollaReactive"), se = Symbol("dependency"), {
+  link: ke,
+  propagate: He,
+  updateDirtyFlag: We,
+  startTracking: ie,
+  endTracking: re,
+  processEffectNotifications: Ke,
+  processComputedUpdate: Ze,
+  processPendingInnerEffects: Xe
+} = ze({
+  updateComputed(n) {
+    const e = M;
+    M = n, ie(n);
+    try {
+      const t = n.currentValue, s = n.getter(t);
+      return n.equals(t, s) ? !1 : (n.currentValue = s, !0);
+    } finally {
+      M = e, re(n);
+    }
+  },
+  notifyEffect(n) {
+    const e = n.flags;
+    return e & D.Dirty || e & D.PendingComputed && We(n, e) ? Oe(n) : Xe(n, n.flags), !0;
+  }
+});
+let M;
+const j = [];
+let X = !1;
+function Ye() {
+  X || (X = !0, queueMicrotask(() => {
+    X = !1;
+    for (let n = 0; n < j.length; n++) {
+      const e = j[n], t = M;
+      M = e, ie(e);
+      try {
+        e.fn();
+      } finally {
+        M = t, re(e);
+      }
+    }
+    j.length = 0;
+  }));
+}
+function Oe(n) {
+  j.push(n), Ye();
+}
+function Je() {
+  ie(this), re(this), queueMicrotask(() => {
+    j.splice(j.indexOf(this), 1);
+  });
+}
+var N, R;
+class Qe {
+  constructor(e, t) {
+    L(this, N);
+    L(this, R);
+    /**
+     * A label for debugging purposes.
+     */
+    l(this, "name");
+    I(this, N, e), I(this, R, (t == null ? void 0 : t.equals) ?? Object.is), t != null && t.name && (this.name = t.name), Object.defineProperties(this, {
+      [ne]: {
+        value: !0,
+        configurable: !1,
+        enumerable: !1,
+        writable: !1
+      },
+      [se]: {
+        value: e,
+        configurable: !1,
+        enumerable: !1,
+        writable: !1
+      }
+    });
+  }
+  get value() {
+    return T(this, N).currentValue;
+  }
+  set value(e) {
+    if (!T(this, R).call(this, T(this, N).currentValue, e)) {
+      T(this, N).currentValue = e;
+      const t = T(this, N).subs;
+      t !== void 0 && (He(t), Ke());
+    }
+  }
+}
+N = new WeakMap(), R = new WeakMap();
+var V;
+class et {
+  constructor(e) {
+    L(this, V);
+    I(this, V, e), Object.defineProperties(this, {
+      [ne]: {
+        value: !0,
+        configurable: !1,
+        enumerable: !1,
+        writable: !1
+      },
+      [se]: {
+        value: e,
+        configurable: !1,
+        enumerable: !1,
+        writable: !1
+      }
+    });
+  }
+  get value() {
+    const e = T(this, V), t = e.flags;
+    return t & (D.Dirty | D.PendingComputed) && Ze(e, t), e.currentValue;
+  }
+}
+V = new WeakMap();
+function w(n) {
+  return n != null && n[ne] === !0;
+}
+function Q(n, e) {
+  return new Qe({ currentValue: n, subs: void 0, subsTail: void 0 }, e);
+}
+function oe(n, e) {
+  return new et({
+    currentValue: void 0,
+    equals: (e == null ? void 0 : e.equals) ?? Object.is,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: D.Computed | D.Dirty,
+    getter: (t) => {
+      let s = n(t);
+      return s = S(s), s;
+    }
+  });
+}
+function tt(n, e) {
+  if (A(e))
+    n.value = e(n.value);
+  else if (arguments.length > 1)
+    n.value = e;
+  else
+    return (t) => tt(n, t);
+}
+function S(n) {
+  if (w(n)) {
+    if (M !== void 0) {
+      const e = n[se];
+      ke(e, M);
+    }
+    return n.value;
+  } else
+    return n;
+}
+function kt(n) {
+  return w(n) ? n.value : n;
+}
+function b(n) {
+  const e = {
+    fn: n,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: D.Effect
+  };
+  return M !== void 0 && ke(e, M), Oe(e), Je.bind(e);
+}
+function Pe(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var z = { exports: {} }, ge;
+function nt() {
+  return ge || (ge = 1, function(n, e) {
+    Object.defineProperty(e, "__esModule", { value: !0 });
+    var t = /* @__PURE__ */ function() {
+      function p(r, u) {
+        var f = [], h = !0, d = !1, m = void 0;
+        try {
+          for (var _, g = r[Symbol.iterator](); !(h = (_ = g.next()).done) && (f.push(_.value), !(u && f.length === u)); h = !0) ;
+        } catch (y) {
+          d = !0, m = y;
+        } finally {
+          try {
+            !h && g.return && g.return();
+          } finally {
+            if (d) throw m;
+          }
+        }
+        return f;
+      }
+      return function(r, u) {
+        if (Array.isArray(r)) return r;
+        if (Symbol.iterator in Object(r)) return p(r, u);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }(), s = function(p) {
+      return p.reduce(function(r, u) {
+        return 16 > u ? r + "0" + u.toString(16) : r + u.toString(16);
+      }, "#");
+    }, i = function(p, r, u) {
+      var f = 0.5 > u ? u * (1 + r) : u + r - u * r, h = 2 * u - f, d = function(y, C, x) {
+        var Z = Math.round, v = 0 > x ? x + 1 : 1 < x ? x - 1 : x;
+        return v = v < 1 / 6 ? y + 6 * (C - y) * v : v < 1 / 2 ? C : v < 2 / 3 ? y + 6 * (C - y) * (2 / 3 - v) : y, Z(255 * v);
+      }, m = d(h, f, p + 1 / 3), _ = d(h, f, p), g = d(h, f, p - 1 / 3);
+      return [m, _, g];
+    }, o = function(p, r, u, f) {
+      var h = p % 1007 / 1007, d = function(y, C, x) {
+        return y * (x - C) + C;
+      }, m = d(h, r.min, r.max), _ = d(h, u.min, u.max), g = d(h, f.max, f.min);
+      return [m, _, g];
+    }, c = function(p) {
+      return p.split("").reduce(function(r, u, f) {
+        return r * u.charCodeAt(0) * f + 1;
+      }, 1);
+    }, a = function(p) {
+      var r = p.str, u = p.hue, f = u === void 0 ? { min: 0, max: 360 } : u, h = p.sat, d = h === void 0 ? { min: 0.35, max: 0.65 } : h, m = p.light, _ = m === void 0 ? { min: 0.3, max: 0.7 } : m, g = p.hashFunction, y = g === void 0 ? c : g, C = p.scheme, x = C === void 0 ? "hex" : C, Z = o(y(r), f, d, _), v = t(Z, 3), ae = v[0], de = v[1], he = v[2], pe = i(ae / 360, de, he), Ve = s(pe);
+      return x === "hsl" ? [ae, de, he] : x === "rgb" ? pe : Ve;
+    };
+    e.default = a, n.exports = e.default;
+  }(z, z.exports)), z.exports;
+}
+var st = nt();
+const it = /* @__PURE__ */ Pe(st);
+var Y, we;
+function rt() {
+  return we || (we = 1, Y = function n(e, t) {
+    if (e === t) return !0;
+    if (e && t && typeof e == "object" && typeof t == "object") {
+      if (e.constructor !== t.constructor) return !1;
+      var s, i, o;
+      if (Array.isArray(e)) {
+        if (s = e.length, s != t.length) return !1;
+        for (i = s; i-- !== 0; )
+          if (!n(e[i], t[i])) return !1;
+        return !0;
+      }
+      if (e instanceof Map && t instanceof Map) {
+        if (e.size !== t.size) return !1;
+        for (i of e.entries())
+          if (!t.has(i[0])) return !1;
+        for (i of e.entries())
+          if (!n(i[1], t.get(i[0]))) return !1;
+        return !0;
+      }
+      if (e instanceof Set && t instanceof Set) {
+        if (e.size !== t.size) return !1;
+        for (i of e.entries())
+          if (!t.has(i[0])) return !1;
+        return !0;
+      }
+      if (ArrayBuffer.isView(e) && ArrayBuffer.isView(t)) {
+        if (s = e.length, s != t.length) return !1;
+        for (i = s; i-- !== 0; )
+          if (e[i] !== t[i]) return !1;
+        return !0;
+      }
+      if (e.constructor === RegExp) return e.source === t.source && e.flags === t.flags;
+      if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === t.valueOf();
+      if (e.toString !== Object.prototype.toString) return e.toString() === t.toString();
+      if (o = Object.keys(e), s = o.length, s !== Object.keys(t).length) return !1;
+      for (i = s; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(t, o[i])) return !1;
+      for (i = s; i-- !== 0; ) {
+        var c = o[i];
+        if (!n(e[c], t[c])) return !1;
+      }
+      return !0;
+    }
+    return e !== e && t !== t;
+  }), Y;
+}
+var ot = rt();
+const ut = /* @__PURE__ */ Pe(ot), Ot = () => {
+};
+let J = 1;
+function ue() {
+  return J = J % Number.MAX_SAFE_INTEGER + 1, J.toString(36) + Date.now().toString(36);
+}
+function Pt(n, e) {
+  return Object.is(n, e);
+}
+function Lt(n, e) {
+  if (Object.is(n, e)) return !0;
+  const t = q(n);
+  if (t !== q(e))
+    return !1;
+  switch (t) {
+    case "object":
+      let s = 0;
+      for (const i in n) {
+        if (n[i] !== e[i]) return !1;
+        s++;
+      }
+      return Object.keys(e).length === s;
+    case "array":
+      if (n.length !== e.length) return !1;
+      for (let i = 0; i < n.length; i++)
+        if (n[i] !== e[i]) return !1;
+      return !0;
+    case "map":
+      if (n.size !== e.size) return !1;
+      for (const i of n.keys())
+        if (n[i] !== e[i]) return !1;
+      return !0;
+    case "set":
+      if (A(n.symmetricDifference))
+        return n.symmetricDifference(e).size === 0;
+      for (const i of n.keys())
+        if (n[i] !== e.get(i)) return !1;
+      return !0;
+  }
+  return !1;
+}
+const It = ut;
+function ft(n, e) {
+  const t = (s) => {
+    const i = {};
+    for (const o in s)
+      n.includes(o) || (i[o] = s[o]);
+    return i;
+  };
+  return e == null ? t : t(e);
+}
+function jt(n) {
+  return it({
+    str: n,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function $t(n) {
+  if (n instanceof RegExp)
+    return (s) => n.test(s);
+  const e = {
+    positive: [],
+    negative: []
+  }, t = n.split(",").map((s) => s.trim()).filter((s) => s !== "");
+  for (let s of t) {
+    let i = "positive";
+    s.startsWith("-") && (i = "negative", s = s.slice(1)), s === "*" ? e[i].push(function() {
+      return !0;
+    }) : s.endsWith("*") ? e[i].push(function(o) {
+      return o.startsWith(s.slice(0, s.length - 1));
+    }) : e[i].push(function(o) {
+      return o === s;
+    });
+  }
+  return function(s) {
+    const { positive: i, negative: o } = e;
+    return !(o.some((c) => c(s)) || i.length > 0 && !i.some((c) => c(s)));
+  };
+}
+const qt = Symbol.for("DollaRef"), Le = Symbol.for("DollaMarkup"), k = Symbol.for("DollaMarkupElement"), Rt = Symbol.for("DollaRouter");
+function Vt(n, e) {
+  return e.outlet();
+}
+function ct(n) {
+  for (var e, t, s = arguments, i = 1, o = "", c = "", a = [0], p = function(f) {
+    i === 1 && (f || (o = o.replace(/^\s*\n\s*|\s*\n\s*$/g, ""))) ? a.push(f ? s[f] : o) : i === 3 && (f || o) ? (a[1] = f ? s[f] : o, i = 2) : i === 2 && o === "..." && f ? a[2] = Object.assign(a[2] || {}, s[f]) : i === 2 && o && !f ? (a[2] = a[2] || {})[o] = !0 : i >= 5 && (i === 5 ? ((a[2] = a[2] || {})[t] = f ? o ? o + s[f] : s[f] : o, i = 6) : (f || o) && (a[2][t] += f ? o + s[f] : o)), o = "";
+  }, r = 0; r < n.length; r++) {
+    r && (i === 1 && p(), p(r));
+    for (var u = 0; u < n[r].length; u++) e = n[r][u], i === 1 ? e === "<" ? (p(), a = [a, "", null], i = 3) : o += e : i === 4 ? o === "--" && e === ">" ? (i = 1, o = "") : o = e + o[0] : c ? e === c ? c = "" : o += e : e === '"' || e === "'" ? c = e : e === ">" ? (p(), i = 1) : i && (e === "=" ? (i = 5, t = o, o = "") : e === "/" && (i < 5 || n[r][u + 1] === ">") ? (p(), i === 3 && (a = a[0]), i = a, (a = a[0]).push(this.apply(null, i.slice(1))), i = 0) : e === " " || e === "	" || e === `
+` || e === "\r" ? (p(), i = 2) : o += e), i === 3 && o === "!--" && (i = 4, a = a[0]);
+  }
+  return p(), a.length > 2 ? a.slice(1) : a[1];
+}
+var xe;
+xe = k;
+class be {
+  constructor(e) {
+    l(this, xe, !0);
+    l(this, "node");
+    this.node = e;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(e, t) {
+    e.insertBefore(this.node, (t == null ? void 0 : t.nextSibling) ?? null);
+  }
+  unmount(e = !1) {
+    this.node.parentNode && !e && this.node.parentNode.removeChild(this.node);
+  }
+}
+var Se;
+Se = k;
+class lt {
+  constructor(e) {
+    l(this, Se, !0);
+    l(this, "node", 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.node.parentNode != null;
+  }
+  mount(e, t) {
+    this.isMounted || (e.insertBefore(this.node, (t == null ? void 0 : t.nextSibling) ?? null), this.unsubscribe = b(() => {
+      const s = S(this.source);
+      if (!Re(s))
+        throw console.error(s), new TypeError(
+          `Dynamic received invalid value to render. Got type: ${q(s)}, value: ${s}`
+        );
+      this.update($(s) ? s : [s]);
+    }));
+  }
+  unmount(e = !1) {
+    var t, s;
+    (t = this.unsubscribe) == null || t.call(this), this.isMounted && (this.cleanup(e), (s = this.node.parentNode) == null || s.removeChild(this.node));
+  }
+  cleanup(e) {
+    for (const t of this.children)
+      t.unmount(e);
+    this.children = [];
+  }
+  update(e) {
+    var o, c, a;
+    if (this.cleanup(!1), e == null || e.length === 0 || !this.isMounted)
+      return;
+    const t = e.flatMap((p) => qe(p) ? p : O(this.elementContext, ce(p)));
+    for (const p of t) {
+      const r = ((o = this.children.at(-1)) == null ? void 0 : o.node) || this.node;
+      p.mount(this.node.parentNode, r), this.children.push(p);
+    }
+    const s = this.node.parentNode, i = ((a = (c = this.children.at(-1)) == null ? void 0 : c.node) == null ? void 0 : a.nextSibling) ?? null;
+    s.insertBefore(this.node, i);
+  }
+}
+const at = (n) => /^on[A-Z]/.test(n);
+var Me;
+Me = k;
+class dt {
+  constructor({ tag: e, props: t, children: s, elementContext: i }) {
+    l(this, Me, !0);
+    l(this, "node");
+    l(this, "props");
+    l(this, "childMarkup", []);
+    l(this, "children", []);
+    l(this, "unsubscribers", []);
+    l(this, "elementContext");
+    l(this, "uniqueId", ue());
+    // 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 (i = { ...i }, e.toLowerCase() === "svg" && (i.isSVG = !0), i.isSVG ? this.node = document.createElementNS("http://www.w3.org/2000/svg", e) : this.node = document.createElement(e), t.ref)
+      if (A(t.ref))
+        this.ref = t.ref, this.ref(this.node);
+      else
+        throw new Error("Expected ref to be a function. Got: " + t.ref);
+    this.props = {
+      ...ft(["ref", "class", "className"], t),
+      class: t.className ?? t.class
+    }, s && (this.childMarkup = s), this.elementContext = i, this.children = O(this.elementContext, this.childMarkup);
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(e, t) {
+    if (e == null)
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${e}`);
+    if (!this.isMounted) {
+      for (let s = 0; s < this.children.length; s++) {
+        const i = this.children[s], o = s > 0 ? this.children[s - 1].node : void 0;
+        i.mount(this.node, o);
+      }
+      this.applyProps(this.node, this.props), this.props.style && this.applyStyles(this.node, this.props.style, this.unsubscribers), this.props.class && this.applyClasses(this.node, this.props.class, this.unsubscribers);
+    }
+    e.insertBefore(this.node, (t == null ? void 0 : t.nextSibling) ?? null), setTimeout(() => {
+      this.canClickAway = !0;
+    }, 0);
+  }
+  unmount(e = !1) {
+    var t;
+    if (this.isMounted) {
+      for (const s of this.children)
+        s.unmount(!0);
+      e || (t = this.node.parentNode) == null || t.removeChild(this.node), this.ref && this.ref(void 0), this.canClickAway = !1;
+      for (const s of this.unsubscribers)
+        s();
+      this.unsubscribers.length = 0;
+    }
+  }
+  getUpdateKey(e, t) {
+    return `${this.uniqueId}:${e}:${t}`;
+  }
+  attachProp(e, t) {
+    w(e) ? this.unsubscribers.push(b(() => t(S(e)))) : t(e);
+  }
+  applyProps(e, t) {
+    for (const s in t) {
+      const i = t[s];
+      if (s === "attributes") {
+        const o = i;
+        for (const c in o)
+          this.attachProp(o[c], (a) => {
+            a == null ? e.removeAttribute(c) : e.setAttribute(c, String(a));
+          });
+      } else if (s === "onClickOutside" || s === "onclickoutside") {
+        const o = (a) => {
+          this.canClickAway && !e.contains(a.target) && (w(i) ? i.value(a) : i(a));
+        }, c = { capture: !0 };
+        window.addEventListener("click", o, c), this.unsubscribers.push(() => {
+          window.removeEventListener("click", o, c);
+        });
+      } else if (at(s)) {
+        const o = s.slice(2).toLowerCase(), c = w(i) ? (a) => i.value(a) : i;
+        e.addEventListener(o, c), this.unsubscribers.push(() => {
+          e.removeEventListener(o, c);
+        });
+      } else if (s.includes("-"))
+        this.attachProp(i, (o) => {
+          o == null ? e.removeAttribute(s) : e.setAttribute(s, String(o));
+        });
+      else if (!ht.includes(s))
+        if (this.elementContext.isSVG)
+          this.attachProp(i, (o) => {
+            o != null ? e.setAttribute(s, String(t[s])) : e.removeAttribute(s);
+          });
+        else
+          switch (s) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(i, (o) => {
+                e[s] = 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;
+            // Attribute-aliased props
+            case "exportParts":
+            case "part":
+            case "translate":
+            case "type":
+            case "title": {
+              const o = s.toLowerCase();
+              this.attachProp(i, (c) => {
+                c == null ? e.removeAttribute(o) : e.setAttribute(o, String(c));
+              });
+              break;
+            }
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(i, (o) => {
+                typeof o == "string" ? e.autocomplete = o : o ? e.autocomplete = "on" : e.autocomplete = "off";
+              });
+              break;
+            default: {
+              this.attachProp(i, (o) => {
+                e[s] = o;
+              });
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(e, t, s) {
+    const i = [];
+    if (w(t)) {
+      let o;
+      const c = b(() => {
+        A(o) && o(), e.style.cssText = "", o = this.applyStyles(e, S(t), s);
+      });
+      s.push(c), i.push(c);
+    } else {
+      const o = je(t);
+      for (const c in o) {
+        const { value: a, priority: p } = o[c];
+        if (w(a)) {
+          const r = b(() => {
+            S(a) ? e.style.setProperty(c, String(a.value), p) : e.style.removeProperty(c);
+          });
+          s.push(r), i.push(r);
+        } else a != null && e.style.setProperty(c, String(a));
+      }
+    }
+    return function() {
+      for (const c of i)
+        c(), s.splice(s.indexOf(c), 1);
+    };
+  }
+  applyClasses(e, t, s) {
+    const i = [];
+    if (w(t)) {
+      let o;
+      const c = b(() => {
+        A(o) && o(), e.removeAttribute("class"), o = this.applyClasses(e, S(t), s);
+      });
+      s.push(c), i.push(c);
+    } else {
+      const o = Ie(t);
+      for (const c in o) {
+        const a = o[c];
+        if (w(a)) {
+          const p = b(() => {
+            S(a) ? e.classList.add(c) : e.classList.remove(c);
+          });
+          s.push(p), i.push(p);
+        } else a && e.classList.add(c);
+      }
+    }
+    return function() {
+      for (const c of i)
+        c(), s.splice(s.indexOf(c), 1);
+    };
+  }
+}
+function Ie(n) {
+  let e = {};
+  if (P(n)) {
+    const t = n.split(" ");
+    for (const s of t)
+      e[s] = !0;
+  } else te(n) ? Object.assign(e, n) : Array.isArray(n) && Array.from(n).filter(Boolean).forEach((t) => {
+    Object.assign(e, Ie(t));
+  });
+  return delete e.undefined, e;
+}
+function je(n) {
+  let e = {};
+  if (P(n)) {
+    const t = n.split(";").filter((s) => s.trim() !== "");
+    for (const s of t) {
+      const [i, o] = s.split(":"), c = {
+        value: o
+      };
+      o.includes("!important") ? (c.priority = "important", c.value = o.replace("!important", "").trim()) : c.value = o.trim(), e[ye(i.trim())] = c;
+    }
+  }
+  if (te(n))
+    for (const t in n)
+      t.startsWith("--") ? e[t] = { value: n[t] } : e[ye(t)] = { value: n[t] };
+  else Array.isArray(n) && Array.from(n).filter((t) => t != null).forEach((t) => {
+    Object.assign(e, je(t));
+  });
+  return e;
+}
+function ye(n) {
+  return n.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (e, t) => (t ? "-" : "") + e.toLowerCase());
+}
+const ht = ["ref", "children", "class", "style", "data"];
+var pt = Object.defineProperty, mt = (n, e, t) => e in n ? pt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, ve = (n, e, t) => mt(n, typeof e != "symbol" ? e + "" : e, t);
+class ee {
+  constructor() {
+    ve(this, "_l", /* @__PURE__ */ new Map()), ve(this, "_a", (e) => {
+      if (typeof e != "string" && !(e instanceof Symbol))
+        throw new TypeError("Emitter: eventName should be a string or symbol");
+    });
+  }
+  emit(e, ...t) {
+    let s = this.listeners(e);
+    for (const i of s)
+      try {
+        i(...t);
+      } catch (o) {
+        let c = this._l.get("error");
+        if (c != null && c.length)
+          for (const a of c)
+            a(o, e, i, ...t);
+        else throw o;
+      }
+    return e != "*" && this.emit("*", e, ...t) || s.length > 0;
+  }
+  on(e, t) {
+    return this.listeners(e).push(t), this;
+  }
+  off(e, t) {
+    const s = this.listeners(e);
+    return s.splice(s.indexOf(t), 1), this;
+  }
+  once(e, t) {
+    return this.on(e, (...s) => {
+      t(...s), this.off(e, t);
+    });
+  }
+  clear() {
+    this._l.clear();
+  }
+  listeners(e) {
+    return this._l.get(e) ?? (this._a(e), this._l.set(e, []).get(e));
+  }
+  events() {
+    return [...this._l.entries()].filter(([, e]) => e.length).map(([e]) => e);
+  }
+}
+var U, G;
+class fe {
+  constructor(e) {
+    L(this, U);
+    L(this, G, !1);
+    I(this, U, e);
+  }
+  get type() {
+    return T(this, U);
+  }
+  get isStopped() {
+    return T(this, G);
+  }
+  stop() {
+    I(this, G, !0);
+  }
+  get [Symbol.toStringTag]() {
+    return "ContextEvent";
+  }
+}
+U = new WeakMap(), G = new WeakMap();
+let _t = class {
+  constructor(e) {
+    l(this, "__store");
+    this.__store = e;
+    const t = Object.getOwnPropertyDescriptors(this.__store._logger);
+    for (const s in t)
+      s !== "setName" && Object.defineProperty(this, s, t[s]);
+  }
+  get isMounted() {
+    return this.__store.isMounted;
+  }
+  get name() {
+    return this.__store._name;
+  }
+  set name(e) {
+    this.__store._name = e, this.__store._logger.setName(e);
+  }
+  on(e, t) {
+    if (e === "*") {
+      const s = (i, o, ...c) => {
+        t(o, ...c);
+      };
+      this.__store._elementContext.emitter.on(e, s), this.__store._wildcardListeners.set(t, s);
+    } else
+      this.__store._elementContext.emitter.on(e, t);
+  }
+  off(e, t) {
+    if (e === "*") {
+      const s = this.__store._wildcardListeners.get(t);
+      s && (this.__store._elementContext.emitter.off(e, s), this.__store._wildcardListeners.delete(t));
+    } else
+      this.__store._elementContext.emitter.off(e, t);
+  }
+  once(e, t) {
+    if (e === "*") {
+      const s = (i, o, ...c) => {
+        this.__store._wildcardListeners.delete(t), t(o, ...c);
+      };
+      this.__store._elementContext.emitter.once(e, s), this.__store._wildcardListeners.set(t, s);
+    } else
+      this.__store._elementContext.emitter.once(e, t);
+  }
+  emit(e, ...t) {
+    return this.__store._elementContext.emitter.emit(e, new fe(e), ...t);
+  }
+  get(e) {
+    if (A(e)) {
+      let t = this.__store._elementContext, s;
+      for (; s = t.stores.get(e), s == null && t.parent != null; )
+        t = t.parent;
+      if (s == null)
+        throw new B(`Store '${e.name}' is not provided on this context.`);
+      return s.value;
+    } else
+      throw new B("Invalid store.");
+  }
+  onMount(e) {
+    this.__store._emitter.on("mounted", e);
+  }
+  onUnmount(e) {
+    this.__store._emitter.on("unmounted", e);
+  }
+  effect(e) {
+    const t = this.__store;
+    if (t.isMounted) {
+      const s = b(e);
+      return t._unsubscribes.push(s), s;
+    } else {
+      let s, i = !1;
+      return t._emitter.on("mounted", () => {
+        i || (s = b(e), t._unsubscribes.push(s));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+};
+class gt {
+  constructor(e, t) {
+    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, "_emitter", new ee());
+    l(this, "_wildcardListeners", /* @__PURE__ */ new Map());
+    l(this, "_logger");
+    l(this, "_unsubscribes", []);
+    l(this, "_name");
+    l(this, "_id", ue());
+    this.fn = e, this._name = e.name, this._options = t;
+  }
+  get name() {
+    return this._name || this._id;
+  }
+  /**
+   * 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), this._emitter.on("error", (s, i, ...o) => {
+      this._logger.error({ error: s, eventName: i, args: o }), this._logger.crash(s);
+    });
+    const t = new _t(this);
+    try {
+      this.value = this.fn.call(t, this._options, t);
+    } catch (s) {
+      throw this._logger.crash(s), s;
+    }
+    return e.stores.set(this.fn, this), !0;
+  }
+  handleMount() {
+    this.isMounted = !0, this._emitter.emit("mounted");
+  }
+  handleUnmount() {
+    this.isMounted = !1, this._emitter.emit("unmounted"), this._emitter.clear();
+    for (const e of this._unsubscribes)
+      e();
+    this._unsubscribes.length = 0;
+  }
+}
+class B extends Error {
+}
+class wt {
+  constructor(e) {
+    l(this, "__view");
+    l(this, "list", Mt);
+    l(this, "if", St);
+    l(this, "portal", Et);
+    this.__view = e;
+    const t = Object.getOwnPropertyDescriptors(this.__view._logger);
+    for (const s in t)
+      s !== "setName" && Object.defineProperty(this, s, t[s]);
+  }
+  get uid() {
+    return this.__view.uniqueId;
+  }
+  get isMounted() {
+    return this.__view.isMounted;
+  }
+  get name() {
+    return this.__view._elementContext.viewName || this.__view.uniqueId;
+  }
+  set name(e) {
+    this.__view._elementContext.viewName = e, this.__view._logger.setName(e);
+  }
+  on(e, t) {
+    if (e === "*") {
+      const s = (i, o, ...c) => {
+        t(o, ...c);
+      };
+      this.__view._elementContext.emitter.on(e, s), this.__view._wildcardListeners.set(t, s);
+    } else
+      this.__view._elementContext.emitter.on(e, t);
+  }
+  off(e, t) {
+    if (e === "*") {
+      const s = this.__view._wildcardListeners.get(t);
+      s && (this.__view._elementContext.emitter.off(e, s), this.__view._wildcardListeners.delete(t));
+    } else
+      this.__view._elementContext.emitter.off(e, t);
+  }
+  once(e, t) {
+    if (e === "*") {
+      const s = (i, o, ...c) => {
+        this.__view._wildcardListeners.delete(t), t(o, ...c);
+      };
+      this.__view._elementContext.emitter.once(e, s), this.__view._wildcardListeners.set(t, s);
+    } else
+      this.__view._elementContext.emitter.once(e, t);
+  }
+  emit(e, ...t) {
+    return this.__view._elementContext.emitter.emit(e, new fe(e), ...t);
+  }
+  provide(e, t) {
+    const s = new gt(e, t);
+    if (s.attach(this.__view._elementContext))
+      return this.__view._emitter.on("mounted", () => {
+        s.handleMount();
+      }), this.__view._emitter.on("unmounted", () => {
+        s.handleUnmount();
+      }), s.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 (A(e)) {
+      let t = this.__view._elementContext, s;
+      for (; s = t.stores.get(e), s == null && t.parent != null; )
+        t = t.parent;
+      if (s == null)
+        throw new B(`Store '${e.name}' is not provided on this context.`);
+      return s.value;
+    } else
+      throw new B("Invalid store.");
+  }
+  beforeMount(e) {
+    this.__view._emitter.on("beforeMount", e);
+  }
+  onMount(e) {
+    this.__view._emitter.on("mounted", e);
+  }
+  beforeUnmount(e) {
+    this.__view._emitter.on("beforeUnmount", e);
+  }
+  onUnmount(e) {
+    this.__view._emitter.on("unmounted", e);
+  }
+  effect(e) {
+    const t = this.__view;
+    if (t.isMounted) {
+      const s = b(e);
+      return this.__view._unsubscribes.push(s), s;
+    } else {
+      let s, i = !1;
+      return t._emitter.on("mounted", () => {
+        i || (s = b(e), this.__view._unsubscribes.push(s));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+  outlet() {
+    return E("$outlet", { children: this.__view._children });
+  }
+}
+var Ee;
+Ee = k;
+const le = class le {
+  constructor(e, t, s, i = []) {
+    l(this, Ee, !0);
+    l(this, "uniqueId", ue());
+    l(this, "_elementContext");
+    l(this, "_logger");
+    l(this, "_view");
+    l(this, "_props");
+    l(this, "_element");
+    l(this, "_childMarkup");
+    l(this, "_children", Q([]));
+    l(this, "_unsubscribes", []);
+    l(this, "_emitter", new ee());
+    l(this, "_wildcardListeners", /* @__PURE__ */ new Map());
+    l(this, "isMounted", !1);
+    this._elementContext = {
+      ...e,
+      data: {},
+      parent: e,
+      viewName: t.name,
+      emitter: new ee(),
+      stores: /* @__PURE__ */ new Map()
+    }, this._logger = e.root.createLogger(t.name || "🌇 anonymous view", { uid: this.uniqueId }), this._view = t, this._props = s, this._childMarkup = i, this._emitter.on("error", (o, c, ...a) => {
+      console.error([o, c, ...a]), this._logger.error(o.message, { error: o, type: c, args: a }), this._logger.crash(o);
+    }), this._elementContext.emitter.on("*", (o, c, ...a) => {
+      var p;
+      c instanceof fe && (c.isStopped || (p = this._elementContext.parent) == null || p.emitter.emit(o, c, ...a));
+    });
+  }
+  /*===============================*\
+  ||         "Public" API          ||
+  \*===============================*/
+  get node() {
+    var e;
+    return (e = this._element) == null ? void 0 : e.node;
+  }
+  mount(e, t) {
+    const s = this.isMounted;
+    s || (this._initialize(), this._emitter.emit("beforeMount")), this._element && this._element.mount(e, t), s || (this.isMounted = !0, requestAnimationFrame(() => {
+      this._emitter.emit("mounted");
+    }));
+  }
+  unmount(e = !1) {
+    this._emitter.emit("beforeUnmount"), this._element && this._element.unmount(e), this.isMounted = !1, this._emitter.emit("unmounted"), this._emitter.clear();
+    for (const t of this._unsubscribes)
+      t();
+    this._unsubscribes.length = 0;
+  }
+  setChildView(e) {
+    this._childMarkup = [];
+    const t = new le(this._elementContext, e, {});
+    return this._children.value = [t], t;
+  }
+  /*===============================*\
+  ||           Internal            ||
+  \*===============================*/
+  _initialize() {
+    const e = new wt(this);
+    let t;
+    try {
+      t = this._view.call(e, this._props, e), this._childMarkup.length && (this._children.value = O(this._elementContext, this._childMarkup));
+    } catch (s) {
+      throw s instanceof Error && this._logger.crash(s), s;
+    }
+    if (t !== null) if (t instanceof Node)
+      this._element = F(O(this._elementContext, E("$node", { value: t })));
+    else if (w(t))
+      this._element = F(
+        O(this._elementContext, E("$dynamic", { source: t }))
+      );
+    else if (W(t) || De(W, t))
+      this._element = F(O(this._elementContext, t));
+    else {
+      const s = new TypeError(
+        `Expected '${this._view.name}' function to return a DOM node, Markup element, Readable or null. Got: ${q(t)}`
+      );
+      this._logger.crash(s);
+    }
+  }
+};
+let H = le;
+var Ce;
+Ce = k;
+class bt {
+  constructor({ elementContext: e, items: t, renderFn: s, keyFn: i }) {
+    l(this, Ce, !0);
+    l(this, "node", 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 = t, this.renderFn = s, this.keyFn = i;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(e, t) {
+    this.isMounted || (e.insertBefore(this.node, (t == null ? void 0 : t.nextSibling) ?? null), this.unsubscribe = b(() => {
+      let s = S(this.items);
+      s == null && (s = [], console.log("list received empty value", s, this)), this._update(Array.from(s));
+    }));
+  }
+  unmount(e = !1) {
+    var t;
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = null), !e && this.isMounted && ((t = this.node.parentNode) == null || t.removeChild(this.node)), this._cleanup(e);
+  }
+  _cleanup(e) {
+    for (const t of this.connectedItems)
+      t.element.unmount(e);
+    this.connectedItems = [];
+  }
+  _update(e) {
+    var c, a, p;
+    if (e.length === 0 || !this.isMounted)
+      return this._cleanup(!1);
+    const t = [];
+    let s = 0;
+    for (const r of e)
+      t.push({
+        key: this.keyFn(r, s),
+        value: r,
+        index: s++
+      });
+    const i = [];
+    for (const r of this.connectedItems)
+      t.find((f) => f.key === r.key) || r.element.unmount(!1);
+    for (const r of t) {
+      const u = this.connectedItems.find((f) => f.key === r.key);
+      if (u)
+        u.item.value = r.value, u.index.value = r.index, i[r.index] = u;
+      else {
+        const f = Q(r.value), h = Q(r.index);
+        i[r.index] = {
+          key: r.key,
+          item: f,
+          index: h,
+          element: new H(this.elementContext, yt, {
+            item: oe(() => f.value),
+            index: h,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let r = 0; r < i.length; r++) {
+      const u = i[r], f = ((c = i[r - 1]) == null ? void 0 : c.element.node) ?? this.node;
+      u.element.mount(this.node.parentNode, f);
+    }
+    this.connectedItems = i;
+    const o = ((a = i.at(-1)) == null ? void 0 : a.element.node) ?? this.node;
+    (p = this.node.parentNode) == null || p.insertBefore(this.node, o.nextSibling);
+  }
+}
+function yt(n, e) {
+  return e.name = "@ListItem", n.renderFn.call(e, n.item, n.index, e);
+}
+var Te;
+Te = k;
+class $e {
+  constructor(e) {
+    l(this, Te, !0);
+    l(this, "node", document.createTextNode(""));
+    l(this, "isMounted", !1);
+    l(this, "source");
+    l(this, "elements", []);
+    l(this, "unsubscribe");
+    this.source = e;
+  }
+  mount(e, t) {
+    this.isMounted || (this.isMounted = !0, e.insertBefore(this.node, (t == null ? void 0 : t.nextSibling) ?? null), w(this.source) ? this.unsubscribe = b(() => {
+      this.update(S(this.source));
+    }) : 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 t of this.elements)
+      t.unmount(e);
+    this.elements = [];
+  }
+  update(e) {
+    var t, s;
+    if (this.cleanup(!1), e.length > 0) {
+      for (let i = 0; i < e.length; i++) {
+        const o = e[i], c = i > 0 ? this.elements[i - 1] : void 0;
+        o.mount(this.node.parentElement, c == null ? void 0 : c.node), this.elements.push(o);
+      }
+      (s = this.node.parentNode) == null || s.insertBefore(this.node, ((t = this.elements.at(-1)) == null ? void 0 : t.node) ?? null);
+    }
+  }
+}
+var Ne;
+Ne = k;
+class vt {
+  constructor(e) {
+    l(this, Ne, !0);
+    l(this, "config");
+    l(this, "element");
+    this.config = e;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(e, t) {
+    const { content: s, parent: i } = this.config;
+    qe(s) ? this.element = s : this.element = F(O(this.config.elementContext, ce(s))), this.element.mount(i);
+  }
+  unmount(e = !1) {
+    var t;
+    (t = this.element) != null && t.isMounted && this.element.unmount(e);
+  }
+}
+function W(n) {
+  return (n == null ? void 0 : n[Le]) === !0;
+}
+function qe(n) {
+  return (n == null ? void 0 : n[k]) === !0;
+}
+function ce(n) {
+  return $(n) || (n = [n]), n.flat(1 / 0).filter((e) => e != null && e !== !1).map((e) => W(e) ? e : e instanceof Node ? E("$node", { value: e }) : w(e) ? E("$dynamic", { source: e }) : E("$text", { value: e }));
+}
+function E(n, e, ...t) {
+  return new xt(n, e, ...t);
+}
+var Ae;
+Ae = Le;
+class xt {
+  constructor(e, t, ...s) {
+    l(this, Ae, !0);
+    l(this, "type");
+    l(this, "props");
+    l(this, "children");
+    this.type = e, this.props = t, this.children = ce(s);
+  }
+}
+const Gt = ct.bind(E);
+function St(n, e, t) {
+  return E("$dynamic", {
+    source: oe(() => {
+      const s = S(n);
+      return s && e ? e : !s && t ? t : null;
+    })
+  });
+}
+function Mt(n, e, t) {
+  return E("$list", { items: oe(() => n), keyFn: e, renderFn: t });
+}
+function Et(n, e) {
+  return E("$portal", { parent: n, content: e });
+}
+function O(n, e) {
+  return ($(e) ? e : [e]).map((s) => {
+    if (A(s.type))
+      return new H(n, s.type, s.props, s.children);
+    if (P(s.type))
+      switch (s.type) {
+        case "$node": {
+          const i = s.props;
+          return new be(i.value);
+        }
+        case "$text": {
+          const i = s.props;
+          return new be(document.createTextNode(String(i.value)));
+        }
+        case "$list": {
+          const i = s.props;
+          return new bt({
+            items: i.items,
+            keyFn: i.keyFn,
+            renderFn: i.renderFn,
+            elementContext: n
+          });
+        }
+        case "$dynamic": {
+          const i = s.props;
+          return new lt({
+            source: i.source,
+            elementContext: n
+          });
+        }
+        case "$outlet": {
+          const i = s.props;
+          return new $e(i.children);
+        }
+        case "$portal": {
+          const i = s.props;
+          return new vt({
+            content: i.content,
+            parent: i.parent,
+            elementContext: n
+          });
+        }
+        default:
+          if (s.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${s.type}`);
+          return new dt({
+            tag: s.type,
+            props: s.props ?? {},
+            children: s.children,
+            elementContext: n
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${s.type}`);
+  });
+}
+function F(n) {
+  return n.length === 1 ? n[0] : new $e(n);
+}
+function Re(n) {
+  return n == null || n === !1 || P(n) || Fe(n) || W(n) || w(n) || De(Re, n);
+}
+export {
+  kt as A,
+  Pt as B,
+  Et as C,
+  Mt as D,
+  qt as I,
+  Vt as P,
+  gt as S,
+  H as V,
+  Nt as a,
+  Tt as b,
+  Rt as c,
+  Q as d,
+  oe as e,
+  Dt as f,
+  S as g,
+  P as h,
+  A as i,
+  te as j,
+  It as k,
+  Gt as l,
+  St as m,
+  $t as n,
+  B as o,
+  ee as p,
+  At as q,
+  E as r,
+  Lt as s,
+  q as t,
+  Ot as u,
+  jt as v,
+  F as w,
+  O as x,
+  b as y,
+  tt as z
+};
+//# sourceMappingURL=markup-BWJWLvDF.js.map