@manyducks.co/dolla 2.0.0-alpha.25 → 2.0.0-alpha.27

package/dist/passthrough-D9NjRov5.js

@@ -0,0 +1,1319 @@
+var Ft = Object.defineProperty;
+var et = (n) => {
+  throw TypeError(n);
+};
+var Pt = (n, t, e) => t in n ? Ft(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var u = (n, t, e) => Pt(n, typeof t != "symbol" ? t + "" : t, e), nt = (n, t, e) => t.has(n) || et("Cannot " + e);
+var $ = (n, t, e) => (nt(n, t, "read from private field"), e ? e.call(n) : t.get(n)), L = (n, t, e) => t.has(n) ? et("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), U = (n, t, e, r) => (nt(n, t, "write to private field"), r ? r.call(n, e) : t.set(n, e), e);
+function _t(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var W = { exports: {} }, rt;
+function It() {
+  return rt || (rt = 1, function(n, t) {
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    var e = /* @__PURE__ */ function() {
+      function h(a, f) {
+        var l = [], d = !0, p = !1, g = void 0;
+        try {
+          for (var M, _ = a[Symbol.iterator](); !(d = (M = _.next()).done) && (l.push(M.value), !(f && l.length === f)); d = !0) ;
+        } catch (w) {
+          p = !0, g = w;
+        } finally {
+          try {
+            !d && _.return && _.return();
+          } finally {
+            if (p) throw g;
+          }
+        }
+        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(w, C, v) {
+        var j = Math.round, y = 0 > v ? v + 1 : 1 < v ? v - 1 : v;
+        return y = y < 1 / 6 ? w + 6 * (C - w) * y : y < 1 / 2 ? C : y < 2 / 3 ? w + 6 * (C - w) * (2 / 3 - y) : w, j(255 * y);
+      }, g = p(d, l, h + 1 / 3), M = p(d, l, h), _ = p(d, l, h - 1 / 3);
+      return [g, M, _];
+    }, i = function(h, a, f, l) {
+      var d = h % 1007 / 1007, p = function(w, C, v) {
+        return w * (v - C) + C;
+      }, g = p(d, a.min, a.max), M = p(d, f.min, f.max), _ = p(d, l.max, l.min);
+      return [g, M, _];
+    }, o = 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, g = h.light, M = g === void 0 ? { min: 0.3, max: 0.7 } : g, _ = h.hashFunction, w = _ === void 0 ? o : _, C = h.scheme, v = C === void 0 ? "hex" : C, j = i(w(a), l, p, M), y = e(j, 3), X = y[0], J = y[1], Q = y[2], tt = s(X / 360, J, Q), qt = r(tt);
+      return v === "hsl" ? [X, J, Q] : v === "rgb" ? tt : qt;
+    };
+    t.default = c, n.exports = t.default;
+  }(W, W.exports)), W.exports;
+}
+var jt = It();
+const Lt = /* @__PURE__ */ _t(jt);
+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 pe(n, t) {
+  if (!n)
+    throw new TypeError(
+      I(n, t || "Failed assertion. Value is not truthy. Got type: %t, value: %v")
+    );
+}
+function A(n) {
+  return Array.isArray(n);
+}
+function vt(...n) {
+  const t = n[0], e = (r) => A(r) && r.every((s) => t(s));
+  return n.length < 2 ? e : e(n[1]);
+}
+function me(...n) {
+  const t = n[0], e = E(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(I(s, e));
+  };
+  return n.length < 2 ? r : r(n[1]);
+}
+function E(n) {
+  return typeof n == "string";
+}
+function ge(n, t) {
+  if (E(n))
+    return !0;
+  throw new TypeError(I(n, t ?? "Expected a string. Got type: %t, value: %v"));
+}
+function q(n) {
+  return typeof n == "function" && !Rt(n);
+}
+function Ut(n) {
+  return typeof n == "number" && !isNaN(n);
+}
+function Rt(n) {
+  return typeof n == "function" && /^\s*class\s+/.test(n.toString());
+}
+function we(...n) {
+  const t = n[0], e = E(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(I(s, e));
+  };
+  return n.length < 2 ? r : r(n[1]);
+}
+function St(n) {
+  return n != null && typeof n == "object" && !A(n);
+}
+function I(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 R, st;
+function zt() {
+  return st || (st = 1, R = 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 o = i[s];
+        if (!n(t[o], e[o])) return !1;
+      }
+      return !0;
+    }
+    return t !== t && e !== e;
+  }), R;
+}
+var Gt = zt();
+const Dt = /* @__PURE__ */ _t(Gt), Kt = () => {
+};
+let z = 1;
+function Ct() {
+  return z = z % Number.MAX_SAFE_INTEGER + 1, z.toString(36) + Date.now().toString(36);
+}
+function Mt(n, t) {
+  return n === t;
+}
+function ye(n, t) {
+  if (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 (q(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 _e = Dt;
+function Bt(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 ve(n) {
+  return Lt({
+    str: n,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function Se(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((o) => o(r)) || s.length > 0 && !s.some((o) => o(r)));
+  };
+}
+var Ht = Object.defineProperty, Zt = (n, t, e) => t in n ? Ht(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, it = (n, t, e) => Zt(n, typeof t != "symbol" ? t + "" : t, e);
+class kt {
+  constructor() {
+    it(this, "_l", /* @__PURE__ */ new Map()), it(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 o = this._l.get("error");
+        if (o != null && o.length)
+          for (const c of o)
+            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 O, b;
+class Ce {
+  constructor(t) {
+    // #dolla;
+    L(this, O);
+    L(this, b);
+    U(this, O, t.createLogger("Dolla.stats")), U(this, b, V());
+    let e;
+    $(this, b).emitter.on("statsChanged", () => {
+      e && clearTimeout(e), e = setTimeout(() => {
+        $(this, O).info($(this, b).stats);
+      }, 200);
+    });
+  }
+}
+O = new WeakMap(), b = new WeakMap();
+const G = "__DOLLA_STATS_STORE__";
+function ot() {
+  const n = new kt(), 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 V() {
+  return typeof window < "u" ? (window[G] || (window[G] = ot()), window[G]) : ot();
+}
+function xt() {
+  V().emitter.emit("_incrementWatcherCount", 1);
+}
+function Et() {
+  V().emitter.emit("_incrementWatcherCount", -1);
+}
+function Yt() {
+  V().emitter.emit("_incrementViewCount", 1);
+}
+function Xt() {
+  V().emitter.emit("_incrementViewCount", -1);
+}
+const bt = Symbol.for("DollaState"), At = Symbol.for("DollaRef"), Nt = Symbol.for("DollaMarkup"), k = Symbol.for("DollaMarkupElement");
+function m(n) {
+  return (n == null ? void 0 : n[bt]) === !0;
+}
+function Jt(n) {
+  return m(n) ? n.get() : n;
+}
+function K(n) {
+  return m(n) ? n : new B({
+    get() {
+      return n;
+    },
+    watch(t, e = {}) {
+      return e != null && e.lazy || t(n), Kt;
+    }
+  });
+}
+class Qt {
+  constructor(t, e) {
+    u(this, "value");
+    u(this, "watchers", []);
+    u(this, "equals", Mt);
+    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), xt(), () => {
+      const r = this.watchers.indexOf(t);
+      r > -1 && this.watchers.splice(r, 1), Et();
+    };
+  }
+}
+var ht;
+ht = bt;
+class B {
+  constructor(t) {
+    u(this, ht, !0);
+    u(this, "__value");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  watch(t, e) {
+    return this.__value.watch(t, e);
+  }
+}
+function D(n, t) {
+  const e = new Qt(n, t);
+  return [new B(e), (s) => e.set(s)];
+}
+const ut = Symbol("EMPTY");
+class te {
+  constructor(t, e, r) {
+    u(this, "equals", Mt);
+    /**
+     * 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", H());
+    /**
+     * 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", ut);
+    /**
+     * 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(K), this.fn = e, r != null && r.equals && (this.equals = r.equals), this.previousSourceValues = new Array(t.length).fill(ut, 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), xt(), () => {
+      r.splice(r.indexOf(t), 1), this.isWatchingSources && r.length === 0 && this.stopWatchingSources(), Et();
+    };
+  }
+  /*==========================*\
+  ||         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 = Jt(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 ee(n, t, e) {
+  const r = new te(n, t, e);
+  return new B(r);
+}
+function H() {
+  const n = [];
+  return {
+    watch(t, e) {
+      if (t.length === 0)
+        throw new TypeError("Expected at least one state to watch.");
+      t = t.map(K);
+      let r;
+      return t.length > 1 ? r = ee(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 Me(n) {
+  const t = function() {
+    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[At] = !0, t;
+}
+function ne(n) {
+  return (n == null ? void 0 : n[At]) === !0;
+}
+function re(n) {
+  for (var t, e, r = arguments, s = 1, i = "", o = "", 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] : o ? t === o ? o = "" : i += t : t === '"' || t === "'" ? o = 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 lt;
+lt = k;
+class ct {
+  constructor(t) {
+    u(this, lt, !0);
+    u(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 se = (n) => /^on[A-Z]/.test(n);
+var ft;
+ft = k;
+class ie {
+  constructor({ tag: t, props: e, children: r, elementContext: s }) {
+    u(this, ft, !0);
+    u(this, "node");
+    u(this, "props");
+    u(this, "childMarkup", []);
+    u(this, "children", []);
+    u(this, "stopCallbacks", []);
+    u(this, "elementContext");
+    u(this, "uniqueId", Ct());
+    u(this, "_batchWrite");
+    // 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 (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 (ne(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 = {
+      ...Bt(["ref", "class", "className"], e),
+      class: e.className ?? e.class
+    }, r && (this.childMarkup = r), this.elementContext = s, this.children = x(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 o in i)
+          this.attachProp(
+            i[o],
+            (c) => {
+              c == null ? t.removeAttribute(o) : t.setAttribute(o, String(c));
+            },
+            this.getUpdateKey("attr", o)
+          );
+      } else if (r === "eventListeners") {
+        const i = s;
+        for (const o in i) {
+          const c = m(s) ? (h) => s.get()(h) : s;
+          t.addEventListener(o, c), this.stopCallbacks.push(() => {
+            t.removeEventListener(o, c);
+          });
+        }
+      } else if (r === "onClickOutside" || r === "onclickoutside") {
+        const i = (c) => {
+          this.canClickAway && !t.contains(c.target) && (m(s) ? s.get()(c) : s(c));
+        }, o = { capture: !0 };
+        window.addEventListener("click", i, o), this.stopCallbacks.push(() => {
+          window.removeEventListener("click", i, o);
+        });
+      } else if (se(r)) {
+        const i = r.slice(2).toLowerCase(), o = m(s) ? (c) => s.get()(c) : s;
+        t.addEventListener(i, o), this.stopCallbacks.push(() => {
+          t.removeEventListener(i, o);
+        });
+      } else if (r.includes("-"))
+        this.attachProp(
+          s,
+          (i) => {
+            i == null ? t.removeAttribute(r) : t.setAttribute(r, String(i));
+          },
+          this.getUpdateKey("attr", r)
+        );
+      else if (!oe.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,
+                (o) => {
+                  o == null ? t.removeAttribute(i) : t.setAttribute(i, String(o));
+                },
+                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 o = e.watch((c) => {
+        this._mutate(
+          () => {
+            q(i) && i(), t.style.cssText = "", i = this.applyStyles(t, c, r);
+          },
+          this.getUpdateKey("styles", "*")
+        );
+      });
+      r.push(o), s.push(o);
+    } else {
+      const i = Vt(e);
+      for (const o in i) {
+        const { value: c, priority: h } = i[o];
+        if (m(c)) {
+          const a = c.watch((f) => {
+            this._mutate(() => {
+              f ? t.style.setProperty(o, String(f), h) : t.style.removeProperty(o);
+            });
+          });
+          r.push(a), s.push(a);
+        } else c != null && t.style.setProperty(o, String(c));
+      }
+    }
+    return function() {
+      for (const o of s)
+        o(), r.splice(r.indexOf(o), 1);
+    };
+  }
+  applyClasses(t, e, r) {
+    const s = [];
+    if (m(e)) {
+      let i;
+      const o = e.watch((c) => {
+        this._mutate(
+          () => {
+            q(i) && i(), t.removeAttribute("class"), i = this.applyClasses(t, c, r);
+          },
+          this.getUpdateKey("attr", "class")
+        );
+      });
+      r.push(o), s.push(o);
+    } else {
+      const i = Ot(e);
+      for (const o in i) {
+        const c = i[o];
+        if (m(c)) {
+          const h = c.watch((a) => {
+            this._mutate(() => {
+              a ? t.classList.add(o) : t.classList.remove(o);
+            });
+          });
+          r.push(h), s.push(h);
+        } else c && t.classList.add(o);
+      }
+    }
+    return function() {
+      for (const o of s)
+        o(), r.splice(r.indexOf(o), 1);
+    };
+  }
+}
+function Ot(n) {
+  let t = {};
+  if (E(n)) {
+    const e = n.split(" ");
+    for (const r of e)
+      t[r] = !0;
+  } else St(n) ? Object.assign(t, n) : Array.isArray(n) && Array.from(n).filter(Boolean).forEach((e) => {
+    Object.assign(t, Ot(e));
+  });
+  return delete t.undefined, t;
+}
+function Vt(n) {
+  let t = {};
+  if (E(n)) {
+    const e = n.split(";").filter((r) => r.trim() !== "");
+    for (const r of e) {
+      const [s, i] = r.split(":"), o = {
+        value: i
+      };
+      i.includes("!important") ? (o.priority = "important", o.value = i.replace("!important", "").trim()) : o.value = i.trim(), t[at(s.trim())] = o;
+    }
+  }
+  if (St(n))
+    for (const e in n)
+      e.startsWith("--") ? t[e] = { value: n[e] } : t[at(e)] = { value: n[e] };
+  else Array.isArray(n) && Array.from(n).filter((e) => e != null).forEach((e) => {
+    Object.assign(t, Vt(e));
+  });
+  return t;
+}
+function at(n) {
+  return n.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, e) => (e ? "-" : "") + t.toLowerCase());
+}
+const oe = ["ref", "children", "class", "style", "data"];
+var dt;
+dt = k;
+class ue {
+  constructor({ sources: t, renderFn: e, elementContext: r }) {
+    u(this, dt, !0);
+    u(this, "node", document.createTextNode(""));
+    u(this, "children", []);
+    u(this, "renderFn");
+    u(this, "elementContext");
+    u(this, "watcher", H());
+    u(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 (!Tt(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, o, c;
+    if (this.cleanup(!1), t == null || t.length === 0 || !this.isMounted)
+      return;
+    const e = t.flatMap((h) => Wt(h) ? h : x(this.elementContext, Z(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 = (o = this.children.at(-1)) == null ? void 0 : o.node) == null ? void 0 : c.nextSibling) ?? null;
+    r.insertBefore(this.node, s);
+  }
+}
+var pt;
+pt = k;
+class $t {
+  constructor(t) {
+    u(this, pt, !0);
+    u(this, "node", document.createTextNode(""));
+    u(this, "isMounted", !1);
+    u(this, "source");
+    u(this, "elements", []);
+    u(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], o = s > 0 ? this.elements[s - 1] : void 0;
+        i.mount(this.node.parentElement, o == null ? void 0 : o.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 mt;
+mt = k;
+class ce {
+  constructor(t) {
+    u(this, mt, !0);
+    u(this, "config");
+    u(this, "element");
+    this.config = t;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(t, e) {
+    const { content: r, parent: s } = this.config;
+    Wt(r) ? this.element = r : this.element = T(x(this.config.elementContext, Z(r))), this.element.mount(s);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.element) != null && e.isMounted && this.element.unmount(t);
+  }
+}
+class ae {
+  constructor(t) {
+    u(this, "__view");
+    this.__view = t;
+    const e = Object.getOwnPropertyDescriptors(this.__view._logger);
+    for (const r in e)
+      r !== "getName" && 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;
+  }
+  getAll() {
+    const t = [];
+    let e = this.__view._elementContext;
+    for (; t.push(e.data), e.parent; )
+      e = e.parent;
+    const r = {};
+    for (const s of t.reverse())
+      Object.assign(r, s);
+    return r;
+  }
+  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 S("$outlet", { $children: this.__view._$children });
+  }
+}
+var gt;
+gt = k;
+const Y = class Y {
+  constructor(t, e, r, s = []) {
+    u(this, gt, !0);
+    u(this, "uniqueId", Ct());
+    u(this, "_elementContext");
+    u(this, "_logger");
+    u(this, "_view");
+    u(this, "_props");
+    u(this, "_element");
+    u(this, "_childMarkup");
+    u(this, "_$children");
+    u(this, "_setChildren");
+    u(this, "_watcher", H());
+    u(this, "_emitter", new kt());
+    u(this, "isMounted", !1);
+    this._elementContext = { ...t, data: {}, parent: t, viewName: e.name }, this._logger = t.root.createLogger(e.name, { uid: this.uniqueId }), this._view = e, this._props = r, this._childMarkup = s, [this._$children, this._setChildren] = D([]);
+  }
+  /*===============================*\
+  ||         "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, Yt(), requestAnimationFrame(() => {
+      this._emitter.emit("mounted");
+    }));
+  }
+  unmount(t = !1) {
+    this._emitter.emit("beforeUnmount"), this._element && this._element.unmount(t), this.isMounted && Xt(), this.isMounted = !1, this._emitter.emit("unmounted"), this._emitter.clear(), this._watcher.stopAll();
+  }
+  setChildView(t) {
+    this._childMarkup = [];
+    const e = new Y(this._elementContext, t, {});
+    return this._setChildren([e]), e;
+  }
+  /*===============================*\
+  ||           Internal            ||
+  \*===============================*/
+  _initialize() {
+    const t = new ae(this);
+    let e;
+    try {
+      this._childMarkup.length && this._setChildren(x(this._elementContext, this._childMarkup)), e = this._view(this._props, t);
+    } catch (r) {
+      throw r instanceof Error && this._logger.crash(r), r;
+    }
+    if (e !== null) if (e instanceof Node)
+      this._element = T(x(this._elementContext, S("$node", { value: e })));
+    else if (P(e) || vt(P, e))
+      this._element = T(x(this._elementContext, e));
+    else if (m(e))
+      this._element = T(
+        x(this._elementContext, S("$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 F = Y;
+var wt;
+wt = k;
+class he {
+  constructor({ elementContext: t, $items: e, renderFn: r, keyFn: s }) {
+    u(this, wt, !0);
+    u(this, "node", document.createTextNode(""));
+    u(this, "$items");
+    u(this, "stopCallback");
+    u(this, "connectedItems", []);
+    u(this, "elementContext");
+    u(this, "renderFn");
+    u(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 o, 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] = D(a.value), [p, g] = D(a.index);
+        s[a.index] = {
+          key: a.key,
+          $value: l,
+          setValue: d,
+          $index: p,
+          setIndex: g,
+          element: new F(this.elementContext, le, {
+            $value: l,
+            $index: p,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let a = 0; a < s.length; a++) {
+      const f = s[a], l = ((o = s[a - 1]) == null ? void 0 : o.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 le({ $value: n, $index: t, renderFn: e }, r) {
+  return e(n, t, r);
+}
+function P(n) {
+  return (n == null ? void 0 : n[Nt]) === !0;
+}
+function Wt(n) {
+  return (n == null ? void 0 : n[k]) === !0;
+}
+function Z(n) {
+  return A(n) || (n = [n]), n.flat(1 / 0).filter((t) => t != null && t !== !1).map((t) => P(t) ? t : t instanceof Node ? S("$node", { value: t }) : m(t) ? S("$observer", {
+    sources: [t],
+    renderFn: (e) => e
+  }) : S("$text", { value: t }));
+}
+function S(n, t, ...e) {
+  return new fe(n, t, ...e);
+}
+var yt;
+yt = Nt;
+class fe {
+  constructor(t, e, ...r) {
+    u(this, yt, !0);
+    u(this, "type");
+    u(this, "props");
+    u(this, "children");
+    this.type = t, this.props = e, this.children = Z(r);
+  }
+}
+const ke = re.bind(S);
+function xe(n, t, e) {
+  return S("$observer", {
+    sources: [n],
+    renderFn: (r) => r && t ? t : !r && e ? e : null
+  });
+}
+function Ee(n, t, e) {
+  const r = K(n);
+  return S("$repeat", { $items: r, keyFn: t, renderFn: e });
+}
+function be(n, t) {
+  return S("$portal", { parent: n, content: t });
+}
+function x(n, t) {
+  return (A(t) ? t : [t]).map((r) => {
+    if (q(r.type))
+      return new F(n, r.type, r.props, r.children);
+    if (E(r.type))
+      switch (r.type) {
+        case "$node": {
+          const s = r.props;
+          return new ct(s.value);
+        }
+        case "$text": {
+          const s = r.props;
+          return new ct(document.createTextNode(String(s.value)));
+        }
+        case "$repeat": {
+          const s = r.props;
+          return new he({
+            $items: s.$items,
+            keyFn: s.keyFn,
+            renderFn: s.renderFn,
+            elementContext: n
+          });
+        }
+        case "$observer": {
+          const s = r.props;
+          return new ue({
+            sources: s.sources,
+            renderFn: s.renderFn,
+            elementContext: n
+          });
+        }
+        case "$outlet": {
+          const s = r.props;
+          return new $t(s.$children);
+        }
+        case "$portal": {
+          const s = r.props;
+          return new ce({
+            content: s.content,
+            parent: s.parent,
+            elementContext: n
+          });
+        }
+        default:
+          if (r.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${r.type}`);
+          return new ie({
+            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 T(n) {
+  return n.length === 1 ? n[0] : new $t(n);
+}
+function Tt(n) {
+  return n == null || n === !1 || E(n) || Ut(n) || P(n) || m(n) || vt(Tt, n);
+}
+function Ae(n, t) {
+  return t.outlet();
+}
+export {
+  Mt as A,
+  be as B,
+  Ee as C,
+  Ae as P,
+  Ce as S,
+  F as V,
+  D as a,
+  E as b,
+  xe as c,
+  ee as d,
+  _e as e,
+  q as f,
+  ge as g,
+  ke as h,
+  St as i,
+  me as j,
+  pe as k,
+  H as l,
+  Se as m,
+  K as n,
+  Jt as o,
+  m as p,
+  Me as q,
+  ne as r,
+  ye as s,
+  N as t,
+  we as u,
+  S as v,
+  Kt as w,
+  ve as x,
+  T as y,
+  x as z
+};
+//# sourceMappingURL=passthrough-D9NjRov5.js.map