@manyducks.co/dolla 2.0.0-alpha.26 → 2.0.0-alpha.28

package/dist/passthrough-1MySicTa.js

@@ -0,0 +1,1476 @@
+var Ut = Object.defineProperty;
+var ot = (n) => {
+  throw TypeError(n);
+};
+var Lt = (n, t, e) => t in n ? Ut(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var o = (n, t, e) => Lt(n, typeof t != "symbol" ? t + "" : t, e), ut = (n, t, e) => t.has(n) || ot("Cannot " + e);
+var O = (n, t, e) => (ut(n, t, "read from private field"), e ? e.call(n) : t.get(n)), F = (n, t, e) => t.has(n) ? ot("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), P = (n, t, e, r) => (ut(n, t, "write to private field"), r ? r.call(n, e) : t.set(n, e), e);
+function kt(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var T = { exports: {} }, ct;
+function Rt() {
+  return ct || (ct = 1, function(n, 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 (g) {
+          p = !0, _ = g;
+        } 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");
+      };
+    }(), r = 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(g, C, S) {
+        var D = Math.round, w = 0 > S ? S + 1 : 1 < S ? S - 1 : S;
+        return w = w < 1 / 6 ? g + 6 * (C - g) * w : w < 1 / 2 ? C : w < 2 / 3 ? g + 6 * (C - g) * (2 / 3 - w) : g, D(255 * w);
+      }, _ = 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(g, C, S) {
+        return g * (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, g = y === void 0 ? u : y, C = h.scheme, S = C === void 0 ? "hex" : C, D = i(g(a), l, p, x), w = e(D, 3), nt = w[0], rt = w[1], st = w[2], it = s(nt / 360, rt, st), jt = r(it);
+      return S === "hsl" ? [nt, rt, st] : S === "rgb" ? it : jt;
+    };
+    t.default = c, n.exports = t.default;
+  }(T, T.exports)), T.exports;
+}
+var Dt = Rt();
+const zt = /* @__PURE__ */ kt(Dt);
+function N(n) {
+  const t = typeof n;
+  switch (t) {
+    case "undefined":
+      return t;
+    case "number":
+      return isNaN(n) ? "NaN" : t;
+    case "function":
+      return /^\s*class\s+/.test(n.toString()) ? "class" : t;
+    case "object":
+      return n === null ? "null" : n instanceof Promise ? "promise" : n instanceof Map ? "map" : n instanceof Set ? "set" : Array.isArray(n) ? "array" : t;
+    default:
+      return t;
+  }
+}
+function xe(n, t) {
+  if (!n)
+    throw new TypeError(
+      R(n, t || "Failed assertion. Value is not truthy. Got type: %t, value: %v")
+    );
+}
+function A(n) {
+  return Array.isArray(n);
+}
+function Mt(...n) {
+  const t = n[0], e = (r) => A(r) && r.every((s) => t(s));
+  return n.length < 2 ? e : e(n[1]);
+}
+function ke(...n) {
+  const t = n[0], e = b(n[2]) ? n[2] : "Expected an array of valid items. Got type: %t, value: %v", r = (s) => {
+    if (A(s) && s.every((i) => t(i)))
+      return !0;
+    throw new TypeError(R(s, e));
+  };
+  return n.length < 2 ? r : r(n[1]);
+}
+function b(n) {
+  return typeof n == "string";
+}
+function Me(n, t) {
+  if (b(n))
+    return !0;
+  throw new TypeError(R(n, t ?? "Expected a string. Got type: %t, value: %v"));
+}
+function I(n) {
+  return typeof n == "function" && !Kt(n);
+}
+function Gt(n) {
+  return typeof n == "number" && !isNaN(n);
+}
+function Kt(n) {
+  return typeof n == "function" && /^\s*class\s+/.test(n.toString());
+}
+function be(...n) {
+  const t = n[0], e = b(n[2]) ? n[2] : `Expected instance of ${t.name}. Got type: %t, value: %v`, r = (s) => {
+    if (s instanceof t)
+      return !0;
+    throw new TypeError(R(s, e));
+  };
+  return n.length < 2 ? r : r(n[1]);
+}
+function bt(n) {
+  return n != null && typeof n == "object" && !A(n);
+}
+function R(n, t) {
+  var s;
+  const e = N(n), r = ((s = n == null ? void 0 : n.toString) == null ? void 0 : s.call(n)) || String(n);
+  return t.replaceAll("%t", e).replaceAll("%v", r);
+}
+var z, at;
+function Bt() {
+  return at || (at = 1, z = function n(t, e) {
+    if (t === e) return !0;
+    if (t && e && typeof t == "object" && typeof e == "object") {
+      if (t.constructor !== e.constructor) return !1;
+      var r, s, i;
+      if (Array.isArray(t)) {
+        if (r = t.length, r != e.length) return !1;
+        for (s = r; s-- !== 0; )
+          if (!n(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 (!n(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 (r = t.length, r != e.length) return !1;
+        for (s = r; 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), r = i.length, r !== Object.keys(e).length) return !1;
+      for (s = r; s-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(e, i[s])) return !1;
+      for (s = r; s-- !== 0; ) {
+        var u = i[s];
+        if (!n(t[u], e[u])) return !1;
+      }
+      return !0;
+    }
+    return t !== t && e !== e;
+  }), z;
+}
+var Ht = Bt();
+const Yt = /* @__PURE__ */ kt(Ht), Zt = () => {
+};
+let G = 1;
+function Y() {
+  return G = G % Number.MAX_SAFE_INTEGER + 1, G.toString(36) + Date.now().toString(36);
+}
+function Et(n, t) {
+  return Object.is(n, t);
+}
+function Ee(n, t) {
+  if (Object.is(n, t)) return !0;
+  const e = N(n);
+  if (e !== N(t))
+    return !1;
+  switch (e) {
+    case "object":
+      let r = 0;
+      for (const s in n) {
+        if (n[s] !== t[s]) return !1;
+        r++;
+      }
+      return Object.keys(t).length === r;
+    case "array":
+      if (n.length !== t.length) return !1;
+      for (let s = 0; s < n.length; s++)
+        if (n[s] !== t[s]) return !1;
+      return !0;
+    case "map":
+      if (n.size !== t.size) return !1;
+      for (const s of n.keys())
+        if (n[s] !== t[s]) return !1;
+      return !0;
+    case "set":
+      if (I(n.symmetricDifference))
+        return n.symmetricDifference(t).size === 0;
+      for (const s of n.keys())
+        if (n[s] !== t.get(s)) return !1;
+      return !0;
+  }
+  return !1;
+}
+const Ae = Yt;
+function Jt(n, t) {
+  const e = (r) => {
+    const s = {};
+    for (const i in r)
+      n.includes(i) || (s[i] = r[i]);
+    return s;
+  };
+  return t == null ? e : e(t);
+}
+function Oe(n) {
+  return zt({
+    str: n,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function Ne(n) {
+  if (n instanceof RegExp)
+    return (r) => n.test(r);
+  const t = {
+    positive: [],
+    negative: []
+  }, e = n.split(",").map((r) => r.trim()).filter((r) => r !== "");
+  for (let r of e) {
+    let s = "positive";
+    r.startsWith("-") && (s = "negative", r = r.slice(1)), r === "*" ? t[s].push(function() {
+      return !0;
+    }) : r.endsWith("*") ? t[s].push(function(i) {
+      return i.startsWith(r.slice(0, r.length - 1));
+    }) : t[s].push(function(i) {
+      return i === r;
+    });
+  }
+  return function(r) {
+    const { positive: s, negative: i } = t;
+    return !(i.some((u) => u(r)) || s.length > 0 && !s.some((u) => u(r)));
+  };
+}
+var Xt = Object.defineProperty, Qt = (n, t, e) => t in n ? Xt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, ht = (n, t, e) => Qt(n, typeof t != "symbol" ? t + "" : t, e);
+class j {
+  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 r = this.listeners(t);
+    for (const s of r)
+      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) || r.length > 0;
+  }
+  on(t, e) {
+    return this.listeners(t).push(e), this;
+  }
+  off(t, e) {
+    const r = this.listeners(t);
+    return r.splice(r.indexOf(e), 1), this;
+  }
+  once(t, e) {
+    return this.on(t, (...r) => {
+      e(...r), 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 V, E;
+class Ve {
+  constructor(t) {
+    // #dolla;
+    F(this, V);
+    F(this, E);
+    P(this, V, t.createLogger("Dolla.stats")), P(this, E, W());
+    let e;
+    O(this, E).emitter.on("statsChanged", () => {
+      e && clearTimeout(e), e = setTimeout(() => {
+        O(this, V).info(O(this, E).stats);
+      }, 200);
+    });
+  }
+}
+V = new WeakMap(), E = new WeakMap();
+const K = Symbol.for("DollaStatsStore");
+function lt() {
+  const n = new j(), t = {
+    watcherCount: 0,
+    viewCount: 0
+  };
+  return n.on("_incrementViewCount", (e) => {
+    t.viewCount += e, n.emit("statsChanged");
+  }), n.on("_incrementWatcherCount", (e) => {
+    t.watcherCount += e, n.emit("statsChanged");
+  }), { emitter: n, stats: t };
+}
+function W() {
+  return typeof window < "u" ? (window[K] || (window[K] = lt()), window[K]) : lt();
+}
+function At() {
+  W().emitter.emit("_incrementWatcherCount", 1);
+}
+function Ot() {
+  W().emitter.emit("_incrementWatcherCount", -1);
+}
+function te() {
+  W().emitter.emit("_incrementViewCount", 1);
+}
+function ee() {
+  W().emitter.emit("_incrementViewCount", -1);
+}
+const Nt = Symbol.for("DollaState"), Vt = Symbol.for("DollaRef"), $t = Symbol.for("DollaMarkup"), k = Symbol.for("DollaMarkupElement"), ne = Symbol.for("DollaStore"), Wt = Symbol.for("DollaStoreFactory");
+function m(n) {
+  return (n == null ? void 0 : n[Nt]) === !0;
+}
+function re(n) {
+  return m(n) ? n.get() : n;
+}
+function Z(n) {
+  return m(n) ? n : new J({
+    get() {
+      return n;
+    },
+    watch(t, e = {}) {
+      return e != null && e.lazy || t(n), 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 r = this.watchers.indexOf(t);
+      r > -1 && this.watchers.splice(r, 1), Ot();
+    };
+  }
+}
+var mt;
+mt = Nt;
+class J {
+  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 H(n, t) {
+  const e = new se(n, t);
+  return [new J(e), (s) => e.set(s)];
+}
+const ft = Symbol("EMPTY");
+class ie {
+  constructor(t, e, r) {
+    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", X());
+    /**
+     * 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(Z), this.fn = e, r != null && r.equals && (this.equals = r.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 r = this.watchers;
+    return r.push(t), e != null && e.lazy || t(this.rawValue), At(), () => {
+      r.splice(r.indexOf(t), 1), this.isWatchingSources && r.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 r = !1, s;
+    for (let i = 0; i < t.length; i++)
+      s = t[i].get(), !r && !this.equals(s, e[i]) && (r = !0), e[i] = s;
+    r && 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 r = 0; r < this.sources.length; r++)
+      this.sourceWatcher.watch([this.sources[r]], (s) => {
+        if (t[r] = 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(n, t, e) {
+  const r = new ie(n, t, e);
+  return new J(r);
+}
+function X() {
+  const n = [];
+  return {
+    watch(t, e) {
+      if (t.length === 0)
+        throw new TypeError("Expected at least one state to watch.");
+      t = t.map(Z);
+      let r;
+      return t.length > 1 ? r = oe(t, e).watch(() => null) : r = t[0].watch(e), n.push(r), () => {
+        let s = n.indexOf(r);
+        s > -1 && n.splice(s, 1), r();
+      };
+    },
+    stopAll() {
+      for (; n.length > 0; )
+        n.pop()();
+    }
+  };
+}
+function $e(n) {
+  function t() {
+    if (arguments.length === 1)
+      n = arguments[0];
+    else if (arguments.length > 1)
+      throw new Error(`Too many arguments. Expected 0 or 1. Got: ${arguments.length}`);
+    return n;
+  }
+  return t[Vt] = !0, t;
+}
+function ue(n) {
+  return (n == null ? void 0 : n[Vt]) === !0;
+}
+var $;
+class Q {
+  constructor(t, e) {
+    o(this, "type");
+    o(this, "detail");
+    F(this, $, !1);
+    this.type = t, this.detail = e;
+  }
+  get propagationStopped() {
+    return O(this, $);
+  }
+  stopPropagation() {
+    P(this, $, !0);
+  }
+  get [Symbol.toStringTag]() {
+    return "ContextEvent";
+  }
+  // stopImmediatePropagation() {}
+}
+$ = new WeakMap();
+let ce = class {
+  constructor(t) {
+    o(this, "__store");
+    this.__store = t;
+    const e = Object.getOwnPropertyDescriptors(this.__store._logger);
+    for (const r in e)
+      r !== "setName" && Object.defineProperty(this, r, e[r]);
+  }
+  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, e) {
+    this.__store._elementContext.emitter.on(t, e);
+  }
+  off(t, e) {
+    this.__store._elementContext.emitter.off(t, e);
+  }
+  once(t, e) {
+    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);
+  }
+};
+class ae {
+  constructor(t, e, r) {
+    o(this, "key");
+    o(this, "_fn");
+    o(this, "_options");
+    /**
+     * Value is guaranteed to be set after `attach` is called.
+     */
+    o(this, "value");
+    o(this, "_elementContext");
+    o(this, "_emitter", new j());
+    o(this, "_logger");
+    this.key = t, this._fn = e, this._options = r;
+  }
+  attach(t) {
+    this._elementContext = t, this._logger = t.root.createLogger(this._fn.name), this._emitter.on("error", (r, s, ...i) => {
+      console.log({ error: r, eventName: s, args: i }), this._logger.crash(r);
+    });
+    const e = new ce(this);
+    try {
+      this.value = this._fn.call(e, this._options, e);
+    } catch (r) {
+      this._logger.crash(r);
+    }
+    t.stores.set(this.key, this);
+  }
+  handleMount() {
+    this._emitter.emit("mounted");
+  }
+  handleUnmount() {
+    this._emitter.emit("unmounted"), this._emitter.clear();
+  }
+}
+function he(n) {
+  return (n == null ? void 0 : n[Wt]) === !0;
+}
+function le(n) {
+  return (n == null ? void 0 : n[ne]) === !0;
+}
+function Fe(n) {
+  const t = Y();
+  function e(r) {
+    return new ae(t, n, r);
+  }
+  return e[Wt] = !0, e.key = t, e;
+}
+class B extends Error {
+}
+function fe(n) {
+  for (var t, e, r = 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 ? r[l] : i) : s === 3 && (l || i) ? (c[1] = l ? r[l] : i, s = 2) : s === 2 && i === "..." && l ? c[2] = Object.assign(c[2] || {}, r[l]) : s === 2 && i && !l ? (c[2] = c[2] || {})[i] = !0 : s >= 5 && (s === 5 ? ((c[2] = c[2] || {})[e] = l ? i ? i + r[l] : r[l] : i, s = 6) : (l || i) && (c[2][e] += l ? i + r[l] : i)), i = "";
+  }, a = 0; a < n.length; a++) {
+    a && (s === 1 && h(), h(a));
+    for (var f = 0; f < n[a].length; f++) t = n[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 || n[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 = k;
+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 = (n) => /^on[A-Z]/.test(n);
+var gt;
+gt = k;
+class pe {
+  constructor({ tag: t, props: e, children: r, elementContext: s }) {
+    o(this, gt, !0);
+    o(this, "node");
+    o(this, "props");
+    o(this, "childMarkup", []);
+    o(this, "children", []);
+    o(this, "stopCallbacks", []);
+    o(this, "elementContext");
+    o(this, "uniqueId", Y());
+    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
+    }, r && (this.childMarkup = r), this.elementContext = s, this.children = M(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 r = 0; r < this.children.length; r++) {
+        const s = this.children[r], i = r > 0 ? this.children[r - 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 r of this.children)
+        r.unmount(!0);
+      t || (e = this.node.parentNode) == null || e.removeChild(this.node), this.ref && this.ref(void 0), this.canClickAway = !1;
+      for (const r of this.stopCallbacks)
+        r();
+      this.stopCallbacks = [];
+    }
+  }
+  getUpdateKey(t, e) {
+    return `${this.uniqueId}:${t}:${e}`;
+  }
+  _mutate(t, e) {
+    this.isMounted ? this._batchWrite(t, e) : t();
+  }
+  attachProp(t, e, r) {
+    m(t) ? this.stopCallbacks.push(
+      t.watch((s) => {
+        this._mutate(() => e(s), r);
+      })
+    ) : this._mutate(() => e(t), r);
+  }
+  applyProps(t, e) {
+    for (const r in e) {
+      const s = e[r];
+      if (r === "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 (r === "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 (r === "onClickOutside" || r === "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(r)) {
+        const i = r.slice(2).toLowerCase(), u = m(s) ? (c) => s.get()(c) : s;
+        t.addEventListener(i, u), this.stopCallbacks.push(() => {
+          t.removeEventListener(i, u);
+        });
+      } else if (r.includes("-"))
+        this.attachProp(
+          s,
+          (i) => {
+            i == null ? t.removeAttribute(r) : t.setAttribute(r, String(i));
+          },
+          this.getUpdateKey("attr", r)
+        );
+      else if (!me.includes(r))
+        if (this.elementContext.isSVG)
+          this.attachProp(
+            s,
+            (i) => {
+              i != null ? t.setAttribute(r, String(e[r])) : t.removeAttribute(r);
+            },
+            this.getUpdateKey("attr", r)
+          );
+        else
+          switch (r) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(
+                s,
+                (i) => {
+                  t[r] = String(i);
+                },
+                this.getUpdateKey("prop", r)
+              );
+              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 = r.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", r)
+              );
+              break;
+            default: {
+              this.attachProp(
+                s,
+                (i) => {
+                  t[r] = i;
+                },
+                this.getUpdateKey("prop", r)
+              );
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(t, e, r) {
+    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, r);
+          },
+          this.getUpdateKey("styles", "*")
+        );
+      });
+      r.push(u), s.push(u);
+    } else {
+      const i = Pt(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);
+            });
+          });
+          r.push(a), s.push(a);
+        } else c != null && t.style.setProperty(u, String(c));
+      }
+    }
+    return function() {
+      for (const u of s)
+        u(), r.splice(r.indexOf(u), 1);
+    };
+  }
+  applyClasses(t, e, r) {
+    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, r);
+          },
+          this.getUpdateKey("attr", "class")
+        );
+      });
+      r.push(u), s.push(u);
+    } else {
+      const i = Ft(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);
+            });
+          });
+          r.push(h), s.push(h);
+        } else c && t.classList.add(u);
+      }
+    }
+    return function() {
+      for (const u of s)
+        u(), r.splice(r.indexOf(u), 1);
+    };
+  }
+}
+function Ft(n) {
+  let t = {};
+  if (b(n)) {
+    const e = n.split(" ");
+    for (const r of e)
+      t[r] = !0;
+  } else bt(n) ? Object.assign(t, n) : Array.isArray(n) && Array.from(n).filter(Boolean).forEach((e) => {
+    Object.assign(t, Ft(e));
+  });
+  return delete t.undefined, t;
+}
+function Pt(n) {
+  let t = {};
+  if (b(n)) {
+    const e = n.split(";").filter((r) => r.trim() !== "");
+    for (const r of e) {
+      const [s, i] = r.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(n))
+    for (const e in n)
+      e.startsWith("--") ? t[e] = { value: n[e] } : t[pt(e)] = { value: n[e] };
+  else Array.isArray(n) && Array.from(n).filter((e) => e != null).forEach((e) => {
+    Object.assign(t, Pt(e));
+  });
+  return t;
+}
+function pt(n) {
+  return n.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, e) => (e ? "-" : "") + t.toLowerCase());
+}
+const me = ["ref", "children", "class", "style", "data"];
+var wt;
+wt = k;
+class _e {
+  constructor({ sources: t, renderFn: e, elementContext: r }) {
+    o(this, wt, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "children", []);
+    o(this, "renderFn");
+    o(this, "elementContext");
+    o(this, "watcher", X());
+    o(this, "sources");
+    this.sources = t, this.renderFn = e, this.elementContext = r;
+  }
+  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, (...r) => {
+      const s = this.renderFn(...r);
+      if (!It(s))
+        throw console.error(s, r), new TypeError(
+          `Observer received invalid value to render. Got type: ${N(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) => qt(h) ? h : M(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 r = this.node.parentNode, s = ((c = (u = this.children.at(-1)) == null ? void 0 : u.node) == null ? void 0 : c.nextSibling) ?? null;
+    r.insertBefore(this.node, s);
+  }
+}
+var yt;
+yt = k;
+class Tt {
+  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((r) => {
+      this.update(r);
+    }) : 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, r;
+    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);
+      }
+      (r = this.node.parentNode) == null || r.insertBefore(this.node, ((e = this.elements.at(-1)) == null ? void 0 : e.node) ?? null);
+    }
+  }
+}
+var St;
+St = k;
+class ge {
+  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: r, parent: s } = this.config;
+    qt(r) ? this.element = r : this.element = q(M(this.config.elementContext, tt(r))), this.element.mount(s);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.element) != null && e.isMounted && this.element.unmount(t);
+  }
+}
+function Pe(n) {
+  return n;
+}
+class we {
+  constructor(t) {
+    o(this, "__view");
+    this.__view = t;
+    const e = Object.getOwnPropertyDescriptors(this.__view._logger);
+    for (const r in e)
+      r !== "setName" && Object.defineProperty(this, r, e[r]);
+  }
+  get uid() {
+    return this.__view.uniqueId;
+  }
+  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, e) {
+    this.__view._elementContext.emitter.on(t, e);
+  }
+  off(t, e) {
+    this.__view._elementContext.emitter.off(t, e);
+  }
+  once(t, e) {
+    this.__view._elementContext.emitter.once(t, e);
+  }
+  emit(t, e) {
+    return this.__view._elementContext.emitter.emit(t, new Q(t, e));
+  }
+  attachStore(t) {
+    t.attach(this.__view._elementContext), this.__view._emitter.on("mounted", () => {
+      t.handleMount();
+    }), this.__view._emitter.on("unmounted", () => {
+      t.handleUnmount();
+    });
+  }
+  useStore(t) {
+    if (he(t)) {
+      const e = t.key;
+      let r = this.__view._elementContext, s;
+      for (; s = r.stores.get(e), s == null && r.parent != null; )
+        r = r.parent;
+      if (s == null)
+        throw new B("Store not found on this context.");
+      return s.value;
+    } else throw le(t) ? new B(
+      "Received a Store instance. Please pass the Store factory function to useStore without calling it."
+    ) : new B("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 r = this.__view;
+    if (r.isMounted)
+      return r._watcher.watch(t, e);
+    {
+      let s, i = !1;
+      return r._emitter.on("mounted", () => {
+        i || (s = r._watcher.watch(t, e));
+      }), () => {
+        s != null && (i = !0, s());
+      };
+    }
+  }
+  outlet() {
+    return v("$outlet", { $children: this.__view._$children });
+  }
+}
+var vt;
+vt = k;
+const et = class et {
+  constructor(t, e, r, s = []) {
+    o(this, vt, !0);
+    o(this, "uniqueId", Y());
+    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", X());
+    o(this, "_emitter", new j());
+    o(this, "isMounted", !1);
+    this._elementContext = {
+      ...t,
+      data: {},
+      parent: t,
+      viewName: e.name,
+      emitter: new j(),
+      stores: /* @__PURE__ */ new Map()
+    }, this._logger = t.root.createLogger(e.name, { uid: this.uniqueId }), this._view = e, this._props = r, this._childMarkup = s, [this._$children, this._setChildren] = H([]), 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 r = this.isMounted;
+    r || (this._initialize(), this._emitter.emit("beforeMount")), this._element && this._element.mount(t, e), r || (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 we(this);
+    let e;
+    try {
+      this._childMarkup.length && this._setChildren(M(this._elementContext, this._childMarkup)), e = this._view.call(t, this._props, t);
+    } catch (r) {
+      throw r instanceof Error && this._logger.crash(r), r;
+    }
+    if (e !== null) if (e instanceof Node)
+      this._element = q(M(this._elementContext, v("$node", { value: e })));
+    else if (L(e) || Mt(L, e))
+      this._element = q(M(this._elementContext, e));
+    else if (m(e))
+      this._element = q(
+        M(this._elementContext, v("$observer", { sources: [e], renderFn: (r) => r }))
+      );
+    else {
+      const r = new TypeError(
+        `Expected '${this._view.name}' function to return a DOM node, Markup element, Readable or null. Got: ${N(e)}`
+      );
+      this._logger.crash(r);
+    }
+  }
+};
+let U = et;
+var Ct;
+Ct = k;
+class ye {
+  constructor({ elementContext: t, $items: e, renderFn: r, 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 = r, 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((r) => {
+      this.isMounted ? this.elementContext.root.batch.write(() => {
+        this._update(Array.from(r));
+      }) : this._update(Array.from(r));
+    }));
+  }
+  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 r = 0;
+    for (const a of t)
+      e.push({
+        key: this.keyFn(a, r),
+        value: a,
+        index: r++
+      });
+    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] = H(a.value), [p, _] = H(a.index);
+        s[a.index] = {
+          key: a.key,
+          $value: l,
+          setValue: d,
+          $index: p,
+          setIndex: _,
+          element: new U(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: n, $index: t, renderFn: e }, r) {
+  return e(n, t, r);
+}
+function L(n) {
+  return (n == null ? void 0 : n[$t]) === !0;
+}
+function qt(n) {
+  return (n == null ? void 0 : n[k]) === !0;
+}
+function tt(n) {
+  return A(n) || (n = [n]), n.flat(1 / 0).filter((t) => t != null && t !== !1).map((t) => L(t) ? t : t instanceof Node ? v("$node", { value: t }) : m(t) ? v("$observer", {
+    sources: [t],
+    renderFn: (e) => e
+  }) : v("$text", { value: t }));
+}
+function v(n, t, ...e) {
+  return new ve(n, t, ...e);
+}
+var xt;
+xt = $t;
+class ve {
+  constructor(t, e, ...r) {
+    o(this, xt, !0);
+    o(this, "type");
+    o(this, "props");
+    o(this, "children");
+    this.type = t, this.props = e, this.children = tt(r);
+  }
+}
+const Te = fe.bind(v);
+function qe(n, t, e) {
+  return v("$observer", {
+    sources: [n],
+    renderFn: (r) => r && t ? t : !r && e ? e : null
+  });
+}
+function Ie(n, t, e) {
+  const r = Z(n);
+  return v("$repeat", { $items: r, keyFn: t, renderFn: e });
+}
+function je(n, t) {
+  return v("$portal", { parent: n, content: t });
+}
+function M(n, t) {
+  return (A(t) ? t : [t]).map((r) => {
+    if (I(r.type))
+      return new U(n, r.type, r.props, r.children);
+    if (b(r.type))
+      switch (r.type) {
+        case "$node": {
+          const s = r.props;
+          return new dt(s.value);
+        }
+        case "$text": {
+          const s = r.props;
+          return new dt(document.createTextNode(String(s.value)));
+        }
+        case "$repeat": {
+          const s = r.props;
+          return new ye({
+            $items: s.$items,
+            keyFn: s.keyFn,
+            renderFn: s.renderFn,
+            elementContext: n
+          });
+        }
+        case "$observer": {
+          const s = r.props;
+          return new _e({
+            sources: s.sources,
+            renderFn: s.renderFn,
+            elementContext: n
+          });
+        }
+        case "$outlet": {
+          const s = r.props;
+          return new Tt(s.$children);
+        }
+        case "$portal": {
+          const s = r.props;
+          return new ge({
+            content: s.content,
+            parent: s.parent,
+            elementContext: n
+          });
+        }
+        default:
+          if (r.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${r.type}`);
+          return new pe({
+            tag: r.type,
+            props: r.props ?? {},
+            children: r.children,
+            elementContext: n
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${r.type}`);
+  });
+}
+function q(n) {
+  return n.length === 1 ? n[0] : new Tt(n);
+}
+function It(n) {
+  return n == null || n === !1 || b(n) || Gt(n) || L(n) || m(n) || Mt(It, n);
+}
+function Ue(n, t) {
+  return t.outlet();
+}
+export {
+  Zt as A,
+  Oe as B,
+  Q as C,
+  q as D,
+  M as E,
+  Fe as F,
+  Et as G,
+  je as H,
+  Ie as I,
+  Pe as J,
+  Ue as P,
+  Ve as S,
+  U as V,
+  b as a,
+  Ae as b,
+  H as c,
+  oe as d,
+  I as e,
+  Me as f,
+  ke as g,
+  xe as h,
+  bt as i,
+  Te as j,
+  qe as k,
+  X as l,
+  Ne as m,
+  Z as n,
+  re as o,
+  j as p,
+  m as q,
+  $e as r,
+  Ee as s,
+  N as t,
+  ue as u,
+  he as v,
+  B as w,
+  le as x,
+  be as y,
+  v as z
+};
+//# sourceMappingURL=passthrough-1MySicTa.js.map