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

package/dist/passthrough-CACEgFx5.js

@@ -0,0 +1,1301 @@
+var St = Object.defineProperty;
+var Mt = (s, t, e) => t in s ? St(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var o = (s, t, e) => Mt(s, typeof t != "symbol" ? t + "" : t, e);
+function ct(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
+}
+var O = { exports: {} }, Y;
+function Et() {
+  return Y || (Y = 1, function(s, t) {
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    var e = /* @__PURE__ */ function() {
+      function l(c, f) {
+        var h = [], d = !0, m = !1, g = void 0;
+        try {
+          for (var M, k = c[Symbol.iterator](); !(d = (M = k.next()).done) && (h.push(M.value), !(f && h.length === f)); d = !0) ;
+        } catch (w) {
+          m = !0, g = w;
+        } finally {
+          try {
+            !d && k.return && k.return();
+          } finally {
+            if (m) throw g;
+          }
+        }
+        return h;
+      }
+      return function(c, f) {
+        if (Array.isArray(c)) return c;
+        if (Symbol.iterator in Object(c)) return l(c, f);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }(), n = function(l) {
+      return l.reduce(function(c, f) {
+        return 16 > f ? c + "0" + f.toString(16) : c + f.toString(16);
+      }, "#");
+    }, r = function(l, c, f) {
+      var h = 0.5 > f ? f * (1 + c) : f + c - f * c, d = 2 * f - h, m = function(w, b, v) {
+        var W = Math.round, y = 0 > v ? v + 1 : 1 < v ? v - 1 : v;
+        return y = y < 1 / 6 ? w + 6 * (b - w) * y : y < 1 / 2 ? b : y < 2 / 3 ? w + 6 * (b - w) * (2 / 3 - y) : w, W(255 * y);
+      }, g = m(d, h, l + 1 / 3), M = m(d, h, l), k = m(d, h, l - 1 / 3);
+      return [g, M, k];
+    }, i = function(l, c, f, h) {
+      var d = l % 1007 / 1007, m = function(w, b, v) {
+        return w * (v - b) + b;
+      }, g = m(d, c.min, c.max), M = m(d, f.min, f.max), k = m(d, h.max, h.min);
+      return [g, M, k];
+    }, u = function(l) {
+      return l.split("").reduce(function(c, f, h) {
+        return c * f.charCodeAt(0) * h + 1;
+      }, 1);
+    }, a = function(l) {
+      var c = l.str, f = l.hue, h = f === void 0 ? { min: 0, max: 360 } : f, d = l.sat, m = d === void 0 ? { min: 0.35, max: 0.65 } : d, g = l.light, M = g === void 0 ? { min: 0.3, max: 0.7 } : g, k = l.hashFunction, w = k === void 0 ? u : k, b = l.scheme, v = b === void 0 ? "hex" : b, W = i(w(c), h, m, M), y = e(W, 3), R = y[0], B = y[1], K = y[2], H = r(R / 360, B, K), Ct = n(H);
+      return v === "hsl" ? [R, B, K] : v === "rgb" ? H : Ct;
+    };
+    t.default = a, s.exports = t.default;
+  }(O, O.exports)), O.exports;
+}
+var xt = Et();
+const At = /* @__PURE__ */ ct(xt);
+function N(s) {
+  const t = typeof s;
+  switch (t) {
+    case "undefined":
+      return t;
+    case "number":
+      return isNaN(s) ? "NaN" : t;
+    case "function":
+      return /^\s*class\s+/.test(s.toString()) ? "class" : t;
+    case "object":
+      return s === null ? "null" : s instanceof Promise ? "promise" : s instanceof Map ? "map" : s instanceof Set ? "set" : Array.isArray(s) ? "array" : t;
+    default:
+      return t;
+  }
+}
+function Jt(s, t) {
+  if (!s)
+    throw new TypeError(
+      q(s, t || "Failed assertion. Value is not truthy. Got type: %t, value: %v")
+    );
+}
+function $(s) {
+  return Array.isArray(s);
+}
+function at(...s) {
+  const t = s[0], e = (n) => $(n) && n.every((r) => t(r));
+  return s.length < 2 ? e : e(s[1]);
+}
+function Qt(...s) {
+  const t = s[0], e = E(s[2]) ? s[2] : "Expected an array of valid items. Got type: %t, value: %v", n = (r) => {
+    if ($(r) && r.every((i) => t(i)))
+      return !0;
+    throw new TypeError(q(r, e));
+  };
+  return s.length < 2 ? n : n(s[1]);
+}
+function E(s) {
+  return typeof s == "string";
+}
+function te(s, t) {
+  if (E(s))
+    return !0;
+  throw new TypeError(q(s, t ?? "Expected a string. Got type: %t, value: %v"));
+}
+function V(s) {
+  return typeof s == "function" && !$t(s);
+}
+function lt(s) {
+  return typeof s == "number" && !isNaN(s);
+}
+function $t(s) {
+  return typeof s == "function" && /^\s*class\s+/.test(s.toString());
+}
+function ee(...s) {
+  const t = s[0], e = E(s[2]) ? s[2] : `Expected instance of ${t.name}. Got type: %t, value: %v`, n = (r) => {
+    if (r instanceof t)
+      return !0;
+    throw new TypeError(q(r, e));
+  };
+  return s.length < 2 ? n : n(s[1]);
+}
+function ht(s) {
+  return s != null && typeof s == "object" && !$(s);
+}
+function q(s, t) {
+  var r;
+  const e = N(s), n = ((r = s == null ? void 0 : s.toString) == null ? void 0 : r.call(s)) || String(s);
+  return t.replaceAll("%t", e).replaceAll("%v", n);
+}
+var F, Z;
+function Nt() {
+  return Z || (Z = 1, F = function s(t, e) {
+    if (t === e) return !0;
+    if (t && e && typeof t == "object" && typeof e == "object") {
+      if (t.constructor !== e.constructor) return !1;
+      var n, r, i;
+      if (Array.isArray(t)) {
+        if (n = t.length, n != e.length) return !1;
+        for (r = n; r-- !== 0; )
+          if (!s(t[r], e[r])) return !1;
+        return !0;
+      }
+      if (t instanceof Map && e instanceof Map) {
+        if (t.size !== e.size) return !1;
+        for (r of t.entries())
+          if (!e.has(r[0])) return !1;
+        for (r of t.entries())
+          if (!s(r[1], e.get(r[0]))) return !1;
+        return !0;
+      }
+      if (t instanceof Set && e instanceof Set) {
+        if (t.size !== e.size) return !1;
+        for (r of t.entries())
+          if (!e.has(r[0])) return !1;
+        return !0;
+      }
+      if (ArrayBuffer.isView(t) && ArrayBuffer.isView(e)) {
+        if (n = t.length, n != e.length) return !1;
+        for (r = n; r-- !== 0; )
+          if (t[r] !== e[r]) return !1;
+        return !0;
+      }
+      if (t.constructor === RegExp) return t.source === e.source && t.flags === e.flags;
+      if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === e.valueOf();
+      if (t.toString !== Object.prototype.toString) return t.toString() === e.toString();
+      if (i = Object.keys(t), n = i.length, n !== Object.keys(e).length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(e, i[r])) return !1;
+      for (r = n; r-- !== 0; ) {
+        var u = i[r];
+        if (!s(t[u], e[u])) return !1;
+      }
+      return !0;
+    }
+    return t !== t && e !== e;
+  }), F;
+}
+var Ot = Nt();
+const Vt = /* @__PURE__ */ ct(Ot), Tt = () => {
+};
+let U = 1;
+function ft() {
+  return U = U % Number.MAX_SAFE_INTEGER + 1, U.toString(36) + Date.now().toString(36);
+}
+function dt(s, t) {
+  return s === t;
+}
+function ne(s, t) {
+  if (s === t) return !0;
+  const e = N(s);
+  if (e !== N(t))
+    return !1;
+  switch (e) {
+    case "object":
+      let n = 0;
+      for (const r in s) {
+        if (s[r] !== t[r]) return !1;
+        n++;
+      }
+      return Object.keys(t).length === n;
+    case "array":
+      if (s.length !== t.length) return !1;
+      for (let r = 0; r < s.length; r++)
+        if (s[r] !== t[r]) return !1;
+      return !0;
+    case "map":
+      if (s.size !== t.size) return !1;
+      for (const r of s.keys())
+        if (s[r] !== t[r]) return !1;
+      return !0;
+    case "set":
+      if (V(s.symmetricDifference))
+        return s.symmetricDifference(t).size === 0;
+      for (const r of s.keys())
+        if (s[r] !== t.get(r)) return !1;
+      return !0;
+  }
+  return !1;
+}
+const se = Vt;
+function Pt(s, t) {
+  const e = (n) => {
+    const r = {};
+    for (const i in n)
+      s.includes(i) || (r[i] = n[i]);
+    return r;
+  };
+  return t == null ? e : e(t);
+}
+function qt(s) {
+  return At({
+    str: s,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function re(s) {
+  if (s instanceof RegExp)
+    return (n) => s.test(n);
+  const t = {
+    positive: [],
+    negative: []
+  }, e = s.split(",").map((n) => n.trim()).filter((n) => n !== "");
+  for (let n of e) {
+    let r = "positive";
+    n.startsWith("-") && (r = "negative", n = n.slice(1)), n === "*" ? t[r].push(function() {
+      return !0;
+    }) : n.endsWith("*") ? t[r].push(function(i) {
+      return i.startsWith(n.slice(0, n.length - 1));
+    }) : t[r].push(function(i) {
+      return i === n;
+    });
+  }
+  return function(n) {
+    const { positive: r, negative: i } = t;
+    return !(i.some((u) => u(n)) || r.length > 0 && !r.some((u) => u(n)));
+  };
+}
+const pt = Symbol.for("DollaState"), mt = Symbol.for("DollaRef"), gt = Symbol.for("DollaMarkup"), S = Symbol.for("DollaMarkupElement"), T = {
+  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:${qt(this._label)};font-weight:bold`,
+        "color:#777",
+        "color:#aaa",
+        "color:#777",
+        { watcherCount: this.watcherCount }
+      ), this._timeout = null;
+    }, 200));
+  }
+};
+function p(s) {
+  return (s == null ? void 0 : s[pt]) === !0;
+}
+function Wt(s) {
+  return (s == null ? void 0 : s[mt]) === !0;
+}
+function Ft(s) {
+  return p(s) ? s.get() : s;
+}
+function j(s) {
+  return p(s) ? s : new L({
+    get() {
+      return s;
+    },
+    watch(t, e = {}) {
+      return e != null && e.lazy || t(s), Tt;
+    }
+  });
+}
+class Ut {
+  constructor(t, e) {
+    o(this, "value");
+    o(this, "watchers", []);
+    o(this, "equals", dt);
+    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), T.increment(), () => {
+      const n = this.watchers.indexOf(t);
+      n > -1 && this.watchers.splice(n, 1), T.decrement();
+    };
+  }
+}
+var Q;
+Q = pt;
+class L {
+  constructor(t) {
+    // Instances will pass isState() with this symbol
+    o(this, Q, !0);
+    o(this, "__value");
+    this.__value = t;
+  }
+  get() {
+    return this.__value.get();
+  }
+  watch(t, e) {
+    return this.__value.watch(t, e);
+  }
+}
+function I(s, t) {
+  const e = new Ut(s, t);
+  return [new L(e), (r) => e.set(r)];
+}
+const X = Symbol("EMPTY");
+class It {
+  constructor(t, e, n) {
+    o(this, "equals", dt);
+    /**
+     * Array of states this holder's value is derived from.
+     */
+    o(this, "sources", []);
+    /**
+     * The function that does the deriving. Receives source values and returns a derived value.
+     */
+    o(this, "fn");
+    /**
+     *
+     */
+    o(this, "sourceWatcher", D());
+    /**
+     * Array of functions awaiting notification when this holder's value changes.
+     */
+    o(this, "watchers", []);
+    /**
+     * True when this holder is actively watching sources.
+     */
+    o(this, "isWatchingSources", !1);
+    /**
+     * Latest values as received from sources.
+     */
+    o(this, "previousSourceValues");
+    /**
+     * The current value as returned from `fn` (may be a State)
+     */
+    o(this, "value", X);
+    /**
+     * The current unwrapped value.
+     */
+    o(this, "rawValue");
+    /**
+     * When value is a State, this function will stop watching its value.
+     */
+    o(this, "stopWatchingCurrentValue");
+    this.sources = t.map(j), this.fn = e, n != null && n.equals && (this.equals = n.equals), this.previousSourceValues = new Array(t.length).fill(X, 0, t.length);
+  }
+  /*==========================*\
+  ||     "Public" methods     ||
+  \*==========================*/
+  get() {
+    return this.getValue();
+  }
+  watch(t, e) {
+    this.isWatchingSources || this.startWatchingSources();
+    const n = this.watchers;
+    return n.push(t), e != null && e.lazy || t(this.rawValue), T.increment(), () => {
+      n.splice(n.indexOf(t), 1), this.isWatchingSources && n.length === 0 && this.stopWatchingSources(), T.decrement();
+    };
+  }
+  /*==========================*\
+  ||         Internal         ||
+  \*==========================*/
+  notify(t) {
+    for (const e of this.watchers)
+      e(t);
+  }
+  update() {
+    const t = this.sources, e = this.previousSourceValues;
+    let n = !1, r;
+    for (let i = 0; i < t.length; i++)
+      r = t[i].get(), !n && !this.equals(r, e[i]) && (n = !0), e[i] = r;
+    n && this.setValue(this.fn(...e));
+  }
+  getValue() {
+    return this.isWatchingSources || this.update(), this.rawValue;
+  }
+  setValue(t) {
+    this.stopWatchingCurrentValue && (this.stopWatchingCurrentValue(), this.stopWatchingCurrentValue = void 0), this.value = t, this.rawValue = Ft(t), this.isWatchingSources && p(t) ? this.stopWatchingCurrentValue = t.watch((e) => {
+      this.rawValue = e, this.notify(e);
+    }) : this.notify(this.rawValue);
+  }
+  startWatchingSources() {
+    const t = this.previousSourceValues;
+    for (let n = 0; n < this.sources.length; n++)
+      this.sourceWatcher.watch([this.sources[n]], (r) => {
+        if (t[n] = r, 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 jt(s, t, e) {
+  const n = new It(s, t, e);
+  return new L(n);
+}
+function ie(s) {
+  const t = function() {
+    if (arguments.length === 1)
+      s = arguments[0];
+    else if (arguments.length > 1)
+      throw new Error(`Too many arguments. Expected 0 or 1. Got: ${arguments.length}`);
+    return s;
+  };
+  return t[mt] = !0, t;
+}
+function D() {
+  const s = [];
+  return {
+    watch(t, e) {
+      if (t.length === 0)
+        throw new TypeError("Expected at least one state to watch.");
+      t = t.map(j);
+      let n;
+      return t.length > 1 ? n = jt(t, e).watch(() => null) : n = t[0].watch(e), s.push(n), () => {
+        let r = s.indexOf(n);
+        r > -1 && s.splice(r, 1), n();
+      };
+    },
+    stopAll() {
+      for (; s.length > 0; )
+        s.pop()();
+    }
+  };
+}
+function Lt(s) {
+  for (var t, e, n = arguments, r = 1, i = "", u = "", a = [0], l = function(h) {
+    r === 1 && (h || (i = i.replace(/^\s*\n\s*|\s*\n\s*$/g, ""))) ? a.push(h ? n[h] : i) : r === 3 && (h || i) ? (a[1] = h ? n[h] : i, r = 2) : r === 2 && i === "..." && h ? a[2] = Object.assign(a[2] || {}, n[h]) : r === 2 && i && !h ? (a[2] = a[2] || {})[i] = !0 : r >= 5 && (r === 5 ? ((a[2] = a[2] || {})[e] = h ? i ? i + n[h] : n[h] : i, r = 6) : (h || i) && (a[2][e] += h ? i + n[h] : i)), i = "";
+  }, c = 0; c < s.length; c++) {
+    c && (r === 1 && l(), l(c));
+    for (var f = 0; f < s[c].length; f++) t = s[c][f], r === 1 ? t === "<" ? (l(), a = [a, "", null], r = 3) : i += t : r === 4 ? i === "--" && t === ">" ? (r = 1, i = "") : i = t + i[0] : u ? t === u ? u = "" : i += t : t === '"' || t === "'" ? u = t : t === ">" ? (l(), r = 1) : r && (t === "=" ? (r = 5, e = i, i = "") : t === "/" && (r < 5 || s[c][f + 1] === ">") ? (l(), r === 3 && (a = a[0]), r = a, (a = a[0]).push(this.apply(null, r.slice(1))), r = 0) : t === " " || t === "	" || t === `
+` || t === "\r" ? (l(), r = 2) : i += t), r === 3 && i === "!--" && (r = 4, a = a[0]);
+  }
+  return l(), a.length > 2 ? a.slice(1) : a[1];
+}
+const Dt = (s) => /^on[A-Z]/.test(s);
+var tt;
+tt = S;
+class Gt {
+  constructor({ tag: t, props: e, children: n, elementContext: r }) {
+    o(this, tt, !0);
+    o(this, "node");
+    o(this, "props");
+    o(this, "children");
+    o(this, "stopCallbacks", []);
+    o(this, "elementContext");
+    o(this, "uniqueId", ft());
+    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 (r = { ...r }, this._batchWrite = r.root.batch.write.bind(r.root.batch), 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), e.ref)
+      if (Wt(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 = {
+      ...Pt(["ref", "class", "className"], e),
+      class: e.className ?? e.class
+    }, this.children = n ? C(r, n) : [], this.elementContext = r;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    if (t == null)
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${t}`);
+    if (!this.isMounted) {
+      for (let n = 0; n < this.children.length; n++) {
+        const r = this.children[n], i = n > 0 ? this.children[n - 1].node : void 0;
+        r.mount(this.node, i);
+      }
+      this.applyProps(this.node, this.props), this.props.style && this.applyStyles(this.node, this.props.style, this.stopCallbacks), this.props.class && this.applyClasses(this.node, this.props.class, this.stopCallbacks);
+    }
+    t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), setTimeout(() => {
+      this.canClickAway = !0;
+    }, 0);
+  }
+  unmount(t = !1) {
+    var e;
+    if (this.isMounted) {
+      for (const n of this.children)
+        n.unmount(!0);
+      t || (e = this.node.parentNode) == null || e.removeChild(this.node), this.ref && this.ref(void 0), this.canClickAway = !1;
+      for (const n of this.stopCallbacks)
+        n();
+      this.stopCallbacks = [];
+    }
+  }
+  getUpdateKey(t, e) {
+    return `${this.uniqueId}:${t}:${e}`;
+  }
+  _mutate(t, e) {
+    this.isMounted ? this._batchWrite(t, e) : t();
+  }
+  attachProp(t, e, n) {
+    p(t) ? this.stopCallbacks.push(
+      t.watch((r) => {
+        this._mutate(() => e(r), n);
+      })
+    ) : this._mutate(() => e(t), n);
+  }
+  applyProps(t, e) {
+    for (const n in e) {
+      const r = e[n];
+      if (n === "attributes") {
+        const i = r;
+        for (const u in i)
+          this.attachProp(
+            i[u],
+            (a) => {
+              a == null ? t.removeAttribute(u) : t.setAttribute(u, String(a));
+            },
+            this.getUpdateKey("attr", u)
+          );
+      } else if (n === "eventListeners") {
+        const i = r;
+        for (const u in i) {
+          const a = p(r) ? (l) => r.get()(l) : r;
+          t.addEventListener(u, a), this.stopCallbacks.push(() => {
+            t.removeEventListener(u, a);
+          });
+        }
+      } else if (n === "onClickOutside" || n === "onclickoutside") {
+        const i = (a) => {
+          this.canClickAway && !t.contains(a.target) && (p(r) ? r.get()(a) : r(a));
+        }, u = { capture: !0 };
+        window.addEventListener("click", i, u), this.stopCallbacks.push(() => {
+          window.removeEventListener("click", i, u);
+        });
+      } else if (Dt(n)) {
+        const i = n.slice(2).toLowerCase(), u = p(r) ? (a) => r.get()(a) : r;
+        t.addEventListener(i, u), this.stopCallbacks.push(() => {
+          t.removeEventListener(i, u);
+        });
+      } else if (n.includes("-"))
+        this.attachProp(
+          r,
+          (i) => {
+            i == null ? t.removeAttribute(n) : t.setAttribute(n, String(i));
+          },
+          this.getUpdateKey("attr", n)
+        );
+      else if (!zt.includes(n))
+        if (this.elementContext.isSVG)
+          this.attachProp(
+            r,
+            (i) => {
+              i != null ? t.setAttribute(n, String(e[n])) : t.removeAttribute(n);
+            },
+            this.getUpdateKey("attr", n)
+          );
+        else
+          switch (n) {
+            case "contentEditable":
+            case "value":
+              this.attachProp(
+                r,
+                (i) => {
+                  t[n] = String(i);
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            case "for":
+              this.attachProp(
+                r,
+                (i) => {
+                  t.htmlFor = i;
+                },
+                this.getUpdateKey("prop", "htmlFor")
+              );
+              break;
+            case "checked":
+              this.attachProp(
+                r,
+                (i) => {
+                  t.checked = i, i ? t.setAttribute("checked", "") : t.removeAttribute("checked");
+                },
+                this.getUpdateKey("prop", "checked")
+              );
+              break;
+            // Attribute-aliased props
+            case "exportParts":
+            case "part":
+            case "translate":
+            case "type":
+            case "title": {
+              const i = n.toLowerCase();
+              this.attachProp(
+                r,
+                (u) => {
+                  u == null ? t.removeAttribute(i) : t.setAttribute(i, String(u));
+                },
+                this.getUpdateKey("attr", i)
+              );
+              break;
+            }
+            case "autocomplete":
+            case "autocapitalize":
+              this.attachProp(
+                r,
+                (i) => {
+                  typeof i == "string" ? t.autocomplete = i : i ? t.autocomplete = "on" : t.autocomplete = "off";
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            default: {
+              this.attachProp(
+                r,
+                (i) => {
+                  t[n] = i;
+                },
+                this.getUpdateKey("prop", n)
+              );
+              break;
+            }
+          }
+    }
+  }
+  applyStyles(t, e, n) {
+    const r = [];
+    if (p(e)) {
+      let i;
+      const u = e.watch((a) => {
+        this._mutate(
+          () => {
+            V(i) && i(), t.style.cssText = "", i = this.applyStyles(t, a, n);
+          },
+          this.getUpdateKey("styles", "*")
+        );
+      });
+      n.push(u), r.push(u);
+    } else {
+      const i = yt(e);
+      for (const u in i) {
+        const { value: a, priority: l } = i[u];
+        if (p(a)) {
+          const c = a.watch((f) => {
+            this._mutate(() => {
+              f ? t.style.setProperty(u, String(f), l) : t.style.removeProperty(u);
+            });
+          });
+          n.push(c), r.push(c);
+        } else a != null && t.style.setProperty(u, String(a));
+      }
+    }
+    return function() {
+      for (const u of r)
+        u(), n.splice(n.indexOf(u), 1);
+    };
+  }
+  applyClasses(t, e, n) {
+    const r = [];
+    if (p(e)) {
+      let i;
+      const u = e.watch((a) => {
+        this._mutate(
+          () => {
+            V(i) && i(), t.removeAttribute("class"), i = this.applyClasses(t, a, n);
+          },
+          this.getUpdateKey("attr", "class")
+        );
+      });
+      n.push(u), r.push(u);
+    } else {
+      const i = wt(e);
+      for (const u in i) {
+        const a = i[u];
+        if (p(a)) {
+          const l = a.watch((c) => {
+            this._mutate(() => {
+              c ? t.classList.add(u) : t.classList.remove(u);
+            });
+          });
+          n.push(l), r.push(l);
+        } else a && t.classList.add(u);
+      }
+    }
+    return function() {
+      for (const u of r)
+        u(), n.splice(n.indexOf(u), 1);
+    };
+  }
+}
+function wt(s) {
+  let t = {};
+  if (E(s)) {
+    const e = s.split(" ");
+    for (const n of e)
+      t[n] = !0;
+  } else ht(s) ? Object.assign(t, s) : Array.isArray(s) && Array.from(s).filter(Boolean).forEach((e) => {
+    Object.assign(t, wt(e));
+  });
+  return delete t.undefined, t;
+}
+function yt(s) {
+  let t = {};
+  if (E(s)) {
+    const e = s.split(";").filter((n) => n.trim() !== "");
+    for (const n of e) {
+      const [r, i] = n.split(":"), u = {
+        value: i
+      };
+      i.includes("!important") ? (u.priority = "important", u.value = i.replace("!important", "").trim()) : u.value = i.trim(), t[J(r.trim())] = u;
+    }
+  }
+  if (ht(s))
+    for (const e in s)
+      e.startsWith("--") ? t[e] = { value: s[e] } : t[J(e)] = { value: s[e] };
+  else Array.isArray(s) && Array.from(s).filter((e) => e != null).forEach((e) => {
+    Object.assign(t, yt(e));
+  });
+  return t;
+}
+function J(s) {
+  return s.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, e) => (e ? "-" : "") + t.toLowerCase());
+}
+const zt = ["ref", "children", "class", "style", "data"];
+var et;
+et = S;
+class Rt {
+  constructor({ sources: t, renderFn: e, elementContext: n }) {
+    o(this, et, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "children", []);
+    o(this, "renderFn");
+    o(this, "elementContext");
+    o(this, "watcher", D());
+    o(this, "sources");
+    this.elementContext = n, this.renderFn = e, this.sources = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  mount(t, e) {
+    this.isMounted || (t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null), this.watcher.watch(this.sources, (...n) => {
+      const r = this.renderFn(...n);
+      if (!bt(r))
+        throw console.error(r, n), new TypeError(
+          `Observer received invalid value to render. Got type: ${N(r)}, value: ${r}`
+        );
+      this.update($(r) ? r : [r]);
+    }));
+  }
+  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, a;
+    if (this.cleanup(!1), t == null || t.length === 0 || !this.isMounted)
+      return;
+    const e = t.map((l) => kt(l) ? l : A(l) ? x(C(this.elementContext, l)) : x(C(this.elementContext, G(l))));
+    for (const l of e) {
+      const c = ((i = this.children.at(-1)) == null ? void 0 : i.node) || this.node;
+      l.mount(this.node.parentNode, c), this.children.push(l);
+    }
+    const n = this.node.parentNode, r = ((a = (u = this.children.at(-1)) == null ? void 0 : u.node) == null ? void 0 : a.nextSibling) ?? null;
+    n.insertBefore(this.node, r);
+  }
+}
+var nt;
+nt = S;
+class _t {
+  constructor(t) {
+    o(this, nt, !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), p(this.source) ? this.stopCallback = this.source.watch((n) => {
+      this.update(n);
+    }) : this.update(this.elements));
+  }
+  unmount(t = !1) {
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), this.isMounted && (this.cleanup(t), this.isMounted = !1);
+  }
+  cleanup(t) {
+    for (const e of this.elements)
+      e.unmount(t);
+    this.elements = [];
+  }
+  update(t) {
+    var e, n;
+    if (this.cleanup(!1), t.length > 0) {
+      for (let r = 0; r < t.length; r++) {
+        const i = t[r], u = r > 0 ? this.elements[r - 1] : void 0;
+        i.mount(this.node.parentElement, u == null ? void 0 : u.node), this.elements.push(i);
+      }
+      (n = this.node.parentNode) == null || n.insertBefore(this.node, ((e = this.elements.at(-1)) == null ? void 0 : e.node) ?? null);
+    }
+  }
+}
+var st;
+st = S;
+class Bt {
+  constructor(t) {
+    o(this, st, !0);
+    o(this, "config");
+    o(this, "element");
+    this.config = t;
+  }
+  get isMounted() {
+    return this.element ? this.element.isMounted : !1;
+  }
+  mount(t, e) {
+    const { content: n, parent: r } = this.config;
+    kt(n) ? this.element = n : A(n) ? this.element = x(C(this.config.elementContext, n)) : this.element = x(C(this.config.elementContext, G(n))), this.element.mount(r);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.element) != null && e.isMounted && this.element.unmount(t);
+  }
+}
+class Kt {
+  constructor(t) {
+    o(this, "__view");
+    this.__view = t;
+    const e = Object.getOwnPropertyDescriptors(this.__view._logger);
+    for (const n in e)
+      n !== "getName" && Object.defineProperty(this, n, e[n]);
+  }
+  get uid() {
+    return this.__view.uniqueId;
+  }
+  setName(t) {
+    return this.__view._logger.setName(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 n = {};
+    for (const r of t.reverse())
+      Object.assign(n, r);
+    return n;
+  }
+  beforeMount(t) {
+    this.__view._beforeMountCallbacks.push(t);
+  }
+  onMount(t) {
+    this.__view._onMountCallbacks.push(t);
+  }
+  beforeUnmount(t) {
+    this.__view._beforeUnmountCallbacks.push(t);
+  }
+  onUnmount(t) {
+    this.__view._onUnmountCallbacks.push(t);
+  }
+  watch(t, e) {
+    const n = this.__view;
+    if (n.isMounted)
+      return n._watcher.watch(t, e);
+    {
+      let r, i = !1;
+      return n._onMountCallbacks.push(() => {
+        i || (r = n._watcher.watch(t, e));
+      }), () => {
+        r != null && (i = !0, r());
+      };
+    }
+  }
+  outlet() {
+    return _("$outlet", { $children: this.__view._$children });
+  }
+}
+var rt;
+rt = S;
+const z = class z {
+  constructor(t, e, n, r = []) {
+    o(this, rt, !0);
+    o(this, "uniqueId", ft());
+    o(this, "_elementContext");
+    o(this, "_logger");
+    o(this, "_view");
+    o(this, "_props");
+    o(this, "_element");
+    o(this, "_childMarkup");
+    o(this, "_$children");
+    o(this, "_setChildren");
+    o(this, "_watcher", D());
+    o(this, "_beforeMountCallbacks", []);
+    o(this, "_onMountCallbacks", []);
+    o(this, "_beforeUnmountCallbacks", []);
+    o(this, "_onUnmountCallbacks", []);
+    o(this, "isMounted", !1);
+    this._elementContext = { ...t, data: {}, parent: t }, this._logger = t.root.createLogger(e.name, { uid: this.uniqueId }), this._view = e, this._props = n, this._childMarkup = r, [this._$children, this._setChildren] = I([]);
+  }
+  /*===============================*\
+  ||         "Public" API          ||
+  \*===============================*/
+  get node() {
+    var t;
+    return (t = this._element) == null ? void 0 : t.node;
+  }
+  mount(t, e) {
+    const n = this.isMounted;
+    if (!n)
+      for (this.initialize(); this._beforeMountCallbacks.length > 0; )
+        this._beforeMountCallbacks.shift()();
+    this._element && this._element.mount(t, e), n || (this.isMounted = !0, requestAnimationFrame(() => {
+      for (; this._onMountCallbacks.length > 0; )
+        this._onMountCallbacks.shift()();
+    }));
+  }
+  unmount(t = !1) {
+    for (; this._beforeUnmountCallbacks.length > 0; )
+      this._beforeUnmountCallbacks.shift()();
+    for (this._element && this._element.unmount(t), this.isMounted = !1; this._onUnmountCallbacks.length > 0; )
+      this._onUnmountCallbacks.shift()();
+    this._watcher.stopAll();
+  }
+  setChildView(t) {
+    this._childMarkup = [];
+    const e = new z(this._elementContext, t, {});
+    return this._setChildren([e]), e;
+  }
+  /*===============================*\
+  ||           Internal            ||
+  \*===============================*/
+  initialize() {
+    const t = new Kt(this);
+    let e;
+    try {
+      this._childMarkup.length && this._setChildren(C(this._elementContext, this._childMarkup)), e = this._view(this._props, t);
+    } catch (n) {
+      throw n instanceof Error && this._logger.crash(n), n;
+    }
+    if (e !== null) if (e instanceof Node)
+      this._element = x(C(this._elementContext, _("$node", { value: e })));
+    else if (A(e) || at(A, e))
+      this._element = x(C(this._elementContext, e));
+    else if (p(e))
+      this._element = x(
+        C(this._elementContext, _("$observer", { sources: [e], renderFn: (n) => n }))
+      );
+    else {
+      const n = new TypeError(
+        `Expected '${this._view.name}' function to return a DOM node, Markup element, Readable or null. Got: ${N(e)}`
+      );
+      this._logger.crash(n);
+    }
+  }
+};
+let P = z;
+var it;
+it = S;
+class Ht {
+  constructor({ elementContext: t, $items: e, renderFn: n, keyFn: r }) {
+    o(this, it, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "$items");
+    o(this, "stopCallback");
+    o(this, "connectedItems", []);
+    o(this, "elementContext");
+    o(this, "renderFn");
+    o(this, "keyFn");
+    this.elementContext = t, this.$items = e, this.renderFn = n, this.keyFn = 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.stopCallback = this.$items.watch((n) => {
+      this._update(Array.from(n));
+    }));
+  }
+  unmount(t = !1) {
+    var e;
+    this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), !t && this.isMounted && ((e = this.node.parentNode) == null || e.removeChild(this.node)), this._cleanup(t);
+  }
+  _cleanup(t) {
+    for (const e of this.connectedItems)
+      e.element.unmount(t);
+    this.connectedItems = [];
+  }
+  _update(t) {
+    var u, a, l;
+    if (t.length === 0 || !this.isMounted)
+      return this._cleanup(!1);
+    const e = [];
+    let n = 0;
+    for (const c of t)
+      e.push({
+        key: this.keyFn(c, n),
+        value: c,
+        index: n++
+      });
+    const r = [];
+    for (const c of this.connectedItems)
+      e.find((h) => h.key === c.key) || c.element.unmount(!1);
+    for (const c of e) {
+      const f = this.connectedItems.find((h) => h.key === c.key);
+      if (f)
+        f.setValue(c.value), f.setIndex(c.index), r[c.index] = f;
+      else {
+        const [h, d] = I(c.value), [m, g] = I(c.index);
+        r[c.index] = {
+          key: c.key,
+          $value: h,
+          setValue: d,
+          $index: m,
+          setIndex: g,
+          element: new P(this.elementContext, Yt, {
+            $value: h,
+            $index: m,
+            renderFn: this.renderFn
+          })
+        };
+      }
+    }
+    for (let c = 0; c < r.length; c++) {
+      const f = r[c], h = ((u = r[c - 1]) == null ? void 0 : u.element.node) ?? this.node;
+      f.element.mount(this.node.parentNode, h);
+    }
+    this.connectedItems = r;
+    const i = ((a = r.at(-1)) == null ? void 0 : a.element.node) ?? this.node;
+    (l = this.node.parentNode) == null || l.insertBefore(this.node, i.nextSibling);
+  }
+}
+function Yt({ $value: s, $index: t, renderFn: e }, n) {
+  return e(s, t, n);
+}
+var ot;
+ot = S;
+class Zt {
+  constructor({ value: t }) {
+    o(this, ot, !0);
+    o(this, "node", document.createTextNode(""));
+    o(this, "value", "");
+    o(this, "stopCallback");
+    this.value = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  async mount(t, e = null) {
+    this.isMounted || (p(this.value) ? this.stopCallback = this.value.watch((n) => {
+      this.update(n);
+    }) : this.update(this.value)), t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null);
+  }
+  async unmount(t = !1) {
+    this.isMounted && (this.stopCallback && (this.stopCallback(), this.stopCallback = void 0), t || this.node.parentNode.removeChild(this.node));
+  }
+  update(t) {
+    t != null ? this.node.textContent = t.toString() : this.node.textContent = "";
+  }
+}
+function A(s) {
+  return (s == null ? void 0 : s[gt]) === !0;
+}
+function kt(s) {
+  return (s == null ? void 0 : s[S]) === !0;
+}
+function G(s) {
+  return $(s) || (s = [s]), s.flat(1 / 0).filter((t) => t != null && t !== !1).map((t) => {
+    if (t instanceof Node)
+      return _("$node", { value: t });
+    if (t instanceof vt)
+      return _("$node", { value: t.node });
+    if (A(t))
+      return t;
+    if (E(t) || lt(t))
+      return _("$text", { value: t });
+    if (p(t))
+      return _("$observer", {
+        sources: [t],
+        renderFn: (e) => e
+      });
+    throw console.error(t), new TypeError(`Unexpected child type. Got: ${t}`);
+  });
+}
+function _(s, t, ...e) {
+  return {
+    [gt]: !0,
+    type: s,
+    props: t,
+    children: G(e)
+  };
+}
+const oe = Lt.bind(_);
+function ue(s, t, e) {
+  return _("$observer", {
+    sources: [s],
+    renderFn: (n) => n && t ? t : !n && e ? e : null
+  });
+}
+function ce(s, t, e) {
+  const n = j(s);
+  return _("$repeat", { $items: n, keyFn: t, renderFn: e });
+}
+function ae(s, t) {
+  return _("$portal", { parent: s, content: t });
+}
+var ut;
+ut = S;
+class vt {
+  constructor(t) {
+    o(this, ut, !0);
+    o(this, "node");
+    this.node = t;
+  }
+  get isMounted() {
+    return this.node.parentNode != null;
+  }
+  async mount(t, e) {
+    t.insertBefore(this.node, (e == null ? void 0 : e.nextSibling) ?? null);
+  }
+  async unmount() {
+    this.node.parentNode && this.node.parentNode.removeChild(this.node);
+  }
+}
+function C(s, t) {
+  return ($(t) ? t : [t]).map((n) => {
+    if (V(n.type))
+      return new P(s, n.type, n.props, n.children);
+    if (E(n.type))
+      switch (n.type) {
+        case "$node": {
+          const r = n.props;
+          return new vt(r.value);
+        }
+        case "$text": {
+          const r = n.props;
+          return new Zt({
+            value: r.value
+          });
+        }
+        // case "$cond": {
+        //   const attrs = item.props! as MarkupAttributes["$cond"];
+        //   return new Conditional({
+        //     $predicate: attrs.$predicate,
+        //     thenContent: attrs.thenContent,
+        //     elseContent: attrs.elseContent,
+        //     elementContext,
+        //   });
+        // }
+        case "$repeat": {
+          const r = n.props;
+          return new Ht({
+            $items: r.$items,
+            keyFn: r.keyFn,
+            renderFn: r.renderFn,
+            elementContext: s
+          });
+        }
+        case "$observer": {
+          const r = n.props;
+          return new Rt({
+            sources: r.sources,
+            renderFn: r.renderFn,
+            elementContext: s
+          });
+        }
+        case "$outlet": {
+          const r = n.props;
+          return new _t(r.$children);
+        }
+        case "$portal": {
+          const r = n.props;
+          return new Bt({
+            content: r.content,
+            parent: r.parent,
+            elementContext: s
+          });
+        }
+        default:
+          if (n.type.startsWith("$"))
+            throw new Error(`Unknown markup type: ${n.type}`);
+          return new Gt({
+            tag: n.type,
+            props: n.props ?? {},
+            children: n.children,
+            elementContext: s
+          });
+      }
+    else
+      throw new TypeError(`Expected a string or view function. Got: ${n.type}`);
+  });
+}
+function x(s) {
+  return s.length === 1 ? s[0] : new _t(s);
+}
+function bt(s) {
+  return s == null || s === !1 || E(s) || lt(s) || A(s) || p(s) || at(bt, s);
+}
+function le(s, t) {
+  return t.outlet();
+}
+export {
+  dt as A,
+  ae as B,
+  ce as C,
+  le as P,
+  P as V,
+  I as a,
+  E as b,
+  ue as c,
+  jt as d,
+  se as e,
+  V as f,
+  te as g,
+  oe as h,
+  ht as i,
+  Qt as j,
+  Jt as k,
+  D as l,
+  re as m,
+  j as n,
+  Ft as o,
+  p,
+  ie as q,
+  Wt as r,
+  ne as s,
+  N as t,
+  ee as u,
+  _ as v,
+  Tt as w,
+  qt as x,
+  x as y,
+  C as z
+};
+//# sourceMappingURL=passthrough-CACEgFx5.js.map