@manyducks.co/dolla 2.0.0-alpha.3 → 2.0.0-alpha.30

package/dist/passthrough-d2lcM0cd.js

@@ -0,0 +1,1563 @@
+var jt = Object.defineProperty;
+var ot = (r) => {
+  throw TypeError(r);
+};
+var Ut = (r, t, e) => t in r ? jt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var o = (r, t, e) => Ut(r, typeof t != "symbol" ? t + "" : t, e), ut = (r, t, e) => t.has(r) || ot("Cannot " + e);
+var O = (r, t, e) => (ut(r, t, "read from private field"), e ? e.call(r) : t.get(r)), W = (r, t, e) => t.has(r) ? ot("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(r) : t.set(r, e), F = (r, t, e, n) => (ut(r, t, "write to private field"), n ? n.call(r, e) : t.set(r, e), e);
+function Mt(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var P = { exports: {} }, ct;
+function Rt() {
+  return ct || (ct = 1, function(r, t) {
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    var e = /* @__PURE__ */ function() {
+      function h(a, f) {
+        var l = [], d = !0, p = !1, _ = void 0;
+        try {
+          for (var x, y = a[Symbol.iterator](); !(d = (x = y.next()).done) && (l.push(x.value), !(f && l.length === f)); d = !0) ;
+        } catch (w) {
+          p = !0, _ = w;
+        } finally {
+          try {
+            !d && y.return && y.return();
+          } finally {
+            if (p) throw _;
+          }
+        }
+        return l;
+      }
+      return function(a, f) {
+        if (Array.isArray(a)) return a;
+        if (Symbol.iterator in Object(a)) return h(a, f);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }(), n = function(h) {
+      return h.reduce(function(a, f) {
+        return 16 > f ? a + "0" + f.toString(16) : a + f.toString(16);
+      }, "#");
+    }, s = function(h, a, f) {
+      var l = 0.5 > f ? f * (1 + a) : f + a - f * a, d = 2 * f - l, p = function(w, C, S) {
+        var z = Math.round, g = 0 > S ? S + 1 : 1 < S ? S - 1 : S;
+        return g = g < 1 / 6 ? w + 6 * (C - w) * g : g < 1 / 2 ? C : g < 2 / 3 ? w + 6 * (C - w) * (2 / 3 - g) : w, z(255 * g);
+      }, _ = p(d, l, h + 1 / 3), x = p(d, l, h), y = p(d, l, h - 1 / 3);
+      return [_, x, y];
+    }, i = function(h, a, f, l) {
+      var d = h % 1007 / 1007, p = function(w, C, S) {
+        return w * (S - C) + C;
+      }, _ = p(d, a.min, a.max), x = p(d, f.min, f.max), y = p(d, l.max, l.min);
+      return [_, x, y];
+    }, u = function(h) {
+      return h.split("").reduce(function(a, f, l) {
+        return a * f.charCodeAt(0) * l + 1;
+      }, 1);
+    }, c = function(h) {
+      var a = h.str, f = h.hue, l = f === void 0 ? { min: 0, max: 360 } : f, d = h.sat, p = d === void 0 ? { min: 0.35, max: 0.65 } : d, _ = h.light, x = _ === void 0 ? { min: 0.3, max: 0.7 } : _, y = h.hashFunction, w = y === void 0 ? u : y, C = h.scheme, S = C === void 0 ? "hex" : C, z = i(w(a), l, p, x), g = e(z, 3), nt = g[0], rt = g[1], st = g[2], it = s(nt / 360, rt, st), qt = n(it);
+      return S === "hsl" ? [nt, rt, st] : S === "rgb" ? it : qt;
+    };
+    t.default = c, r.exports = t.default;
+  }(P, P.exports)), P.exports;
+}
+var Dt = Rt();
+const zt = /* @__PURE__ */ Mt(Dt);
+function V(r) {
+  const t = typeof r;
+  switch (t) {
+    case "undefined":
+      return t;
+    case "number":
+      return isNaN(r) ? "NaN" : t;
+    case "function":
+      return /^\s*class\s+/.test(r.toString()) ? "class" : t;
+    case "object":
+      return r === null ? "null" : r instanceof Promise ? "promise" : r instanceof Map ? "map" : r instanceof Set ? "set" : Array.isArray(r) ? "array" : t;
+    default:
+      return t;
+  }
+}
+function xe(r, t) {
+  if (!r)
+    throw new TypeError(
+      R(r, t || "Failed assertion. Value is not truthy. Got type: %t, value: %v")
+    );
+}
+function A(r) {
+  return Array.isArray(r);
+}
+function kt(...r) {
+  const t = r[0], e = (n) => A(n) && n.every((s) => t(s));
+  return r.length < 2 ? e : e(r[1]);
+}
+function Me(...r) {
+  const t = r[0], e = b(r[2]) ? r[2] : "Expected an array of valid items. Got type: %t, value: %v", n = (s) => {
+    if (A(s) && s.every((i) => t(i)))
+      return !0;
+    throw new TypeError(R(s, e));
+  };
+  return r.length < 2 ? n : n(r[1]);
+}
+function b(r) {
+  return typeof r == "string";
+}
+function ke(r, t) {
+  if (b(r))
+    return !0;
+  throw new TypeError(R(r, t ?? "Expected a string. Got type: %t, value: %v"));
+}
+function I(r) {
+  return typeof r == "function" && !Kt(r);
+}
+function Gt(r) {
+  return typeof r == "number" && !isNaN(r);
+}
+function Kt(r) {
+  return typeof r == "function" && /^\s*class\s+/.test(r.toString());
+}
+function be(...r) {
+  const t = r[0], e = b(r[2]) ? r[2] : `Expected instance of ${t.name}. Got type: %t, value: %v`, n = (s) => {
+    if (s instanceof t)
+      return !0;
+    throw new TypeError(R(s, e));
+  };
+  return r.length < 2 ? n : n(r[1]);
+}
+function bt(r) {
+  return r != null && typeof r == "object" && !A(r);
+}
+function R(r, t) {
+  var s;
+  const e = V(r), n = ((s = r == null ? void 0 : r.toString) == null ? void 0 : s.call(r)) || String(r);
+  return t.replaceAll("%t", e).replaceAll("%v", n);
+}
+var G, at;
+function Bt() {
+  return at || (at = 1, G = function r(t, e) {
+    if (t === e) return !0;
+    if (t && e && typeof t == "object" && typeof e == "object") {
+      if (t.constructor !== e.constructor) return !1;
+      var n, s, i;
+      if (Array.isArray(t)) {
+        if (n = t.length, n != e.length) return !1;
+        for (s = n; s-- !== 0; )
+          if (!r(t[s], e[s])) return !1;
+        return !0;
+      }
+      if (t instanceof Map && e instanceof Map) {
+        if (t.size !== e.size) return !1;
+        for (s of t.entries())
+          if (!e.has(s[0])) return !1;
+        for (s of t.entries())
+          if (!r(s[1], e.get(s[0]))) return !1;
+        return !0;
+      }
+      if (t instanceof Set && e instanceof Set) {
+        if (t.size !== e.size) return !1;
+        for (s of t.entries())
+          if (!e.has(s[0])) return !1;
+        return !0;
+      }
+      if (ArrayBuffer.isView(t) && ArrayBuffer.isView(e)) {
+        if (n = t.length, n != e.length) return !1;
+        for (s = n; s-- !== 0; )
+          if (t[s] !== e[s]) 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), n = i.length, n !== Object.keys(e).length) return !1;
+      for (s = n; s-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(e, i[s])) return !1;
+      for (s = n; s-- !== 0; ) {
+        var u = i[s];
+        if (!r(t[u], e[u])) return !1;
+      }
+      return !0;
+    }
+    return t !== t && e !== e;
+  }), G;
+}
+var Ht = Bt();
+const Yt = /* @__PURE__ */ Mt(Ht), Zt = () => {
+};
+let K = 1;
+function Z() {
+  return K = K % Number.MAX_SAFE_INTEGER + 1, K.toString(36) + Date.now().toString(36);
+}
+function Et(r, t) {
+  return Object.is(r, t);
+}
+function Ee(r, t) {
+  if (Object.is(r, t)) return !0;
+  const e = V(r);
+  if (e !== V(t))
+    return !1;
+  switch (e) {
+    case "object":
+      let n = 0;
+      for (const s in r) {
+        if (r[s] !== t[s]) return !1;
+        n++;
+      }
+      return Object.keys(t).length === n;
+    case "array":
+      if (r.length !== t.length) return !1;
+      for (let s = 0; s < r.length; s++)
+        if (r[s] !== t[s]) return !1;
+      return !0;
+    case "map":
+      if (r.size !== t.size) return !1;
+      for (const s of r.keys())
+        if (r[s] !== t[s]) return !1;
+      return !0;
+    case "set":
+      if (I(r.symmetricDifference))
+        return r.symmetricDifference(t).size === 0;
+      for (const s of r.keys())
+        if (r[s] !== t.get(s)) return !1;
+      return !0;
+  }
+  return !1;
+}
+const Ae = Yt;
+function Jt(r, t) {
+  const e = (n) => {
+    const s = {};
+    for (const i in n)
+      r.includes(i) || (s[i] = n[i]);
+    return s;
+  };
+  return t == null ? e : e(t);
+}
+function Oe(r) {
+  return zt({
+    str: r,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function Ve(r) {
+  if (r instanceof RegExp)
+    return (n) => r.test(n);
+  const t = {
+    positive: [],
+    negative: []
+  }, e = r.split(",").map((n) => n.trim()).filter((n) => n !== "");
+  for (let n of e) {
+    let s = "positive";
+    n.startsWith("-") && (s = "negative", n = n.slice(1)), n === "*" ? t[s].push(function() {
+      return !0;
+    }) : n.endsWith("*") ? t[s].push(function(i) {
+      return i.startsWith(n.slice(0, n.length - 1));
+    }) : t[s].push(function(i) {
+      return i === n;
+    });
+  }
+  return function(n) {
+    const { positive: s, negative: i } = t;
+    return !(i.some((u) => u(n)) || s.length > 0 && !s.some((u) => u(n)));
+  };
+}
+var Xt = Object.defineProperty, Qt = (r, t, e) => t in r ? Xt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, ht = (r, t, e) => Qt(r, typeof t != "symbol" ? t + "" : t, e);
+class q {
+  constructor() {
+    ht(this, "_l", /* @__PURE__ */ new Map()), ht(this, "_a", (t) => {
+      if (typeof t != "string" && !(t instanceof Symbol))
+        throw new TypeError("Emitter: eventName should be a string or symbol");
+    });
+  }
+  emit(t, ...e) {
+    let n = this.listeners(t);
+    for (const s of n)
+      try {
+        s(...e);
+      } catch (i) {
+        let u = this._l.get("error");
+        if (u != null && u.length)
+          for (const c of u)
+            c(i, t, s, ...e);
+        else throw i;
+      }
+    return t != "*" && this.emit("*", t, ...e) || n.length > 0;
+  }
+  on(t, e) {
+    return this.listeners(t).push(e), this;
+  }
+  off(t, e) {
+    const n = this.listeners(t);
+    return n.splice(n.indexOf(e), 1), this;
+  }
+  once(t, e) {
+    return this.on(t, (...n) => {
+      e(...n), this.off(t, e);
+    });
+  }
+  clear() {
+    this._l.clear();
+  }
+  listeners(t) {
+    return this._l.get(t) ?? (this._a(t), this._l.set(t, []).get(t));
+  }
+  events() {
+    return [...this._l.entries()].filter(([, t]) => t.length).map(([t]) => t);
+  }
+}
+var $, E;
+class $e {
+  constructor(t) {
+    // #dolla;
+    W(this, $);
+    W(this, E);
+    F(this, $, t.createLogger("Dolla.stats")), F(this, E, N());
+    let e;
+    O(this, E).emitter.on("statsChanged", () => {
+      e && clearTimeout(e), e = setTimeout(() => {
+        O(this, $).info(O(this, E).stats);
+      }, 200);
+    });
+  }
+}
+$ = new WeakMap(), E = new WeakMap();
+const B = Symbol.for("DollaStatsStore");
+function lt() {
+  const r = new q(), t = {
+    watcherCount: 0,
+    viewCount: 0
+  };
+  return r.on("_incrementViewCount", (e) => {
+    t.viewCount += e, r.emit("statsChanged");
+  }), r.on("_incrementWatcherCount", (e) => {
+    t.watcherCount += e, r.emit("statsChanged");
+  }), { emitter: r, stats: t };
+}
+function N() {
+  return typeof window < "u" ? (window[B] || (window[B] = lt()), window[B]) : lt();
+}
+function At() {
+  N().emitter.emit("_incrementWatcherCount", 1);
+}
+function Ot() {
+  N().emitter.emit("_incrementWatcherCount", -1);
+}
+function te() {
+  N().emitter.emit("_incrementViewCount", 1);
+}
+function ee() {
+  N().emitter.emit("_incrementViewCount", -1);
+}
+const Vt = Symbol.for("DollaState"), $t = Symbol.for("DollaRef"), Lt = Symbol.for("DollaMarkup"), M = Symbol.for("DollaMarkupElement"), ne = Symbol.for("DollaStore"), Nt = Symbol.for("DollaStoreFactory");
+function m(r) {
+  return (r == null ? void 0 : r[Vt]) === !0;
+}
+function re(r) {
+  return m(r) ? r.get() : r;
+}
+function J(r) {
+  return m(r) ? r : new X({
+    get() {
+      return r;
+    },
+    watch(t, e = {}) {
+      return e != null && e.lazy || t(r), Zt;
+    }
+  });
+}
+class se {
+  constructor(t, e) {
+    o(this, "value");
+    o(this, "watchers", []);
+    o(this, "equals", Et);
+    this.value = t, e != null && e.equals && (this.equals = e.equals);
+  }
+  get() {
+    return this.value;
+  }
+  set(t) {
+    if (typeof t == "function" && (t = t(this.value)), !this.equals(t, this.value)) {
+      this.value = t;
+      try {
+        for (const e of this.watchers)
+          e(t);
+      } catch (e) {
+        throw console.error("Error in watcher", e), e;
+      }
+    }
+  }
+  watch(t, e) {
+    return this.watchers.push(t), e != null && e.lazy || t(this.value), At(), () => {
+      const n = this.watchers.indexOf(t);
+      n > -1 && this.watchers.splice(n, 1), Ot();
+    };
+  }
+}
+var mt;
+mt = Vt;
+class X {
+  constructor(t) {
+    o(this, mt, !0);
+    o(this, "__value");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  watch(t, e) {
+    return this.__value.watch(t, e);
+  }
+}
+function Y(r, t) {
+  const e = new se(r, t);
+  return [new X(e), (s) => e.set(s)];
+}
+const ft = Symbol("EMPTY");
+class ie {
+  constructor(t, e, n) {
+    o(this, "equals", Et);
+    /**
+     * Array of states this holder's value is derived from.
+     */
+    o(this, "sources", []);
+    /**
+     * The function that does the deriving. Receives source values and returns a derived value.
+     */
+    o(this, "fn");
+    /**
+     *
+     */
+    o(this, "sourceWatcher", D());
+    /**
+     * Array of functions awaiting notification when this holder's value changes.
+     */
+    o(this, "watchers", []);
+    /**
+     * True when this holder is actively watching sources.
+     */
+    o(this, "isWatchingSources", !1);
+    /**
+     * Latest values as received from sources.
+     */
+    o(this, "previousSourceValues");
+    /**
+     * The current value as returned from `fn` (may be a State)
+     */
+    o(this, "value", ft);
+    /**
+     * The current unwrapped value.
+     */
+    o(this, "rawValue");
+    /**
+     * When value is a State, this function will stop watching its value.
+     */
+    o(this, "stopWatchingCurrentValue");
+    this.sources = t.map(J), this.fn = e, n != null && n.equals && (this.equals = n.equals), this.previousSourceValues = new Array(t.length).fill(ft, 0, t.length);
+  }
+  /*==========================*\
+  ||     "Public" methods     ||
+  \*==========================*/
+  get() {
+    return this.getValue();
+  }
+  watch(t, e) {
+    this.isWatchingSources || this.startWatchingSources();
+    const n = this.watchers;
+    return n.push(t), e != null && e.lazy || t(this.rawValue), At(), () => {
+      n.splice(n.indexOf(t), 1), this.isWatchingSources && n.length === 0 && this.stopWatchingSources(), Ot();
+    };
+  }
+  /*==========================*\
+  ||         Internal         ||
+  \*==========================*/
+  notify(t) {
+    for (const e of this.watchers)
+      e(t);
+  }
+  update() {
+    const t = this.sources, e = this.previousSourceValues;
+    let n = !1, s;
+    for (let i = 0; i < t.length; i++)
+      s = t[i].get(), !n && !this.equals(s, e[i]) && (n = !0), e[i] = s;
+    n && this.setValue(this.fn(...e));
+  }
+  getValue() {
+    return this.isWatchingSources || this.update(), this.rawValue;
+  }
+  setValue(t) {
+    this.stopWatchingCurrentValue && (this.stopWatchingCurrentValue(), this.stopWatchingCurrentValue = void 0), this.value = t, this.rawValue = re(t), this.isWatchingSources && m(t) ? this.stopWatchingCurrentValue = t.watch((e) => {
+      this.rawValue = e, this.notify(e);
+    }) : this.notify(this.rawValue);
+  }
+  startWatchingSources() {
+    const t = this.previousSourceValues;
+    for (let n = 0; n < this.sources.length; n++)
+      this.sourceWatcher.watch([this.sources[n]], (s) => {
+        if (t[n] = s, this.isWatchingSources) {
+          const i = this.fn(...t);
+          this.equals(i, this.value) || this.setValue(i);
+        }
+      });
+    this.isWatchingSources = !0;
+    const e = this.fn(...t);
+    this.equals(e, this.value) || this.setValue(e);
+  }
+  stopWatchingSources() {
+    this.sourceWatcher.stopAll(), this.stopWatchingCurrentValue && (this.stopWatchingCurrentValue(), this.stopWatchingCurrentValue = void 0), this.isWatchingSources = !1;
+  }
+}
+function oe(r, t, e) {
+  const n = new ie(r, t, e);
+  return new X(n);
+}
+function D() {
+  const r = [];
+  return {
+    watch(t, e) {
+      if (t.length === 0)
+        throw new TypeError("Expected at least one state to watch.");
+      t = t.map(J);
+      let n;
+      return t.length > 1 ? n = oe(t, e).watch(() => null) : n = t[0].watch(e), r.push(n), () => {
+        let s = r.indexOf(n);
+        s > -1 && r.splice(s, 1), n();
+      };
+    },
+    stopAll() {
+      for (; r.length > 0; )
+        r.pop()();
+    }
+  };
+}
+function Le(r) {
+  function t() {
+    if (arguments.length === 1)
+      r = arguments[0];
+    else if (arguments.length > 1)
+      throw new Error(`Too many arguments. Expected 0 or 1. Got: ${arguments.length}`);
+    return r;
+  }
+  return t[$t] = !0, t;
+}
+function ue(r) {
+  return (r == null ? void 0 : r[$t]) === !0;
+}
+var L;
+class Q {
+  constructor(t, e) {
+    o(this, "type");
+    o(this, "detail");
+    W(this, L, !1);
+    this.type = t, this.detail = e;
+  }
+  get propagationStopped() {
+    return O(this, L);
+  }
+  stopPropagation() {
+    F(this, L, !0);
+  }
+  get [Symbol.toStringTag]() {
+    return "ContextEvent";
+  }
+  // stopImmediatePropagation() {}
+}
+L = new WeakMap();
+let ce = class {
+  constructor(t) {
+    o(this, "__store");
+    this.__store = t;
+    const e = Object.getOwnPropertyDescriptors(this.__store._logger);
+    for (const n in e)
+      n !== "setName" && Object.defineProperty(this, n, e[n]);
+  }
+  get isMounted() {
+    return this.__store.isMounted;
+  }
+  setName(t) {
+    return this.__store._logger.setName(t), this;
+  }
+  set(t, e) {
+    return this.__store._elementContext.data[t] = e, e;
+  }
+  get(t) {
+    let e = this.__store._elementContext;
+    for (; ; ) {
+      if (t in e.data)
+        return e.data[t];
+      if (e.parent)
+        e = e.parent;
+      else
+        break;
+    }
+    return null;
+  }
+  // on<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__store._elementContext.emitter.on(eventName, listener);
+  // }
+  // off<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__store._elementContext.emitter.off(eventName, listener);
+  // }
+  // once<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__store._elementContext.emitter.once(eventName, listener);
+  // }
+  on(t, e) {
+    if (t === "*") {
+      const n = (s, i) => {
+        e(i);
+      };
+      this.__store._elementContext.emitter.on(t, n), this.__store._wildcardListeners.set(e, n);
+    } else
+      this.__store._elementContext.emitter.on(t, e);
+  }
+  off(t, e) {
+    if (t === "*") {
+      const n = this.__store._wildcardListeners.get(e);
+      n && (this.__store._elementContext.emitter.off(t, n), this.__store._wildcardListeners.delete(e));
+    } else
+      this.__store._elementContext.emitter.off(t, e);
+  }
+  once(t, e) {
+    if (t === "*") {
+      const n = (s, i) => {
+        this.__store._wildcardListeners.delete(e), e(i);
+      };
+      this.__store._elementContext.emitter.once(t, n), this.__store._wildcardListeners.set(e, n);
+    } else
+      this.__store._elementContext.emitter.once(t, e);
+  }
+  emit(t, e) {
+    return this.__store._elementContext.emitter.emit(t, new Q(t, e));
+  }
+  onMount(t) {
+    this.__store._emitter.on("mounted", t);
+  }
+  onUnmount(t) {
+    this.__store._emitter.on("unmounted", t);
+  }
+  watch(t, e) {
+    const n = this.__store;
+    if (n.isMounted)
+      return n._watcher.watch(t, e);
+    {
+      let s, i = !1;
+      return n._emitter.on("mounted", () => {
+        i || (s = n._watcher.watch(t, e));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+};
+class ae {
+  constructor(t, e, n) {
+    o(this, "key");
+    o(this, "_fn");
+    o(this, "_options");
+    /**
+     * Value is guaranteed to be set after `attach` is called.
+     */
+    o(this, "value");
+    o(this, "isMounted", !1);
+    o(this, "_elementContext");
+    o(this, "_emitter", new q());
+    o(this, "_wildcardListeners", /* @__PURE__ */ new Map());
+    o(this, "_logger");
+    o(this, "_watcher", D());
+    this.key = t, this._fn = e, this._options = n;
+  }
+  get name() {
+    return this._fn.name;
+  }
+  /**
+   * Attaches this Store to the elementContext.
+   * Returns false if there was already an instance attached, and true otherwise.
+   */
+  attach(t) {
+    if (t.stores.has(this.key))
+      return !1;
+    this._elementContext = t, this._logger = t.root.createLogger(this._fn.name), this._emitter.on("error", (n, s, ...i) => {
+      console.log({ error: n, eventName: s, args: i }), this._logger.crash(n);
+    });
+    const e = new ce(this);
+    try {
+      this.value = this._fn.call(e, this._options, e);
+    } catch (n) {
+      this._logger.crash(n);
+    }
+    return t.stores.set(this.key, this), !0;
+  }
+  handleMount() {
+    this.isMounted = !0, this._emitter.emit("mounted");
+  }
+  handleUnmount() {
+    this.isMounted = !1, this._emitter.emit("unmounted"), this._emitter.clear(), this._watcher.stopAll();
+  }
+}
+function he(r) {
+  return (r == null ? void 0 : r[Nt]) === !0;
+}
+function le(r) {
+  return (r == null ? void 0 : r[ne]) === !0;
+}
+function We(r) {
+  const t = Z();
+  function e(n) {
+    return new ae(t, r, n);
+  }
+  return e[Nt] = !0, e.key = t, e;
+}
+class H extends Error {
+}
+function fe(r) {
+  for (var t, e, n = arguments, s = 1, i = "", u = "", c = [0], h = function(l) {
+    s === 1 && (l || (i = i.replace(/^\s*\n\s*|\s*\n\s*$/g, ""))) ? c.push(l ? n[l] : i) : s === 3 && (l || i) ? (c[1] = l ? n[l] : i, s = 2) : s === 2 && i === "..." && l ? c[2] = Object.assign(c[2] || {}, n[l]) : s === 2 && i && !l ? (c[2] = c[2] || {})[i] = !0 : s >= 5 && (s === 5 ? ((c[2] = c[2] || {})[e] = l ? i ? i + n[l] : n[l] : i, s = 6) : (l || i) && (c[2][e] += l ? i + n[l] : i)), i = "";
+  }, a = 0; a < r.length; a++) {
+    a && (s === 1 && h(), h(a));
+    for (var f = 0; f < r[a].length; f++) t = r[a][f], s === 1 ? t === "<" ? (h(), c = [c, "", null], s = 3) : i += t : s === 4 ? i === "--" && t === ">" ? (s = 1, i = "") : i = t + i[0] : u ? t === u ? u = "" : i += t : t === '"' || t === "'" ? u = t : t === ">" ? (h(), s = 1) : s && (t === "=" ? (s = 5, e = i, i = "") : t === "/" && (s < 5 || r[a][f + 1] === ">") ? (h(), s === 3 && (c = c[0]), s = c, (c = c[0]).push(this.apply(null, s.slice(1))), s = 0) : t === " " || t === "	" || t === `
+` || t === "\r" ? (h(), s = 2) : i += t), s === 3 && i === "!--" && (s = 4, c = c[0]);
+  }
+  return h(), c.length > 2 ? c.slice(1) : c[1];
+}
+var _t;
+_t = M;
+class dt {
+  constructor(t) {
+    o(this, _t, !0);
+    o(this, "node");
+    this.node = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null);
+  }
+  unmount(t = !1) {
+    this.node.parentNode && !t && this.node.parentNode.removeChild(this.node);
+  }
+}
+const de = (r) => /^on[A-Z]/.test(r);
+var wt;
+wt = M;
+class pe {
+  constructor({ tag: t, props: e, children: n, elementContext: s }) {
+    o(this, wt, !0);
+    o(this, "node");
+    o(this, "props");
+    o(this, "childMarkup", []);
+    o(this, "children", []);
+    o(this, "stopCallbacks", []);
+    o(this, "elementContext");
+    o(this, "uniqueId", Z());
+    o(this, "_batchWrite");
+    // Track the ref so we can nullify it on unmount.
+    o(this, "ref");
+    // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+    o(this, "canClickAway", !1);
+    if (s = { ...s }, this._batchWrite = s.root.batch.write.bind(s.root.batch), t.toLowerCase() === "svg" && (s.isSVG = !0), s.isSVG ? this.node = document.createElementNS("http://www.w3.org/2000/svg", t) : this.node = document.createElement(t), e.ref)
+      if (ue(e.ref))
+        this.ref = e.ref, this.ref(this.node);
+      else
+        throw new Error("Expected ref to be a function. Got: " + e.ref);
+    this.props = {
+      ...Jt(["ref", "class", "className"], e),
+      class: e.className ?? e.class
+    }, n && (this.childMarkup = n), this.elementContext = s, this.children = k(this.elementContext, this.childMarkup);
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    if (t == null)
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${t}`);
+    if (!this.isMounted) {
+      for (let n = 0; n < this.children.length; n++) {
+        const s = this.children[n], i = n > 0 ? this.children[n - 1].node : void 0;
+        s.mount(this.node, i);
+      }
+      this.applyProps(this.node, this.props), this.props.style && this.applyStyles(this.node, this.props.style, this.stopCallbacks), this.props.class && this.applyClasses(this.node, this.props.class, this.stopCallbacks);
+    }
+    t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), setTimeout(() => {
+      this.canClickAway = !0;
+    }, 0);
+  }
+  unmount(t = !1) {
+    var e;
+    if (this.isMounted) {
+      for (const n of this.children)
+        n.unmount(!0);
+      t || (e = this.node.parentNode) == null || e.removeChild(this.node), this.ref && this.ref(void 0), this.canClickAway = !1;
+      for (const n of this.stopCallbacks)
+        n();
+      this.stopCallbacks = [];
+    }
+  }
+  getUpdateKey(t, e) {
+    return `${this.uniqueId}:${t}:${e}`;
+  }
+  _mutate(t, e) {
+    this.isMounted ? this._batchWrite(t, e) : t();
+  }
+  attachProp(t, e, n) {
+    m(t) ? this.stopCallbacks.push(
+      t.watch((s) => {
+        this._mutate(() => e(s), n);
+      })
+    ) : this._mutate(() => e(t), n);
+  }
+  applyProps(t, e) {
+    for (const n in e) {
+      const s = e[n];
+      if (n === "attributes") {
+        const i = s;
+        for (const u in i)
+          this.attachProp(
+            i[u],
+            (c) => {
+              c == null ? t.removeAttribute(u) : t.setAttribute(u, String(c));
+            },
+            this.getUpdateKey("attr", u)
+          );
+      } else if (n === "eventListeners") {
+        const i = s;
+        for (const u in i) {
+          const c = m(s) ? (h) => s.get()(h) : s;
+          t.addEventListener(u, c), this.stopCallbacks.push(() => {
+            t.removeEventListener(u, c);
+          });
+        }
+      } else if (n === "onClickOutside" || n === "onclickoutside") {
+        const i = (c) => {
+          this.canClickAway && !t.contains(c.target) && (m(s) ? s.get()(c) : s(c));
+        }, u = { capture: !0 };
+        window.addEventListener("click", i, u), this.stopCallbacks.push(() => {
+          window.removeEventListener("click", i, u);
+        });
+      } else if (de(n)) {
+        const i = n.slice(2).toLowerCase(), u = m(s) ? (c) => s.get()(c) : s;
+        t.addEventListener(i, u), this.stopCallbacks.push(() => {
+          t.removeEventListener(i, u);
+        });
+      } else if (n.includes("-"))
+        this.attachProp(
+          s,
+          (i) => {
+            i == null ? t.removeAttribute(n) : t.setAttribute(n, String(i));
+          },
+          this.getUpdateKey("attr", n)
+        );
+      else if (!me.includes(n))
+        if (this.elementContext.isSVG)
+          this.attachProp(
+            s,
+            (i) => {
+              i != null ? t.setAttribute(n, String(e[n])) : t.removeAttribute(n);
+            },
+            this.getUpdateKey("attr", n)
+          );
+        else
+          switch (n) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(
+                s,
+                (i) => {
+                  t[n] = String(i);
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            case "for":
+              this.attachProp(
+                s,
+                (i) => {
+                  t.htmlFor = i;
+                },
+                this.getUpdateKey("prop", "htmlFor")
+              );
+              break;
+            case "checked":
+              this.attachProp(
+                s,
+                (i) => {
+                  t.checked = i, i ? t.setAttribute("checked", "") : t.removeAttribute("checked");
+                },
+                this.getUpdateKey("prop", "checked")
+              );
+              break;
+            // Attribute-aliased props
+            case "exportParts":
+            case "part":
+            case "translate":
+            case "type":
+            case "title": {
+              const i = n.toLowerCase();
+              this.attachProp(
+                s,
+                (u) => {
+                  u == null ? t.removeAttribute(i) : t.setAttribute(i, String(u));
+                },
+                this.getUpdateKey("attr", i)
+              );
+              break;
+            }
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(
+                s,
+                (i) => {
+                  typeof i == "string" ? t.autocomplete = i : i ? t.autocomplete = "on" : t.autocomplete = "off";
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            default: {
+              this.attachProp(
+                s,
+                (i) => {
+                  t[n] = i;
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(t, e, n) {
+    const s = [];
+    if (m(e)) {
+      let i;
+      const u = e.watch((c) => {
+        this._mutate(
+          () => {
+            I(i) && i(), t.style.cssText = "", i = this.applyStyles(t, c, n);
+          },
+          this.getUpdateKey("styles", "*")
+        );
+      });
+      n.push(u), s.push(u);
+    } else {
+      const i = Ft(e);
+      for (const u in i) {
+        const { value: c, priority: h } = i[u];
+        if (m(c)) {
+          const a = c.watch((f) => {
+            this._mutate(() => {
+              f ? t.style.setProperty(u, String(f), h) : t.style.removeProperty(u);
+            });
+          });
+          n.push(a), s.push(a);
+        } else c != null && t.style.setProperty(u, String(c));
+      }
+    }
+    return function() {
+      for (const u of s)
+        u(), n.splice(n.indexOf(u), 1);
+    };
+  }
+  applyClasses(t, e, n) {
+    const s = [];
+    if (m(e)) {
+      let i;
+      const u = e.watch((c) => {
+        this._mutate(
+          () => {
+            I(i) && i(), t.removeAttribute("class"), i = this.applyClasses(t, c, n);
+          },
+          this.getUpdateKey("attr", "class")
+        );
+      });
+      n.push(u), s.push(u);
+    } else {
+      const i = Wt(e);
+      for (const u in i) {
+        const c = i[u];
+        if (m(c)) {
+          const h = c.watch((a) => {
+            this._mutate(() => {
+              a ? t.classList.add(u) : t.classList.remove(u);
+            });
+          });
+          n.push(h), s.push(h);
+        } else c && t.classList.add(u);
+      }
+    }
+    return function() {
+      for (const u of s)
+        u(), n.splice(n.indexOf(u), 1);
+    };
+  }
+}
+function Wt(r) {
+  let t = {};
+  if (b(r)) {
+    const e = r.split(" ");
+    for (const n of e)
+      t[n] = !0;
+  } else bt(r) ? Object.assign(t, r) : Array.isArray(r) && Array.from(r).filter(Boolean).forEach((e) => {
+    Object.assign(t, Wt(e));
+  });
+  return delete t.undefined, t;
+}
+function Ft(r) {
+  let t = {};
+  if (b(r)) {
+    const e = r.split(";").filter((n) => n.trim() !== "");
+    for (const n of e) {
+      const [s, i] = n.split(":"), u = {
+        value: i
+      };
+      i.includes("!important") ? (u.priority = "important", u.value = i.replace("!important", "").trim()) : u.value = i.trim(), t[pt(s.trim())] = u;
+    }
+  }
+  if (bt(r))
+    for (const e in r)
+      e.startsWith("--") ? t[e] = { value: r[e] } : t[pt(e)] = { value: r[e] };
+  else Array.isArray(r) && Array.from(r).filter((e) => e != null).forEach((e) => {
+    Object.assign(t, Ft(e));
+  });
+  return t;
+}
+function pt(r) {
+  return r.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, e) => (e ? "-" : "") + t.toLowerCase());
+}
+const me = ["ref", "children", "class", "style", "data"];
+var gt;
+gt = M;
+class _e {
+  constructor({ sources: t, renderFn: e, elementContext: n }) {
+    o(this, gt, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "children", []);
+    o(this, "renderFn");
+    o(this, "elementContext");
+    o(this, "watcher", D());
+    o(this, "sources");
+    this.sources = t, this.renderFn = e, this.elementContext = n;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    this.isMounted || (t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), this.watcher.watch(this.sources, (...n) => {
+      const s = this.renderFn(...n);
+      if (!It(s))
+        throw console.error(s, n), new TypeError(
+          `Observer received invalid value to render. Got type: ${V(s)}, value: ${s}`
+        );
+      this.update(A(s) ? s : [s]);
+    }));
+  }
+  unmount(t = !1) {
+    var e;
+    this.watcher.stopAll(), this.isMounted && (this.cleanup(t), (e = this.node.parentNode) == null || e.removeChild(this.node));
+  }
+  cleanup(t) {
+    for (const e of this.children)
+      e.unmount(t);
+    this.children = [];
+  }
+  update(t) {
+    var i, u, c;
+    if (this.cleanup(!1), t == null || t.length === 0 || !this.isMounted)
+      return;
+    const e = t.flatMap((h) => Tt(h) ? h : k(this.elementContext, tt(h)));
+    for (const h of e) {
+      const a = ((i = this.children.at(-1)) == null ? void 0 : i.node) || this.node;
+      h.mount(this.node.parentNode, a), this.children.push(h);
+    }
+    const n = this.node.parentNode, s = ((c = (u = this.children.at(-1)) == null ? void 0 : u.node) == null ? void 0 : c.nextSibling) ?? null;
+    n.insertBefore(this.node, s);
+  }
+}
+var yt;
+yt = M;
+class Pt {
+  constructor(t) {
+    o(this, yt, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "isMounted", !1);
+    o(this, "source");
+    o(this, "elements", []);
+    o(this, "stopCallback");
+    this.source = t;
+  }
+  mount(t, e) {
+    this.isMounted || (this.isMounted = !0, t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), m(this.source) ? this.stopCallback = this.source.watch((n) => {
+      this.update(n);
+    }) : this.update(this.elements));
+  }
+  unmount(t = !1) {
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), this.isMounted && (this.cleanup(t), this.isMounted = !1);
+  }
+  cleanup(t) {
+    for (const e of this.elements)
+      e.unmount(t);
+    this.elements = [];
+  }
+  update(t) {
+    var e, n;
+    if (this.cleanup(!1), t.length > 0) {
+      for (let s = 0; s < t.length; s++) {
+        const i = t[s], u = s > 0 ? this.elements[s - 1] : void 0;
+        i.mount(this.node.parentElement, u == null ? void 0 : u.node), this.elements.push(i);
+      }
+      (n = this.node.parentNode) == null || n.insertBefore(this.node, ((e = this.elements.at(-1)) == null ? void 0 : e.node) ?? null);
+    }
+  }
+}
+var St;
+St = M;
+class we {
+  constructor(t) {
+    o(this, St, !0);
+    o(this, "config");
+    o(this, "element");
+    this.config = t;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(t, e) {
+    const { content: n, parent: s } = this.config;
+    Tt(n) ? this.element = n : this.element = T(k(this.config.elementContext, tt(n))), this.element.mount(s);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.element) != null && e.isMounted && this.element.unmount(t);
+  }
+}
+function Fe(r) {
+  return r;
+}
+class ge {
+  constructor(t) {
+    o(this, "__view");
+    this.__view = t;
+    const e = Object.getOwnPropertyDescriptors(this.__view._logger);
+    for (const n in e)
+      n !== "setName" && Object.defineProperty(this, n, e[n]);
+  }
+  get uid() {
+    return this.__view.uniqueId;
+  }
+  get isMounted() {
+    return this.__view.isMounted;
+  }
+  setName(t) {
+    return this.__view._logger.setName(t), this.__view._elementContext.viewName = t, this;
+  }
+  set(t, e) {
+    return this.__view._elementContext.data[t] = e, e;
+  }
+  get(t) {
+    let e = this.__view._elementContext;
+    for (; ; ) {
+      if (t in e.data)
+        return e.data[t];
+      if (e.parent)
+        e = e.parent;
+      else
+        break;
+    }
+    return null;
+  }
+  // on<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__view._elementContext.emitter.on(eventName, listener);
+  // }
+  // off<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__view._elementContext.emitter.off(eventName, listener);
+  // }
+  // once<T = unknown>(eventName: string, listener: (...args: any) => void): void {
+  //   this.__view._elementContext.emitter.once(eventName, listener);
+  // }
+  on(t, e) {
+    if (t === "*") {
+      const n = (s, i) => {
+        e(i);
+      };
+      this.__view._elementContext.emitter.on(t, n), this.__view._wildcardListeners.set(e, n);
+    } else
+      this.__view._elementContext.emitter.on(t, e);
+  }
+  off(t, e) {
+    if (t === "*") {
+      const n = this.__view._wildcardListeners.get(e);
+      n && (this.__view._elementContext.emitter.off(t, n), this.__view._wildcardListeners.delete(e));
+    } else
+      this.__view._elementContext.emitter.off(t, e);
+  }
+  once(t, e) {
+    if (t === "*") {
+      const n = (s, i) => {
+        this.__view._wildcardListeners.delete(e), e(i);
+      };
+      this.__view._elementContext.emitter.once(t, n), this.__view._wildcardListeners.set(e, n);
+    } else
+      this.__view._elementContext.emitter.once(t, e);
+  }
+  emit(t, e) {
+    return this.__view._elementContext.emitter.emit(t, new Q(t, e));
+  }
+  attachStore(t) {
+    if (t.attach(this.__view._elementContext))
+      this.__view._emitter.on("mounted", () => {
+        t.handleMount();
+      }), this.__view._emitter.on("unmounted", () => {
+        t.handleUnmount();
+      });
+    else {
+      let n = t.name ? `'${t.name}'` : "this store";
+      this.__view._logger.warn(`An instance of ${n} was already attached to this context.`);
+    }
+  }
+  useStore(t) {
+    if (he(t)) {
+      const e = t.key;
+      let n = this.__view._elementContext, s;
+      for (; s = n.stores.get(e), s == null && n.parent != null; )
+        n = n.parent;
+      if (s == null)
+        throw new H("Store not found on this context.");
+      return s.value;
+    } else throw le(t) ? new H(
+      "Received a Store instance. Please pass the Store factory function to useStore without calling it."
+    ) : new H("Invalid store.");
+  }
+  beforeMount(t) {
+    this.__view._emitter.on("beforeMount", t);
+  }
+  onMount(t) {
+    this.__view._emitter.on("mounted", t);
+  }
+  beforeUnmount(t) {
+    this.__view._emitter.on("beforeUnmount", t);
+  }
+  onUnmount(t) {
+    this.__view._emitter.on("unmounted", t);
+  }
+  watch(t, e) {
+    const n = this.__view;
+    if (n.isMounted)
+      return n._watcher.watch(t, e);
+    {
+      let s, i = !1;
+      return n._emitter.on("mounted", () => {
+        i || (s = n._watcher.watch(t, e));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+  outlet() {
+    return v("$outlet", { $children: this.__view._$children });
+  }
+}
+var vt;
+vt = M;
+const et = class et {
+  constructor(t, e, n, s = []) {
+    o(this, vt, !0);
+    o(this, "uniqueId", Z());
+    o(this, "_elementContext");
+    o(this, "_logger");
+    o(this, "_view");
+    o(this, "_props");
+    o(this, "_element");
+    o(this, "_childMarkup");
+    o(this, "_$children");
+    o(this, "_setChildren");
+    o(this, "_watcher", D());
+    o(this, "_emitter", new q());
+    o(this, "_wildcardListeners", /* @__PURE__ */ new Map());
+    o(this, "isMounted", !1);
+    this._elementContext = {
+      ...t,
+      data: {},
+      parent: t,
+      viewName: e.name,
+      emitter: new q(),
+      stores: /* @__PURE__ */ new Map()
+    }, this._logger = t.root.createLogger(e.name || "🌇 anonymous view", { uid: this.uniqueId }), this._view = e, this._props = n, this._childMarkup = s, [this._$children, this._setChildren] = Y([]), this._emitter.on("error", (i, u, ...c) => {
+      this._logger.error({ error: i, eventName: u, args: c }), this._logger.crash(i);
+    }), this._elementContext.emitter.on("*", (i, u) => {
+      var c;
+      u instanceof Q && (u.propagationStopped || (c = this._elementContext.parent) == null || c.emitter.emit(i, u));
+    });
+  }
+  /*===============================*\
+  ||         "Public" API          ||
+  \*===============================*/
+  get node() {
+    var t;
+    return (t = this._element) == null ? void 0 : t.node;
+  }
+  mount(t, e) {
+    const n = this.isMounted;
+    n || (this._initialize(), this._emitter.emit("beforeMount")), this._element && this._element.mount(t, e), n || (this.isMounted = !0, te(), requestAnimationFrame(() => {
+      this._emitter.emit("mounted");
+    }));
+  }
+  unmount(t = !1) {
+    this._emitter.emit("beforeUnmount"), this._element && this._element.unmount(t), this.isMounted && ee(), this.isMounted = !1, this._emitter.emit("unmounted"), this._emitter.clear(), this._watcher.stopAll();
+  }
+  setChildView(t) {
+    this._childMarkup = [];
+    const e = new et(this._elementContext, t, {});
+    return this._setChildren([e]), e;
+  }
+  /*===============================*\
+  ||           Internal            ||
+  \*===============================*/
+  _initialize() {
+    const t = new ge(this);
+    let e;
+    try {
+      e = this._view.call(t, this._props, t), this._childMarkup.length && this._setChildren(k(this._elementContext, this._childMarkup));
+    } catch (n) {
+      throw n instanceof Error && this._logger.crash(n), n;
+    }
+    if (e !== null) if (e instanceof Node)
+      this._element = T(k(this._elementContext, v("$node", { value: e })));
+    else if (U(e) || kt(U, e))
+      this._element = T(k(this._elementContext, e));
+    else if (m(e))
+      this._element = T(
+        k(this._elementContext, v("$observer", { sources: [e], renderFn: (n) => n }))
+      );
+    else {
+      const n = new TypeError(
+        `Expected '${this._view.name}' function to return a DOM node, Markup element, Readable or null. Got: ${V(e)}`
+      );
+      this._logger.crash(n);
+    }
+  }
+};
+let j = et;
+var Ct;
+Ct = M;
+class ye {
+  constructor({ elementContext: t, $items: e, renderFn: n, keyFn: s }) {
+    o(this, Ct, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "$items");
+    o(this, "stopCallback");
+    o(this, "connectedItems", []);
+    o(this, "elementContext");
+    o(this, "renderFn");
+    o(this, "keyFn");
+    this.elementContext = t, this.$items = e, this.renderFn = n, this.keyFn = s;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    this.isMounted || (t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), this.stopCallback = this.$items.watch((n) => {
+      this.isMounted ? this.elementContext.root.batch.write(() => {
+        this._update(Array.from(n));
+      }) : this._update(Array.from(n));
+    }));
+  }
+  unmount(t = !1) {
+    var e;
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), !t && this.isMounted && ((e = this.node.parentNode) == null || e.removeChild(this.node)), this._cleanup(t);
+  }
+  _cleanup(t) {
+    for (const e of this.connectedItems)
+      e.element.unmount(t);
+    this.connectedItems = [];
+  }
+  _update(t) {
+    var u, c, h;
+    if (t.length === 0 || !this.isMounted)
+      return this._cleanup(!1);
+    const e = [];
+    let n = 0;
+    for (const a of t)
+      e.push({
+        key: this.keyFn(a, n),
+        value: a,
+        index: n++
+      });
+    const s = [];
+    for (const a of this.connectedItems)
+      e.find((l) => l.key === a.key) || a.element.unmount(!1);
+    for (const a of e) {
+      const f = this.connectedItems.find((l) => l.key === a.key);
+      if (f)
+        f.setValue(a.value), f.setIndex(a.index), s[a.index] = f;
+      else {
+        const [l, d] = Y(a.value), [p, _] = Y(a.index);
+        s[a.index] = {
+          key: a.key,
+          $value: l,
+          setValue: d,
+          $index: p,
+          setIndex: _,
+          element: new j(this.elementContext, Se, {
+            $value: l,
+            $index: p,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let a = 0; a < s.length; a++) {
+      const f = s[a], l = ((u = s[a - 1]) == null ? void 0 : u.element.node) ?? this.node;
+      f.element.mount(this.node.parentNode, l);
+    }
+    this.connectedItems = s;
+    const i = ((c = s.at(-1)) == null ? void 0 : c.element.node) ?? this.node;
+    (h = this.node.parentNode) == null || h.insertBefore(this.node, i.nextSibling);
+  }
+}
+function Se({ $value: r, $index: t, renderFn: e }, n) {
+  return n.setName("@RepeatItem"), e.call(n, r, t, n);
+}
+function U(r) {
+  return (r == null ? void 0 : r[Lt]) === !0;
+}
+function Tt(r) {
+  return (r == null ? void 0 : r[M]) === !0;
+}
+function tt(r) {
+  return A(r) || (r = [r]), r.flat(1 / 0).filter((t) => t != null && t !== !1).map((t) => U(t) ? t : t instanceof Node ? v("$node", { value: t }) : m(t) ? v("$observer", {
+    sources: [t],
+    renderFn: (e) => e
+  }) : v("$text", { value: t }));
+}
+function v(r, t, ...e) {
+  return new ve(r, t, ...e);
+}
+var xt;
+xt = Lt;
+class ve {
+  constructor(t, e, ...n) {
+    o(this, xt, !0);
+    o(this, "type");
+    o(this, "props");
+    o(this, "children");
+    this.type = t, this.props = e, this.children = tt(n);
+  }
+}
+const Pe = fe.bind(v);
+function Te(r, t, e) {
+  return v("$observer", {
+    sources: [r],
+    renderFn: (n) => n && t ? t : !n && e ? e : null
+  });
+}
+function Ie(r, t, e) {
+  const n = J(r);
+  return v("$repeat", { $items: n, keyFn: t, renderFn: e });
+}
+function qe(r, t) {
+  return v("$portal", { parent: r, content: t });
+}
+function k(r, t) {
+  return (A(t) ? t : [t]).map((n) => {
+    if (I(n.type))
+      return new j(r, n.type, n.props, n.children);
+    if (b(n.type))
+      switch (n.type) {
+        case "$node": {
+          const s = n.props;
+          return new dt(s.value);
+        }
+        case "$text": {
+          const s = n.props;
+          return new dt(document.createTextNode(String(s.value)));
+        }
+        case "$repeat": {
+          const s = n.props;
+          return new ye({
+            $items: s.$items,
+            keyFn: s.keyFn,
+            renderFn: s.renderFn,
+            elementContext: r
+          });
+        }
+        case "$observer": {
+          const s = n.props;
+          return new _e({
+            sources: s.sources,
+            renderFn: s.renderFn,
+            elementContext: r
+          });
+        }
+        case "$outlet": {
+          const s = n.props;
+          return new Pt(s.$children);
+        }
+        case "$portal": {
+          const s = n.props;
+          return new we({
+            content: s.content,
+            parent: s.parent,
+            elementContext: r
+          });
+        }
+        default:
+          if (n.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${n.type}`);
+          return new pe({
+            tag: n.type,
+            props: n.props ?? {},
+            children: n.children,
+            elementContext: r
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${n.type}`);
+  });
+}
+function T(r) {
+  return r.length === 1 ? r[0] : new Pt(r);
+}
+function It(r) {
+  return r == null || r === !1 || b(r) || Gt(r) || U(r) || m(r) || kt(It, r);
+}
+function je(r, t) {
+  return t.outlet();
+}
+export {
+  Zt as A,
+  Oe as B,
+  Q as C,
+  T as D,
+  k as E,
+  We as F,
+  Et as G,
+  qe as H,
+  Ie as I,
+  Fe as J,
+  je as P,
+  $e as S,
+  j as V,
+  b as a,
+  Ae as b,
+  Y as c,
+  oe as d,
+  I as e,
+  ke as f,
+  Me as g,
+  xe as h,
+  bt as i,
+  Pe as j,
+  Te as k,
+  D as l,
+  Ve as m,
+  J as n,
+  re as o,
+  q as p,
+  m as q,
+  Le as r,
+  Ee as s,
+  V as t,
+  ue as u,
+  he as v,
+  H as w,
+  le as x,
+  be as y,
+  v as z
+};
+//# sourceMappingURL=passthrough-d2lcM0cd.js.map