@manyducks.co/dolla 2.0.0-alpha.14 → 2.0.0-alpha.16

package/dist/passthrough-DUh0_zQF.js

@@ -0,0 +1,1398 @@
+var yt = Object.defineProperty;
+var wt = (e, t, n) => t in e ? yt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var u = (e, t, n) => wt(e, typeof t != "symbol" ? t + "" : t, n);
+function ot(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var P = { exports: {} }, J;
+function Ct() {
+  return J || (J = 1, function(e, t) {
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    var n = /* @__PURE__ */ function() {
+      function a(h, d) {
+        var f = [], y = !0, w = !1, S = void 0;
+        try {
+          for (var v, b = h[Symbol.iterator](); !(y = (v = b.next()).done) && (f.push(v.value), !(d && f.length === d)); y = !0) ;
+        } catch (m) {
+          w = !0, S = m;
+        } finally {
+          try {
+            !y && b.return && b.return();
+          } finally {
+            if (w) throw S;
+          }
+        }
+        return f;
+      }
+      return function(h, d) {
+        if (Array.isArray(h)) return h;
+        if (Symbol.iterator in Object(h)) return a(h, d);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }(), s = function(a) {
+      return a.reduce(function(h, d) {
+        return 16 > d ? h + "0" + d.toString(16) : h + d.toString(16);
+      }, "#");
+    }, r = function(a, h, d) {
+      var f = 0.5 > d ? d * (1 + h) : d + h - d * h, y = 2 * d - f, w = function(m, E, l) {
+        var p = Math.round, g = 0 > l ? l + 1 : 1 < l ? l - 1 : l;
+        return g = g < 1 / 6 ? m + 6 * (E - m) * g : g < 1 / 2 ? E : g < 2 / 3 ? m + 6 * (E - m) * (2 / 3 - g) : m, p(255 * g);
+      }, S = w(y, f, a + 1 / 3), v = w(y, f, a), b = w(y, f, a - 1 / 3);
+      return [S, v, b];
+    }, o = function(a, h, d, f) {
+      var y = a % 1007 / 1007, w = function(m, E, l) {
+        return m * (l - E) + E;
+      }, S = w(y, h.min, h.max), v = w(y, d.min, d.max), b = w(y, f.max, f.min);
+      return [S, v, b];
+    }, i = function(a) {
+      return a.split("").reduce(function(h, d, f) {
+        return h * d.charCodeAt(0) * f + 1;
+      }, 1);
+    }, c = function(a) {
+      var h = a.str, d = a.hue, f = d === void 0 ? { min: 0, max: 360 } : d, y = a.sat, w = y === void 0 ? { min: 0.35, max: 0.65 } : y, S = a.light, v = S === void 0 ? { min: 0.3, max: 0.7 } : S, b = a.hashFunction, m = b === void 0 ? i : b, E = a.scheme, l = E === void 0 ? "hex" : E, p = o(m(h), f, w, v), g = n(p, 3), N = g[0], z = g[1], Y = g[2], Z = r(N / 360, z, Y), gt = s(Z);
+      return l === "hsl" ? [N, z, Y] : l === "rgb" ? Z : gt;
+    };
+    t.default = c, e.exports = t.default;
+  }(P, P.exports)), P.exports;
+}
+var bt = Ct();
+const vt = /* @__PURE__ */ ot(bt);
+function R(e) {
+  if (e === void 0)
+    return "undefined";
+  if (e === null)
+    return "null";
+  const t = typeof e;
+  switch (t) {
+    case "number":
+      return isNaN(e) ? "NaN" : "number";
+    case "function":
+      return ut(e) ? "class" : t;
+    case "object":
+      return M(e) ? "array" : Et(e) ? "promise" : t;
+    default:
+      return t;
+  }
+}
+function M(e) {
+  return Array.isArray(e);
+}
+function it(...e) {
+  const t = e[0], n = (s) => M(s) && s.every((r) => t(r));
+  return e.length < 2 ? n : n(e[1]);
+}
+function Yt(...e) {
+  const t = e[0], n = A(e[2]) ? e[2] : "Expected an array of valid items. Got type: %t, value: %v", s = (r) => {
+    if (M(r) && r.every((o) => t(o)))
+      return !0;
+    throw new TypeError(G(r, n));
+  };
+  return e.length < 2 ? s : s(e[1]);
+}
+function A(e) {
+  return typeof e == "string";
+}
+function Zt(e, t) {
+  if (A(e))
+    return !0;
+  throw new TypeError(G(e, t ?? "Expected a string. Got type: %t, value: %v"));
+}
+function $(e) {
+  return typeof e == "function" && !ut(e);
+}
+function St(e) {
+  return typeof e == "number" && !isNaN(e);
+}
+function Et(e) {
+  if (e == null) return !1;
+  const t = e;
+  return t instanceof Promise || $(t.then) && $(t.catch) && $(t.finally);
+}
+function ut(e) {
+  return typeof e == "function" && /^\s*class\s+/.test(e.toString());
+}
+function Jt(...e) {
+  const t = e[0], n = A(e[2]) ? e[2] : `Expected instance of ${t.name}. Got type: %t, value: %v`, s = (r) => {
+    if (r instanceof t)
+      return !0;
+    throw new TypeError(G(r, n));
+  };
+  return e.length < 2 ? s : s(e[1]);
+}
+function L(e) {
+  return e != null && typeof e == "object" && !M(e);
+}
+function G(e, t) {
+  var r;
+  const n = R(e), s = ((r = e == null ? void 0 : e.toString) == null ? void 0 : r.call(e)) || String(e);
+  return t.replaceAll("%t", n).replaceAll("%v", s);
+}
+var I, Q;
+function kt() {
+  return Q || (Q = 1, I = function e(t, n) {
+    if (t === n) return !0;
+    if (t && n && typeof t == "object" && typeof n == "object") {
+      if (t.constructor !== n.constructor) return !1;
+      var s, r, o;
+      if (Array.isArray(t)) {
+        if (s = t.length, s != n.length) return !1;
+        for (r = s; r-- !== 0; )
+          if (!e(t[r], n[r])) return !1;
+        return !0;
+      }
+      if (t.constructor === RegExp) return t.source === n.source && t.flags === n.flags;
+      if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === n.valueOf();
+      if (t.toString !== Object.prototype.toString) return t.toString() === n.toString();
+      if (o = Object.keys(t), s = o.length, s !== Object.keys(n).length) return !1;
+      for (r = s; r-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(n, o[r])) return !1;
+      for (r = s; r-- !== 0; ) {
+        var i = o[r];
+        if (!e(t[i], n[i])) return !1;
+      }
+      return !0;
+    }
+    return t !== t && n !== n;
+  }), I;
+}
+var xt = kt();
+const Qt = /* @__PURE__ */ ot(xt), Nt = () => {
+};
+function $t(e, t) {
+  const n = (s) => {
+    const r = {};
+    for (const o in s)
+      e.includes(o) || (r[o] = s[o]);
+    return r;
+  };
+  return t == null ? n : n(t);
+}
+function Xt() {
+  if (typeof window < "u" && window.console)
+    return window.console;
+  if (typeof global < "u" && global.console)
+    return global.console;
+}
+function _t(e) {
+  return vt({
+    str: e,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function te(e) {
+  if (e instanceof RegExp)
+    return (s) => e.test(s);
+  const t = {
+    positive: [],
+    negative: []
+  }, n = e.split(",").map((s) => s.trim()).filter((s) => s !== "");
+  for (let s of n) {
+    let r = "positive";
+    s.startsWith("-") && (r = "negative", s = s.slice(1)), s === "*" ? t[r].push(function() {
+      return !0;
+    }) : s.endsWith("*") ? t[r].push(function(o) {
+      return o.startsWith(s.slice(0, s.length - 1));
+    }) : t[r].push(function(o) {
+      return o === s;
+    });
+  }
+  return function(s) {
+    const { positive: r, negative: o } = t;
+    return !(o.some((i) => i(s)) || r.length > 0 && !r.some((i) => i(s)));
+  };
+}
+const q = {
+  watcherCount: 0,
+  increment() {
+    this.watcherCount++, this._log();
+  },
+  decrement() {
+    this.watcherCount--, this._log();
+  },
+  _label: "dolla/state-tracker",
+  _timeout: null,
+  _log() {
+    window.DOLLA_DEV_DEBUG === !0 && !this._timeout && (this._timeout = setTimeout(() => {
+      console.log(
+        `%c[DOLLA_DEV_DEBUG] %c${this._label}%c%c%c`,
+        "color:#e44c4c;font-weight:bold",
+        `color:${_t(this._label)};font-weight:bold`,
+        "color:#777",
+        "color:#aaa",
+        "color:#777",
+        { watcherCount: this.watcherCount }
+      ), this._timeout = null;
+    }, 200));
+  }
+}, U = Symbol("State"), B = Symbol("SettableState"), ct = Symbol("Ref");
+function C(e) {
+  return (e == null ? void 0 : e[U]) === !0;
+}
+function D(e) {
+  return (e == null ? void 0 : e[B]) === !0;
+}
+function at(e) {
+  return (e == null ? void 0 : e[ct]) === !0;
+}
+function At(e) {
+  return C(e) ? e.get() : e;
+}
+function j(e) {
+  return D(e) ? new F(e) : C(e) ? e : new F({
+    get() {
+      return e;
+    },
+    watch(t, n = {}) {
+      return n != null && n.lazy || t(e), Nt;
+    }
+  });
+}
+class T {
+  constructor(t, n) {
+    u(this, "value");
+    u(this, "watchers", []);
+    u(this, "equals", T.defaultEquals);
+    this.value = t, n != null && n.equals && (this.equals = n.equals);
+  }
+  static defaultEquals(t, n) {
+    return t === n;
+  }
+  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 n of this.watchers)
+          n(t);
+      } catch (n) {
+        throw console.error("Error in watcher", n), n;
+      }
+    }
+  }
+  watch(t, n) {
+    return this.watchers.push(t), n != null && n.lazy || t(this.value), q.increment(), () => {
+      const s = this.watchers.indexOf(t);
+      s > -1 && this.watchers.splice(s, 1), q.decrement();
+    };
+  }
+}
+var et;
+et = U;
+class F {
+  constructor(t) {
+    // Instances will pass isState() with this symbol
+    u(this, et, !0);
+    u(this, "__value");
+    if (t == null)
+      throw new TypeError("Value is null");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  watch(t, n) {
+    return this.__value.watch(t, n);
+  }
+}
+function W(e, t) {
+  const n = new T(e, t);
+  return [new F(n), (r) => n.set(r)];
+}
+var nt, st;
+st = U, nt = B;
+class Vt {
+  constructor(t) {
+    // Instances will pass isState() and isSettableState() with these symbols
+    u(this, st, !0);
+    u(this, nt, !0);
+    u(this, "__value");
+    if (t == null)
+      throw new TypeError("Value is null");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  set(t) {
+    this.__value.set(t);
+  }
+  watch(t, n) {
+    return this.__value.watch(t, n);
+  }
+}
+function ee(e, t) {
+  return new Vt(new T(e, t));
+}
+function ne(e, t) {
+  return {
+    [U]: !0,
+    [B]: !0,
+    get: e.get.bind(e),
+    watch: e.watch.bind(e),
+    set: t
+  };
+}
+function se(e, t) {
+  return function(s) {
+    const r = e.get();
+    let o;
+    typeof s == "function" ? o = s(r) : o = s, t(o, r);
+  };
+}
+const X = Symbol("EMPTY");
+class Mt {
+  constructor(t, n, s) {
+    u(this, "equals", T.defaultEquals);
+    /**
+     * Array of states this holder's value is derived from.
+     */
+    u(this, "sources", []);
+    /**
+     * The function that does the deriving. Receives source values and returns a derived value.
+     */
+    u(this, "fn");
+    /**
+     *
+     */
+    u(this, "sourceWatcher", K());
+    /**
+     * Array of functions awaiting notification when this holder's value changes.
+     */
+    u(this, "watchers", []);
+    /**
+     * True when this holder is actively watching sources.
+     */
+    u(this, "isWatchingSources", !1);
+    /**
+     * Latest values as received from sources.
+     */
+    u(this, "previousSourceValues");
+    /**
+     * The current value as returned from `fn` (may be a State)
+     */
+    u(this, "value", X);
+    /**
+     * The current unwrapped value.
+     */
+    u(this, "rawValue");
+    /**
+     * When value is a State, this function will stop watching its value.
+     */
+    u(this, "stopWatchingCurrentValue");
+    this.sources = t.map(j), this.fn = n, s != null && s.equals && (this.equals = s.equals), this.previousSourceValues = new Array(t.length).fill(X, 0, t.length);
+  }
+  /*==========================*\
+  ||     "Public" methods     ||
+  \*==========================*/
+  get() {
+    return this.getValue();
+  }
+  watch(t, n) {
+    this.isWatchingSources || this.startWatchingSources();
+    const s = this.watchers;
+    return s.push(t), n != null && n.lazy || t(this.rawValue), q.increment(), () => {
+      s.splice(s.indexOf(t), 1), this.isWatchingSources && s.length === 0 && this.stopWatchingSources(), q.decrement();
+    };
+  }
+  /*==========================*\
+  ||         Internal         ||
+  \*==========================*/
+  notify(t) {
+    for (const n of this.watchers)
+      n(t);
+  }
+  update() {
+    const t = this.sources, n = this.previousSourceValues;
+    let s = !1, r;
+    for (let o = 0; o < t.length; o++)
+      r = t[o].get(), !s && !this.equals(r, n[o]) && (s = !0), n[o] = r;
+    s && this.setValue(this.fn(...n));
+  }
+  getValue() {
+    return this.isWatchingSources || this.update(), this.rawValue;
+  }
+  setValue(t) {
+    this.stopWatchingCurrentValue && (this.stopWatchingCurrentValue(), this.stopWatchingCurrentValue = void 0), this.value = t, this.rawValue = At(t), this.isWatchingSources && C(t) ? this.stopWatchingCurrentValue = t.watch((n) => {
+      this.rawValue = n, this.notify(n);
+    }) : this.notify(this.rawValue);
+  }
+  startWatchingSources() {
+    const t = this.previousSourceValues;
+    for (let s = 0; s < this.sources.length; s++)
+      this.sourceWatcher.watch([this.sources[s]], (r) => {
+        if (t[s] = r, this.isWatchingSources) {
+          const o = this.fn(...t);
+          this.equals(o, this.value) || this.setValue(o);
+        }
+      });
+    this.isWatchingSources = !0;
+    const n = this.fn(...t);
+    this.equals(n, this.value) || this.setValue(n);
+  }
+  stopWatchingSources() {
+    this.sourceWatcher.stopAll(), this.stopWatchingCurrentValue && (this.stopWatchingCurrentValue(), this.stopWatchingCurrentValue = void 0), this.isWatchingSources = !1;
+  }
+}
+function Tt(e, t, n) {
+  const s = new Mt(e, t, n);
+  return new F(s);
+}
+var rt;
+rt = ct;
+class Ot {
+  constructor(t) {
+    // Instances will pass isRef() with this symbol
+    u(this, rt, !0);
+    u(this, "__value");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  watch(t, n) {
+    return this.__value.watch(t, n);
+  }
+  get node() {
+    return this.__value.get();
+  }
+  set node(t) {
+    this.__value.set(t);
+  }
+}
+function re() {
+  return new Ot(new T(void 0));
+}
+function K() {
+  const e = [];
+  return {
+    watch(t, n) {
+      if (t.length === 0)
+        throw new TypeError("Expected at least one state to watch.");
+      t = t.map(j);
+      let s;
+      return t.length > 1 ? s = Tt(t, n).watch(() => null) : s = t[0].watch(n), e.push(s), () => {
+        let r = e.indexOf(s);
+        r > -1 && e.splice(r, 1), s();
+      };
+    },
+    stopAll() {
+      for (; e.length > 0; )
+        e.pop()();
+    }
+  };
+}
+function Pt(e) {
+  for (var t, n, s = arguments, r = 1, o = "", i = "", c = [0], a = function(f) {
+    r === 1 && (f || (o = o.replace(/^\s*\n\s*|\s*\n\s*$/g, ""))) ? c.push(f ? s[f] : o) : r === 3 && (f || o) ? (c[1] = f ? s[f] : o, r = 2) : r === 2 && o === "..." && f ? c[2] = Object.assign(c[2] || {}, s[f]) : r === 2 && o && !f ? (c[2] = c[2] || {})[o] = !0 : r >= 5 && (r === 5 ? ((c[2] = c[2] || {})[n] = f ? o ? o + s[f] : s[f] : o, r = 6) : (f || o) && (c[2][n] += f ? o + s[f] : o)), o = "";
+  }, h = 0; h < e.length; h++) {
+    h && (r === 1 && a(), a(h));
+    for (var d = 0; d < e[h].length; d++) t = e[h][d], r === 1 ? t === "<" ? (a(), c = [c, "", null], r = 3) : o += t : r === 4 ? o === "--" && t === ">" ? (r = 1, o = "") : o = t + o[0] : i ? t === i ? i = "" : o += t : t === '"' || t === "'" ? i = t : t === ">" ? (a(), r = 1) : r && (t === "=" ? (r = 5, n = o, o = "") : t === "/" && (r < 5 || e[h][d + 1] === ">") ? (a(), r === 3 && (c = c[0]), r = c, (c = c[0]).push(this.apply(null, r.slice(1))), r = 0) : t === " " || t === "	" || t === `
+` || t === "\r" ? (a(), r = 2) : o += t), r === 3 && o === "!--" && (r = 4, c = c[0]);
+  }
+  return a(), c.length > 2 ? c.slice(1) : c[1];
+}
+class qt {
+  constructor(t) {
+    u(this, "node");
+    u(this, "endNode");
+    u(this, "$predicate");
+    u(this, "stopCallback");
+    u(this, "thenContent");
+    u(this, "elseContent");
+    u(this, "connectedContent", []);
+    u(this, "elementContext");
+    u(this, "initialUpdateHappened", !1);
+    u(this, "previousValue");
+    this.$predicate = t.$predicate, this.thenContent = t.thenContent ? O(t.thenContent) : void 0, this.elseContent = t.elseContent ? O(t.elseContent) : void 0, this.elementContext = t.elementContext, this.elementContext.root.getEnv() === "development" ? (this.node = document.createComment("Conditional"), this.endNode = document.createComment("/Conditional")) : (this.node = document.createTextNode(""), this.endNode = document.createTextNode(""));
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, n) {
+    this.isMounted || (t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null), this.elementContext.root.getEnv() === "development" && t.insertBefore(this.endNode, this.node.nextSibling), this.stopCallback = this.$predicate.watch((s) => {
+      (!this.initialUpdateHappened || s && !this.previousValue || !s && this.previousValue) && (this.update(s), this.initialUpdateHappened = !0, this.previousValue = s);
+    }));
+  }
+  unmount() {
+    var t, n;
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0);
+    for (const s of this.connectedContent)
+      s.unmount();
+    this.connectedContent = [], this.isMounted && ((t = this.node.parentNode) == null || t.removeChild(this.node), (n = this.endNode.parentNode) == null || n.removeChild(this.endNode));
+  }
+  update(t) {
+    var n;
+    for (const s of this.connectedContent)
+      s.unmount();
+    if (this.connectedContent = [], this.node.parentNode != null) {
+      t && this.thenContent ? this.connectedContent = x(this.elementContext, this.thenContent) : !t && this.elseContent && (this.connectedContent = x(this.elementContext, this.elseContent));
+      for (let s = 0; s < this.connectedContent.length; s++) {
+        const r = this.connectedContent[s], o = ((n = this.connectedContent[s - 1]) == null ? void 0 : n.node) ?? this.node;
+        r.mount(this.node.parentNode, o);
+      }
+      this.elementContext.root.getEnv() === "development" && (this.node.textContent = `Conditional (${t ? "truthy" : "falsy"})`);
+    }
+  }
+}
+const Ft = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let lt = (e = 21) => {
+  let t = "", n = crypto.getRandomValues(new Uint8Array(e |= 0));
+  for (; e--; )
+    t += Ft[n[e] & 63];
+  return t;
+};
+const Wt = (e) => /^on[A-Z]/.test(e);
+class Lt {
+  constructor({ tag: t, props: n, children: s, elementContext: r }) {
+    u(this, "node");
+    u(this, "props");
+    u(this, "children");
+    u(this, "stopCallbacks", []);
+    u(this, "elementContext");
+    u(this, "uniqueId", lt());
+    // Track the ref so we can nullify it on unmount.
+    u(this, "ref");
+    // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+    u(this, "canClickAway", !1);
+    if (r = { ...r }, t.toLowerCase() === "svg" && (r.isSVG = !0), r.isSVG ? this.node = document.createElementNS("http://www.w3.org/2000/svg", t) : this.node = document.createElement(t), r.root.getEnv() === "development" && (this.node.dataset.uniqueId = this.uniqueId), n.ref)
+      if (at(n.ref))
+        this.ref = n.ref;
+      else
+        throw new Error("Expected ref to be a Ref object. Got: " + n.ref);
+    this.props = {
+      ...$t(["ref", "class", "className"], n),
+      class: n.className ?? n.class
+    }, this.children = s ? x(r, s) : [], this.elementContext = r;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, n) {
+    if (t == null)
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${t}`);
+    if (!this.isMounted) {
+      for (const s of this.children)
+        s.mount(this.node);
+      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, (n == null ? void 0 : n.nextSibling) ?? null), this.ref && (this.ref.node = this.node), setTimeout(() => {
+      this.canClickAway = !0;
+    }, 0);
+  }
+  unmount() {
+    var t;
+    if (this.isMounted) {
+      for (const n of this.children)
+        n.unmount();
+      this.ref && (this.ref.node = void 0), (t = this.node.parentNode) == null || t.removeChild(this.node), this.canClickAway = !1;
+      for (const n of this.stopCallbacks)
+        n();
+      this.stopCallbacks = [];
+    }
+  }
+  getUpdateKey(t, n) {
+    return `${this.uniqueId}:${t}:${n}`;
+  }
+  attachProp(t, n, s) {
+    C(t) ? this.stopCallbacks.push(
+      t.watch((r) => {
+        this.elementContext.root.render.update(() => {
+          n(r);
+        }, s);
+      })
+    ) : this.elementContext.root.render.update(() => {
+      n(t);
+    }, s);
+  }
+  applyProps(t, n) {
+    for (const s in n) {
+      const r = n[s];
+      if (s === "attributes") {
+        const o = r;
+        for (const i in o)
+          this.attachProp(
+            o[i],
+            (c) => {
+              c == null ? t.removeAttribute(i) : t.setAttribute(i, String(c));
+            },
+            this.getUpdateKey("attr", i)
+          );
+      } else if (s === "eventListeners") {
+        const o = r;
+        for (const i in o) {
+          const c = C(r) ? (a) => r.get()(a) : r;
+          t.addEventListener(i, c), this.stopCallbacks.push(() => {
+            t.removeEventListener(i, c);
+          });
+        }
+      } else if (s === "onClickOutside" || s === "onclickoutside") {
+        const o = (c) => {
+          this.canClickAway && !t.contains(c.target) && (C(r) ? r.get()(c) : r(c));
+        }, i = { capture: !0 };
+        window.addEventListener("click", o, i), this.stopCallbacks.push(() => {
+          window.removeEventListener("click", o, i);
+        });
+      } else if (s === "$$value") {
+        if (!D(r))
+          throw new TypeError(`$$value attribute must be a settable state. Got: ${r}`);
+        this.attachProp(
+          r,
+          (i) => {
+            i == null ? t.value = "" : t.value = String(i);
+          },
+          this.getUpdateKey("attr", "value")
+        );
+        const o = (i) => {
+          const c = Ut(r.get(), i.currentTarget.value);
+          r.set(c);
+        };
+        t.addEventListener("input", o), this.stopCallbacks.push(() => {
+          t.removeEventListener("input", o);
+        });
+      } else if (Wt(s)) {
+        const o = s.slice(2).toLowerCase(), i = C(r) ? (c) => r.get()(c) : r;
+        t.addEventListener(o, i), this.stopCallbacks.push(() => {
+          t.removeEventListener(o, i);
+        });
+      } else if (s.includes("-"))
+        this.attachProp(
+          r,
+          (o) => {
+            o == null ? t.removeAttribute(s) : t.setAttribute(s, String(o));
+          },
+          this.getUpdateKey("attr", s)
+        );
+      else if (!jt.includes(s))
+        if (this.elementContext.isSVG)
+          this.attachProp(
+            r,
+            (o) => {
+              o != null ? t.setAttribute(s, String(n[s])) : t.removeAttribute(s);
+            },
+            this.getUpdateKey("attr", s)
+          );
+        else
+          switch (s) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(
+                r,
+                (o) => {
+                  t[s] = String(o);
+                },
+                this.getUpdateKey("prop", s)
+              );
+              break;
+            case "for":
+              this.attachProp(
+                r,
+                (o) => {
+                  t.htmlFor = o;
+                },
+                this.getUpdateKey("prop", "htmlFor")
+              );
+              break;
+            case "checked":
+              this.attachProp(
+                r,
+                (o) => {
+                  t.checked = o, o ? 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 o = s.toLowerCase();
+              this.attachProp(
+                r,
+                (i) => {
+                  i == null ? t.removeAttribute(o) : t.setAttribute(o, String(i));
+                },
+                this.getUpdateKey("attr", o)
+              );
+              break;
+            }
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(
+                r,
+                (o) => {
+                  typeof o == "string" ? t.autocomplete = o : o ? t.autocomplete = "on" : t.autocomplete = "off";
+                },
+                this.getUpdateKey("prop", s)
+              );
+              break;
+            default: {
+              this.attachProp(
+                r,
+                (o) => {
+                  t[s] = o;
+                },
+                this.getUpdateKey("prop", s)
+              );
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(t, n, s) {
+    const r = [];
+    if (C(n)) {
+      let o;
+      const i = n.watch((c) => {
+        this.elementContext.root.render.update(
+          () => {
+            $(o) && o(), t.style.cssText = "", o = this.applyStyles(t, c, s);
+          },
+          this.getUpdateKey("styles", "*")
+        );
+      });
+      s.push(i), r.push(i);
+    } else {
+      const o = dt(n);
+      for (const i in o) {
+        const { value: c, priority: a } = o[i];
+        if (C(c)) {
+          const h = c.watch((d) => {
+            this.elementContext.root.render.update(() => {
+              d ? t.style.setProperty(i, String(d), a) : t.style.removeProperty(i);
+            });
+          });
+          s.push(h), r.push(h);
+        } else c != null && t.style.setProperty(i, String(c));
+      }
+    }
+    return function() {
+      for (const i of r)
+        i(), s.splice(s.indexOf(i), 1);
+    };
+  }
+  applyClasses(t, n, s) {
+    const r = [];
+    if (C(n)) {
+      let o;
+      const i = n.watch((c) => {
+        this.elementContext.root.render.update(
+          () => {
+            $(o) && o(), t.removeAttribute("class"), o = this.applyClasses(t, c, s);
+          },
+          this.getUpdateKey("attr", "class")
+        );
+      });
+      s.push(i), r.push(i);
+    } else {
+      const o = ht(n);
+      for (const i in o) {
+        const c = o[i];
+        if (C(c)) {
+          const a = c.watch((h) => {
+            this.elementContext.root.render.update(() => {
+              h ? t.classList.add(i) : t.classList.remove(i);
+            });
+          });
+          s.push(a), r.push(a);
+        } else c && t.classList.add(i);
+      }
+    }
+    return function() {
+      for (const i of r)
+        i(), s.splice(s.indexOf(i), 1);
+    };
+  }
+}
+function ht(e) {
+  let t = {};
+  if (A(e)) {
+    const n = e.split(" ");
+    for (const s of n)
+      t[s] = !0;
+  } else L(e) ? Object.assign(t, e) : Array.isArray(e) && Array.from(e).filter(Boolean).forEach((n) => {
+    Object.assign(t, ht(n));
+  });
+  return delete t.undefined, t;
+}
+function dt(e) {
+  let t = {};
+  if (A(e)) {
+    const n = e.split(";").filter((s) => s.trim() !== "");
+    for (const s of n) {
+      const [r, o] = s.split(":"), i = {
+        value: o
+      };
+      o.includes("!important") ? (i.priority = "important", i.value = o.replace("!important", "").trim()) : i.value = o.trim(), t[tt(r.trim())] = i;
+    }
+  }
+  if (L(e))
+    for (const n in e)
+      n.startsWith("--") ? t[n] = { value: e[n] } : t[tt(n)] = { value: e[n] };
+  else Array.isArray(e) && Array.from(e).filter((n) => n != null).forEach((n) => {
+    Object.assign(t, dt(n));
+  });
+  return t;
+}
+function tt(e) {
+  return e.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, n) => (n ? "-" : "") + t.toLowerCase());
+}
+function Ut(e, t) {
+  const n = typeof e;
+  return n === "string" ? String(t) : n === "number" ? Number(t) : n === "boolean" ? !!t : t;
+}
+const jt = ["ref", "children", "class", "style", "data"];
+class It {
+  constructor({ states: t, renderFn: n, elementContext: s }) {
+    u(this, "node");
+    u(this, "endNode");
+    u(this, "connectedViews", []);
+    u(this, "renderFn");
+    u(this, "elementContext");
+    u(this, "observerControls");
+    u(this, "watcher", K());
+    this.elementContext = s, this.renderFn = n, this.node = document.createComment("Observer"), this.endNode = document.createComment("/Observer");
+    let r;
+    this.observerControls = {
+      start: () => {
+        r == null && (r = this.watcher.watch(t, (...o) => {
+          const i = this.renderFn(...o);
+          if (!mt(i))
+            throw console.error(i), new TypeError(
+              `Observer received invalid value to render. Got type: ${R(i)}, value: ${i}`
+            );
+          Array.isArray(i) ? this.update(...i) : this.update(i);
+        }));
+      },
+      stop: () => {
+        r != null && (r(), r = void 0);
+      }
+    };
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, n) {
+    this.isMounted || (t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null), this.observerControls.start());
+  }
+  unmount() {
+    var t;
+    this.observerControls.stop(), this.watcher.stopAll(), this.isMounted && (this.cleanup(), (t = this.node.parentNode) == null || t.removeChild(this.node));
+  }
+  cleanup() {
+    var t;
+    for (; this.connectedViews.length > 0; )
+      (t = this.connectedViews.pop()) == null || t.unmount();
+  }
+  update(...t) {
+    var s, r;
+    if (this.cleanup(), t == null || !this.isMounted)
+      return;
+    const n = t.map((o) => ft(o) ? o : V(o) ? _(x(this.elementContext, o)) : _(x(this.elementContext, O(o))));
+    for (const o of n) {
+      const i = ((s = this.connectedViews.at(-1)) == null ? void 0 : s.node) || this.node;
+      o.mount(this.node.parentNode, i), this.connectedViews.push(o);
+    }
+    if (this.elementContext.root.getEnv() === "development") {
+      const o = (r = this.connectedViews.at(-1)) == null ? void 0 : r.node;
+      this.endNode.previousSibling !== o && this.node.parentNode.insertBefore(this.endNode, (o == null ? void 0 : o.nextSibling) ?? null);
+    }
+  }
+}
+class Rt {
+  constructor(t) {
+    u(this, "node");
+    u(this, "endNode");
+    u(this, "$children");
+    u(this, "stopCallback");
+    u(this, "mountedChildren", []);
+    u(this, "elementContext");
+    this.$children = t.$children, this.elementContext = t.elementContext, this.elementContext.root.getEnv() === "development" ? (this.node = document.createComment("Outlet"), this.endNode = document.createComment("/Outlet")) : (this.node = document.createTextNode(""), this.endNode = document.createTextNode(""));
+  }
+  get isMounted() {
+    var t;
+    return ((t = this.node) == null ? void 0 : t.parentNode) != null;
+  }
+  mount(t, n) {
+    this.isMounted || (t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null), this.stopCallback = this.$children.watch((s) => {
+      this.update(s);
+    }));
+  }
+  unmount() {
+    var t;
+    if (this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), this.isMounted) {
+      for (const n of this.mountedChildren)
+        n.unmount();
+      this.mountedChildren = [], (t = this.endNode.parentNode) == null || t.removeChild(this.endNode);
+    }
+  }
+  update(t) {
+    var n, s, r;
+    for (const o of this.mountedChildren)
+      o.unmount();
+    for (let o = 0; o < t.length; o++) {
+      const i = t[o], c = o > 0 ? t[o] : void 0;
+      i.mount(this.node.parentElement, c == null ? void 0 : c.node);
+    }
+    this.mountedChildren = t, this.elementContext.root.getEnv() === "development" && (this.node.textContent = `Outlet (${t.length} ${t.length === 1 ? "child" : "children"})`, (r = this.node.parentElement) == null || r.insertBefore(
+      this.endNode,
+      ((s = (n = this.mountedChildren[this.mountedChildren.length - 1]) == null ? void 0 : n.node) == null ? void 0 : s.nextSibling) ?? null
+    ));
+  }
+}
+class Gt {
+  constructor(t) {
+    u(this, "config");
+    u(this, "element");
+    this.config = t;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(t, n) {
+    const { content: s, parent: r } = this.config;
+    ft(s) ? this.element = s : V(s) ? this.element = _(x(this.config.elementContext, s)) : this.element = _(x(this.config.elementContext, O(s))), this.element.mount(r);
+  }
+  unmount() {
+    var t;
+    (t = this.element) != null && t.isMounted && this.element.unmount();
+  }
+}
+function H(e, t, n, s = []) {
+  e = { ...e, data: {}, parent: e };
+  const [r, o] = W(x(e, s));
+  let i = !1;
+  const c = K(), a = [], h = [], d = [], f = [], y = lt(), [w, S] = W(t.name), v = e.root.createLogger(w, { uid: y }), b = {
+    get uid() {
+      return y;
+    },
+    set(l, p) {
+      return e.data[l] = p, p;
+    },
+    get(l) {
+      let p = e;
+      for (; ; ) {
+        if (l in p.data)
+          return p.data[l];
+        if (p.parent)
+          p = p.parent;
+        else
+          break;
+      }
+      return null;
+    },
+    getAll() {
+      const l = [];
+      let p = e;
+      for (; l.push(p.data), p.parent; )
+        p = p.parent;
+      const g = {};
+      for (const N of l.reverse())
+        Object.assign(g, N);
+      return g;
+    },
+    setName(l) {
+      S(l);
+    },
+    beforeMount(l) {
+      a.push(l);
+    },
+    onMount(l) {
+      h.push(l);
+    },
+    beforeUnmount(l) {
+      d.push(l);
+    },
+    onUnmount(l) {
+      f.push(l);
+    },
+    watch(l, p) {
+      if (i)
+        return c.watch(l, p);
+      {
+        let g, N = !1;
+        return h.push(() => {
+          N || (g = c.watch(l, p));
+        }), () => {
+          g != null && (N = !0, g());
+        };
+      }
+    },
+    outlet() {
+      return k("$outlet", { $children: r });
+    }
+  };
+  Object.assign(b, v);
+  let m;
+  function E() {
+    let l;
+    try {
+      l = t(n, b);
+    } catch (p) {
+      throw p instanceof Error && v.crash(p), p;
+    }
+    if (l instanceof Promise)
+      throw new TypeError("View function cannot return a Promise.");
+    if (l !== null) if (l instanceof Node)
+      m = _(x(e, k("$node", { value: l })));
+    else if (V(l) || it(V, l))
+      m = _(x(e, l));
+    else if (C(l))
+      m = _(
+        x(e, k("$observer", { states: [l], renderFn: (p) => p }))
+      );
+    else {
+      const p = new TypeError(
+        `Expected '${t.name}' function to return a DOM node, Markup element, Readable or null. Got: ${R(l)}`
+      );
+      v.crash(p);
+    }
+  }
+  return {
+    get node() {
+      return m == null ? void 0 : m.node;
+    },
+    get isMounted() {
+      return i;
+    },
+    mount(l, p) {
+      const g = i;
+      if (!g)
+        for (E(); a.length > 0; )
+          a.shift()();
+      m && m.mount(l, p), g || (i = !0, requestAnimationFrame(() => {
+        for (; h.length > 0; )
+          h.shift()();
+      }));
+    },
+    unmount() {
+      for (; d.length > 0; )
+        d.shift()();
+      for (m && m.unmount(), i = !1; f.length > 0; )
+        f.shift()();
+      c.stopAll();
+    },
+    setChildView(l) {
+      const p = H(e, l, {});
+      return o([p]), p;
+    }
+  };
+}
+class Bt {
+  constructor({ elementContext: t, $items: n, renderFn: s, keyFn: r }) {
+    u(this, "node");
+    u(this, "endNode");
+    u(this, "$items");
+    u(this, "stopCallback");
+    u(this, "connectedItems", []);
+    u(this, "elementContext");
+    u(this, "renderFn");
+    u(this, "keyFn");
+    this.elementContext = t, this.$items = n, this.renderFn = s, this.keyFn = r, this.elementContext.root.getEnv() === "development" ? (this.node = document.createComment("Repeat"), this.endNode = document.createComment("/Repeat")) : (this.node = document.createTextNode(""), this.endNode = document.createTextNode(""));
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, n) {
+    this.isMounted || (t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null), this.stopCallback = this.$items.watch((s) => {
+      this._update(Array.from(s));
+    }));
+  }
+  unmount() {
+    var t, n;
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), this.isMounted && ((t = this.node.parentNode) == null || t.removeChild(this.node), (n = this.endNode.parentNode) == null || n.removeChild(this.endNode)), this._cleanup();
+  }
+  _cleanup() {
+    for (const t of this.connectedItems)
+      t.element.unmount();
+    this.connectedItems = [];
+  }
+  _update(t) {
+    var o, i, c;
+    if (t.length === 0 || !this.isMounted)
+      return this._cleanup();
+    const n = [];
+    let s = 0;
+    for (const a of t)
+      n.push({
+        key: this.keyFn(a, s),
+        value: a,
+        index: s++
+      });
+    const r = [];
+    for (const a of this.connectedItems)
+      n.find((d) => d.key === a.key) || a.element.unmount();
+    for (const a of n) {
+      const h = this.connectedItems.find((d) => d.key === a.key);
+      if (h)
+        h.setValue(a.value), h.setIndex(a.index), r[a.index] = h;
+      else {
+        const [d, f] = W(a.value), [y, w] = W(a.index);
+        r[a.index] = {
+          key: a.key,
+          $value: d,
+          setValue: f,
+          $index: y,
+          setIndex: w,
+          element: H(this.elementContext, Dt, {
+            $value: d,
+            $index: y,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let a = 0; a < r.length; a++) {
+      const h = r[a], d = ((o = r[a - 1]) == null ? void 0 : o.element.node) ?? this.node;
+      h.element.mount(this.node.parentNode, d);
+    }
+    if (this.connectedItems = r, this.elementContext.root.getEnv() === "development") {
+      this.node.textContent = `Repeat (${r.length} item${r.length === 1 ? "" : "s"})`;
+      const a = ((i = r.at(-1)) == null ? void 0 : i.element.node) ?? this.node;
+      (c = this.node.parentNode) == null || c.insertBefore(this.endNode, a.nextSibling);
+    }
+  }
+}
+function Dt({ $value: e, $index: t, renderFn: n }, s) {
+  return n(e, t, s);
+}
+class Kt {
+  constructor({ value: t }) {
+    u(this, "node", document.createTextNode(""));
+    u(this, "value", "");
+    u(this, "stopCallback");
+    this.value = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  async mount(t, n = null) {
+    this.isMounted || (C(this.value) ? this.stopCallback = this.value.watch((s) => {
+      this.update(s);
+    }) : this.update(this.value)), t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null);
+  }
+  async unmount() {
+    this.isMounted && (this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), this.node.parentNode.removeChild(this.node));
+  }
+  update(t) {
+    t != null ? this.node.textContent = t.toString() : this.node.textContent = "";
+  }
+}
+function V(e) {
+  return L(e) && (typeof e.type == "string" || typeof e.type == "function") && Array.isArray(e.children);
+}
+function ft(e) {
+  return L(e) && $(e.connect) && $(e.disconnect);
+}
+function O(e) {
+  return M(e) || (e = [e]), e.flat(1 / 0).filter((t) => t != null && t !== !1).map((t) => {
+    if (t instanceof Node)
+      return k("$node", { value: t });
+    if (t instanceof pt)
+      return k("$node", { value: t.node });
+    if (V(t))
+      return t;
+    if (A(t) || St(t))
+      return k("$text", { value: t });
+    if (C(t))
+      return k("$observer", {
+        states: [t],
+        renderFn: (n) => n
+      });
+    throw console.error(t), new TypeError(`Unexpected child type. Got: ${t}`);
+  });
+}
+function k(e, t, ...n) {
+  return t != null && Ht(t), {
+    type: e,
+    props: t,
+    children: O(n)
+  };
+}
+function Ht(e) {
+  if (e.ref && !at(e.ref))
+    throw console.warn(e.ref), new TypeError(`Prop 'ref' must be a Ref object. Got: ${e.ref}`);
+  for (const t in e)
+    if (t.startsWith("$$") && e[t] !== void 0) {
+      if (!D(e[t]))
+        throw new TypeError(`Prop '${t}' is named as a SettableState but value is not. Got: ${e[t]}`);
+    } else if (t.startsWith("$") && e[t] !== void 0 && !C(e[t]))
+      throw new TypeError(`Prop '${t}' is named as a State but value is not. Got: ${e[t]}`);
+}
+const oe = Pt.bind(k);
+function ie(e, t, n) {
+  const s = j(e);
+  return k("$cond", {
+    $predicate: s,
+    thenContent: t,
+    elseContent: n
+  });
+}
+function ue(e, t, n) {
+  const s = j(e);
+  return k("$repeat", { $items: s, keyFn: t, renderFn: n });
+}
+function ce(e, t) {
+  return k("$portal", { parent: e, content: t });
+}
+class pt {
+  constructor(t) {
+    u(this, "node");
+    this.node = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  async mount(t, n) {
+    t.insertBefore(this.node, (n == null ? void 0 : n.nextSibling) ?? null);
+  }
+  async unmount() {
+    this.node.parentNode && this.node.parentNode.removeChild(this.node);
+  }
+}
+function x(e, t) {
+  return (M(t) ? t : [t]).map((s) => {
+    if ($(s.type))
+      return H(e, s.type, s.props, s.children);
+    if (A(s.type))
+      switch (s.type) {
+        case "$node": {
+          const r = s.props;
+          return new pt(r.value);
+        }
+        case "$text": {
+          const r = s.props;
+          return new Kt({
+            value: r.value
+          });
+        }
+        case "$cond": {
+          const r = s.props;
+          return new qt({
+            $predicate: r.$predicate,
+            thenContent: r.thenContent,
+            elseContent: r.elseContent,
+            elementContext: e
+          });
+        }
+        case "$repeat": {
+          const r = s.props;
+          return new Bt({
+            $items: r.$items,
+            keyFn: r.keyFn,
+            renderFn: r.renderFn,
+            elementContext: e
+          });
+        }
+        case "$observer": {
+          const r = s.props;
+          return new It({
+            states: r.states,
+            renderFn: r.renderFn,
+            elementContext: e
+          });
+        }
+        case "$outlet": {
+          const r = s.props;
+          return new Rt({
+            $children: r.$children,
+            elementContext: e
+          });
+        }
+        case "$portal": {
+          const r = s.props;
+          return new Gt({
+            content: r.content,
+            parent: r.parent,
+            elementContext: e
+          });
+        }
+        default:
+          if (s.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${s.type}`);
+          return new Lt({
+            tag: s.type,
+            props: s.props ?? {},
+            children: s.children,
+            elementContext: e
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${s.type}`);
+  });
+}
+function _(e) {
+  if (e.length === 1)
+    return e[0];
+  const t = document.createComment("Fragment");
+  let n = !1;
+  return {
+    get node() {
+      return t;
+    },
+    get isMounted() {
+      return n;
+    },
+    mount(s, r) {
+      var o;
+      s.insertBefore(t, r || null);
+      for (const i of e) {
+        const c = ((o = e[e.length - 1]) == null ? void 0 : o.node) ?? t;
+        i.mount(s, c);
+      }
+      n = !0;
+    },
+    unmount() {
+      if (n) {
+        for (const s of e)
+          s.unmount();
+        t.remove();
+      }
+      n = !1;
+    }
+  };
+}
+function mt(e) {
+  return e == null || e === !1 || typeof e == "string" || typeof e == "number" || V(e) || C(e) || it(mt, e);
+}
+function ae(e, t) {
+  return t.outlet();
+}
+export {
+  x as A,
+  se as B,
+  ce as C,
+  ue as D,
+  ae as P,
+  W as a,
+  Qt as b,
+  ie as c,
+  Tt as d,
+  $ as e,
+  A as f,
+  Zt as g,
+  oe as h,
+  L as i,
+  Yt as j,
+  K as k,
+  te as l,
+  ee as m,
+  ne as n,
+  j as o,
+  re as p,
+  at as q,
+  Jt as r,
+  k as s,
+  R as t,
+  Xt as u,
+  At as v,
+  Nt as w,
+  _t as x,
+  H as y,
+  _ as z
+};
+//# sourceMappingURL=passthrough-DUh0_zQF.js.map