@manyducks.co/dolla 2.0.0-alpha.6 → 2.0.0-alpha.61

package/dist/markup-CX27GJ1M.js

@@ -0,0 +1,1030 @@
+var it = Object.defineProperty;
+var B = (i) => {
+  throw TypeError(i);
+};
+var nt = (i, o, t) => o in i ? it(i, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[o] = t;
+var a = (i, o, t) => nt(i, typeof o != "symbol" ? o + "" : o, t), V = (i, o, t) => o.has(i) || B("Cannot " + t);
+var O = (i, o, t) => (V(i, o, "read from private field"), t ? t.call(i) : o.get(i)), j = (i, o, t) => o.has(i) ? B("Cannot add the same private member more than once") : o instanceof WeakSet ? o.add(i) : o.set(i, t), T = (i, o, t, e) => (V(i, o, "write to private field"), e ? e.call(i, t) : o.set(i, t), t);
+import { c as m, t as rt, i as C, b as D } from "./typeChecking-CbltMOUt.js";
+import { u as I, g as x, f as Y, h as M, e as v, t as J, o as ct, i as at, b as ht, $ as _, d as ut } from "./signals-gCwiIe5X.js";
+import { c as lt, g as dt } from "./logger-Bl496yfY.js";
+var g = /* @__PURE__ */ ((i) => (i[i.WILL_MOUNT = 0] = "WILL_MOUNT", i[i.DID_MOUNT = 1] = "DID_MOUNT", i[i.WILL_UNMOUNT = 2] = "WILL_UNMOUNT", i[i.DID_UNMOUNT = 3] = "DID_UNMOUNT", i[i.DISPOSE = 4] = "DISPOSE", i))(g || {});
+const U = Symbol("name"), d = Symbol("lifecycle"), b = Symbol("parent"), y = Symbol("stores"), w = Symbol("state");
+class ft {
+  constructor(o) {
+    a(this, "context");
+    a(this, "state", 0);
+    a(this, "listeners", /* @__PURE__ */ new Map());
+    a(this, "bound");
+    this.context = o;
+  }
+  /**
+   * Listen for a certain event to be emitted. Listeners are called when the event results in a state change.
+   */
+  on(o, t) {
+    const e = this.listeners.get(o);
+    e ? e.add(t) : this.listeners.set(o, /* @__PURE__ */ new Set([t]));
+  }
+  /**
+   * Stop a particular listener from being called when an event is emitted.
+   */
+  off(o, t) {
+    const e = this.listeners.get(o);
+    e && (e.delete(t), e.size === 0 && this.listeners.delete(o));
+  }
+  /**
+   * Advance the lifecycle state machine.
+   */
+  emit(o) {
+    switch (o) {
+      case 0: {
+        this.state < 1 ? (this.state = 1, this.notify(o)) : this.context.crash(new Error(`Tried to WILL_MOUNT context at state ${this.state}`));
+        break;
+      }
+      case 1: {
+        this.state >= 1 && this.state < 2 ? (this.state = 2, this.notify(o)) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 2: {
+        this.state >= 2 && this.state < 3 ? (this.notify(o), this.state = 3) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 3: {
+        this.state >= 3 && this.state < 4 ? (this.state = 4 % 4, this.notify(o)) : this.context.crash(new Error(`Tried to DID_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case 4: {
+        this.state === 0 ? (this.notify(o), this.listeners.clear(), this.bound = void 0, this.context[w] = void 0, this.context[y] = void 0, this.state = 5) : this.context.crash(new Error(`Tried to DISPOSE context at state ${this.state}`));
+        break;
+      }
+    }
+  }
+  /**
+   * Bind `context` to this lifecycle; when any event is emitted here it will be emitted for `context` as well.
+   */
+  bind(o) {
+    this.bound ? this.bound.add(o) : this.bound = /* @__PURE__ */ new Set([o]);
+  }
+  /**
+   * Call all the event's listeners and re-emit to bound contexts.
+   */
+  notify(o) {
+    const t = this.listeners.get(o);
+    if (t)
+      for (const e of t)
+        e();
+    if (this.bound)
+      for (const e of this.bound)
+        e[d].emit(o);
+  }
+}
+var z, F, H, Z, K, N;
+K = U, Z = d, H = b, F = y, z = w;
+const L = class L {
+  constructor(o, t) {
+    j(this, N);
+    a(this, K);
+    a(this, Z, new ft(this));
+    a(this, H);
+    a(this, F);
+    a(this, z);
+    T(this, N, o), this[U] = I(o);
+    const e = lt(() => x(O(this, N)), t == null ? void 0 : t.logger), s = Object.getOwnPropertyDescriptors(e);
+    for (const n in s)
+      Object.defineProperty(this, n, s[n]);
+  }
+  get isMounted() {
+    const { state: o } = this[d];
+    return o >= 2 && o < 4;
+  }
+  /**
+   * Returns a new Context with this one as its parent.
+   */
+  static linked(o, t, e) {
+    const s = new L(t, e);
+    return s[b] = o, e != null && e.bindLifecycleToParent && o[d].bind(s), s;
+  }
+  /**
+   * Emit a lifecycle event to `context`.
+   */
+  static emit(o, t) {
+    o[d].emit(t);
+  }
+  /**
+   * Traverses _parent contexts until arriving at one that doesn't have a parent itself.
+   * Returns null if this context is the parent.
+   */
+  static getRoot(o) {
+    let t = o[b];
+    for (; t != null && t[b]; )
+      t = t[b];
+    return t ?? null;
+  }
+  /**
+   * Returns the current name of this context.
+   */
+  getName() {
+    return I(O(this, N));
+  }
+  /**
+   * Sets a new name for this context.
+   */
+  setName(o) {
+    T(this, N, o), this[U] = I(o);
+  }
+  /**
+   * Creates an instance of a store and attaches it to this context.
+   */
+  addStore(o, t) {
+    var s;
+    if ((s = this[y]) != null && s.get(o)) {
+      let n = o.name ? `'${o.name}'` : "this store";
+      throw this.crash(new Error(`An instance of ${n} was already added on this context.`));
+    }
+    const e = L.linked(this, o.name, {
+      bindLifecycleToParent: !0,
+      logger: { tag: Y(), tagName: "uid" }
+    });
+    try {
+      this[y] || (this[y] = /* @__PURE__ */ new Map());
+      const n = M(e), c = o.call(e, t, e);
+      M(n), this[y].set(o, c);
+    } catch (n) {
+      throw this.crash(n);
+    }
+    return this;
+  }
+  /**
+   * Retrieves the nearest instance of `store`. If this context doesn't have it, the parent context is checked. This process continues until either:
+   * 1. An instance of the store is found and returned.
+   * 2. No instance is found and an error is thrown.
+   */
+  getStore(o) {
+    var s;
+    if (!m(o))
+      throw new Error("Invalid store.");
+    let t = this, e;
+    for (; e = (s = t[y]) == null ? void 0 : s.get(o), e == null && t[b] != null; )
+      t = t[b];
+    if (e == null)
+      throw this.crash(new Error(`Store '${o.name}' is not provided by this context.`));
+    return e;
+  }
+  /**
+   * Schedule a callback function to run just before this context is mounted.
+   */
+  beforeMount(o) {
+    return this[d].on(0, o), () => this[d].off(0, o);
+  }
+  /**
+   * Schedule a callback function to run after this context is mounted.
+   */
+  onMount(o) {
+    return this[d].on(1, o), () => this[d].off(1, o);
+  }
+  /**
+   * Schedule a callback function to run just before this context is unmounted.
+   */
+  beforeUnmount(o) {
+    return this[d].on(2, o), () => this[d].off(2, o);
+  }
+  /**
+   * Schedule a callback function to run after this context is unmounted.
+   */
+  onUnmount(o) {
+    return this[d].on(3, o), () => this[d].off(3, o);
+  }
+  effect(o) {
+    const t = () => {
+      try {
+        return o();
+      } catch (e) {
+        this.error(e), e instanceof Error ? this.crash(e) : typeof e == "string" ? this.crash(new Error(e)) : this.crash(new Error("Unknown error thrown in effect callback"));
+      }
+    };
+    if (this[d].state >= 1) {
+      const e = v(t);
+      return this[d].on(3, e), e;
+    } else {
+      let e, s = !1;
+      return this[d].on(0, () => {
+        s || (e = v(t), this[d].on(3, e));
+      }), () => {
+        e != null && (s = !0, e());
+      };
+    }
+  }
+  getState(o, t) {
+    var e;
+    if (arguments.length > 0) {
+      let s = this, n;
+      for (; n = (e = s[w]) == null ? void 0 : e.get(o), n === void 0 && s[b] != null; )
+        s = s[b];
+      if (n === void 0) {
+        if (arguments.length > 1)
+          return t;
+        throw new Error(`Expected a value for '${String(o)}' but got undefined.`);
+      }
+      return n;
+    } else {
+      let s = this;
+      const n = [];
+      for (; s[w] && n.push(...s[w].entries()), s[b] != null; )
+        s = s[b];
+      return new Map(n.reverse());
+    }
+  }
+  setState(...o) {
+    if (this[w] || (this[w] = /* @__PURE__ */ new Map()), o.length === 2)
+      this[w].set(o[0], o[1]);
+    else if (rt(o[0]) === "array")
+      for (const [t, e] of o[0])
+        e === void 0 ? this[w].delete(t) : this[w].set(t, e);
+    else
+      throw new Error("Invalid arguments.");
+    return this;
+  }
+};
+N = new WeakMap();
+let f = L;
+function Lt(i, o) {
+  return new f(i, o);
+}
+class k {
+  /**
+   * Returns a single DOM node to represent this MarkupNode's position in the DOM.
+   * Usually the parent element, but it can be an empty Text node used as a marker.
+   *
+   * It only needs to be defined while the node is mounted, so it can be created in the `mount` function.
+   */
+  getRoot() {
+    throw new Error("getRoot method is not implemented");
+  }
+  /**
+   * Returns true while this node is mounted.
+   */
+  isMounted() {
+    throw new Error("isMounted method is not implemented");
+  }
+  /**
+   * Mount this node to a `parent` element.
+   * If passed, this node will be mounted as the next sibling of `after`.
+   */
+  mount(o, t) {
+    throw new Error("mount method is not implemented");
+  }
+  /**
+   * Unmount this MarkupNode from its parent element.
+   *
+   * The `skipDOM` option can be passed as an optimization when unmounting a parent node.
+   * A value of `true` indicates that no DOM operations need to happen because the parent is already being unmounted.
+   *
+   * @param skipDOM - No DOM updates will be performed when true. Lifecycle methods will be called regardless.
+   */
+  unmount(o) {
+    throw new Error("unmount method is not implemented");
+  }
+  /**
+   * Moves a node without unmounting and remounting (if the browser supports Element.moveBefore).
+   */
+  move(o, t) {
+    throw new Error("move method is not implemented");
+  }
+}
+class $ extends k {
+  constructor(t) {
+    super();
+    a(this, "root");
+    this.root = t;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentNode != null;
+  }
+  mount(t, e) {
+    t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+  }
+  unmount(t = !1) {
+    !t && this.root.parentNode && this.root.parentNode.removeChild(this.root);
+  }
+  move(t, e) {
+    if ("moveBefore" in t && this.root instanceof Element)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+}
+class A extends k {
+  constructor(t, e) {
+    super();
+    a(this, "root", document.createTextNode(""));
+    a(this, "children", []);
+    a(this, "context");
+    a(this, "$slot");
+    a(this, "unsubscribe");
+    this.context = t, this.$slot = e;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, e) {
+    this.isMounted() || (t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.unsubscribe = v(() => {
+      try {
+        const s = this.$slot();
+        I(() => {
+          this.update(J(s));
+        });
+      } catch (s) {
+        this.context.crash(s);
+      }
+    }));
+  }
+  unmount(t = !1) {
+    var e, s;
+    (e = this.unsubscribe) == null || e.call(this), this.isMounted() && (this.cleanup(t), (s = this.root.parentNode) == null || s.removeChild(this.root));
+  }
+  move(t, e) {
+    var s, n, c;
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+        for (let r = 0; r < this.children.length; r++)
+          this.children[r].move(t, ((s = this.children[r - 1]) == null ? void 0 : s.getRoot()) ?? this.root);
+        t.moveBefore(this.root, ((c = (n = this.children.at(-1)) == null ? void 0 : n.getRoot()) == null ? void 0 : c.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+  cleanup(t) {
+    for (const e of this.children)
+      e.isMounted() && e.unmount(t);
+    this.children.length = 0;
+  }
+  update(t) {
+    var c, r, h;
+    if (this.cleanup(!1), t.length === 0 || !this.isMounted()) return;
+    const e = W(this.context, t);
+    for (const u of e) {
+      const l = ((c = this.children.at(-1)) == null ? void 0 : c.getRoot()) || this.root;
+      u.mount(this.root.parentElement, l), this.children.push(u);
+    }
+    const s = this.root.parentElement, n = ((h = (r = this.children.at(-1)) == null ? void 0 : r.getRoot()) == null ? void 0 : h.nextSibling) ?? null;
+    "moveBefore" in s ? s.moveBefore(this.root, n) : s.insertBefore(this.root, n);
+  }
+}
+const Q = Symbol("ViewNode");
+class X extends k {
+  /**
+   * @param context - Parent contenxt to link to.
+   * @param view - View function to mount.
+   * @param props - Props to pass to view function.
+   */
+  constructor(t, e, s) {
+    super();
+    a(this, "uniqueId", Y());
+    a(this, "context");
+    a(this, "props");
+    a(this, "view");
+    a(this, "node");
+    this.context = f.linked(t, e.name ?? "anonymous view", {
+      logger: {
+        tag: this.uniqueId,
+        tagName: "uid"
+      }
+    }), this.context.setState(Q, this), this.props = s, this.view = e;
+  }
+  getRoot() {
+    var t;
+    return (t = this.node) == null ? void 0 : t.getRoot();
+  }
+  isMounted() {
+    var t;
+    return ((t = this.node) == null ? void 0 : t.isMounted()) ?? !1;
+  }
+  mount(t, e) {
+    const s = this.isMounted();
+    if (!s) {
+      const { context: n, props: c, view: r } = this;
+      try {
+        const h = M(n), u = r.call(n, c, n);
+        M(h), u != null && u !== !1 && (this.node = ot(u, n));
+      } catch (h) {
+        throw h instanceof Error && n.crash(h), h;
+      }
+      f.emit(this.context, g.WILL_MOUNT);
+    }
+    this.node && this.node.mount(t, e), s || f.emit(this.context, g.DID_MOUNT);
+  }
+  unmount(t = !1) {
+    f.emit(this.context, g.WILL_UNMOUNT), this.node && this.node.unmount(t), f.emit(this.context, g.DID_UNMOUNT), f.emit(this.context, g.DISPOSE);
+  }
+  move(t, e) {
+    var s;
+    (s = this.node) == null || s.move(t, e);
+  }
+}
+const mt = (i) => /^on[A-Z]/.test(i), P = Symbol("HTML.isSVG"), pt = ["class", "className", "ref", "mixin", "children"];
+class bt extends k {
+  constructor(t, e, s) {
+    super();
+    a(this, "root");
+    a(this, "tag");
+    a(this, "props");
+    a(this, "context");
+    a(this, "childNodes", []);
+    a(this, "unsubscribers", []);
+    // Track the ref so we can nullify it on unmount.
+    a(this, "ref");
+    // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+    a(this, "canClickAway", !1);
+    if (this.tag = e, this.props = s, this.context = f.linked(t, q.bind(this)), e.toLowerCase() === "svg" && this.context.setState(P, !0), this.context.getState(P, !1) ? this.root = document.createElementNS("http://www.w3.org/2000/svg", e) : this.root = document.createElement(e), dt() === "development") {
+      const c = this.context.getState(Q, null);
+      c && (this.root.dataset.view = c.context.getName());
+    }
+    if (s.mixin)
+      for (const c of J(s.mixin)) {
+        const r = f.linked(this.context, q.bind(this), {
+          bindLifecycleToParent: !0,
+          logger: { tagName: c.name === "mixin" ? void 0 : "mixin", tag: c.name }
+        }), h = M(r);
+        c(this.root, r), M(h);
+      }
+    const n = s.className ?? s.class;
+    if (this.applyProps(this.root, s), s.style && this.applyStyles(this.root, s.style, this.unsubscribers), n && this.applyClasses(this.root, n, this.unsubscribers), s.ref)
+      if (m(s.ref))
+        this.ref = s.ref, this.ref(this.root);
+      else
+        throw new Error("Expected ref to be a function. Got: " + s.ref);
+    s.children && (this.childNodes = W(this.context, s.children));
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.context.isMounted;
+  }
+  mount(t, e) {
+    const s = this.isMounted();
+    if (!s) {
+      f.emit(this.context, g.WILL_MOUNT);
+      for (let n = 0; n < this.childNodes.length; n++) {
+        const c = this.childNodes[n], r = n > 0 ? this.childNodes[n - 1].getRoot() : void 0;
+        c.mount(this.root, r);
+      }
+    }
+    t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.canClickAway = !0, s || f.emit(this.context, g.DID_MOUNT);
+  }
+  unmount(t = !1) {
+    var e;
+    f.emit(this.context, g.WILL_UNMOUNT), t || (e = this.root.parentNode) == null || e.removeChild(this.root);
+    for (const s of this.childNodes)
+      s.unmount(!0);
+    this.canClickAway = !1;
+    for (const s of this.unsubscribers)
+      s();
+    this.unsubscribers.length = 0, this.ref && this.ref(void 0), f.emit(this.context, g.DID_UNMOUNT), f.emit(this.context, g.DISPOSE);
+  }
+  move(t, e) {
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null);
+      } catch {
+        this.mount(t, e);
+      }
+    else
+      this.mount(t, e);
+  }
+  attachProp(t, e) {
+    m(t) ? this.unsubscribers.push(
+      v(() => {
+        try {
+          e(t());
+        } catch (s) {
+          this.context.error(s), this.context.crash(s);
+        }
+      })
+    ) : e(t);
+  }
+  applyProps(t, e) {
+    for (const s in ct(pt, e)) {
+      const n = e[s];
+      if (s === "on:clickoutside" || s === "onClickOutside" || s === "onclickoutside") {
+        const c = (h) => {
+          this.canClickAway && !t.contains(h.target) && n(h);
+        }, r = { capture: !0 };
+        window.addEventListener("click", c, r), this.unsubscribers.push(() => {
+          window.removeEventListener("click", c, r);
+        });
+      } else if (s.startsWith("prop:")) {
+        const c = s.substring(5);
+        this.attachProp(n, (r) => {
+          t[c] = r;
+        });
+      } else if (s.startsWith("on:")) {
+        const c = s.substring(3);
+        let r;
+        m(n) ? (t.addEventListener(c, n), this.unsubscribers.push(() => {
+          t.removeEventListener(c, n);
+        })) : this.attachProp(n, (h) => {
+          !h && r ? t.removeEventListener(c, r) : h != null && (r && r !== h && t.removeEventListener(c, r), t.addEventListener(c, h)), r = h;
+        });
+      } else if (s.startsWith("attr:")) {
+        const c = s.substring(5).toLowerCase();
+        this.attachProp(n, (r) => {
+          r != null ? t.setAttribute(c, String(r)) : t.removeAttribute(c);
+        });
+      } else if (m(n) && mt(s)) {
+        const c = s.slice(2).toLowerCase(), r = n;
+        t.addEventListener(c, r), this.unsubscribers.push(() => {
+          t.removeEventListener(c, r);
+        });
+      } else if (s.startsWith("on") && m(n) && gt.includes(s.substring(2)))
+        t[s] = n, this.unsubscribers.push(() => {
+          t[s] = void 0;
+        });
+      else if (s.includes("-"))
+        this.attachProp(n, (c) => {
+          c == null ? t.removeAttribute(s) : t.setAttribute(s, String(c));
+        });
+      else if (this.context.getState(P, !1))
+        this.attachProp(n, (c) => {
+          c != null ? t.setAttribute(s, String(e[s])) : t.removeAttribute(s);
+        });
+      else
+        switch (s) {
+          case "contentEditable":
+          case "value":
+            this.attachProp(n, (r) => {
+              t[s] = String(r);
+            });
+            break;
+          case "for":
+            this.attachProp(n, (r) => {
+              t.htmlFor = r;
+            });
+            break;
+          case "innerHTML":
+            this.attachProp(n, (r) => {
+              t.innerHTML = r;
+            });
+            break;
+          case "title":
+            this.attachProp(n, (r) => {
+              r == null ? t.removeAttribute(s) : t.setAttribute(s, String(r));
+            });
+          case "checked":
+            this.attachProp(n, (r) => {
+              t.checked = r, r ? t.setAttribute("checked", "") : t.removeAttribute("checked");
+            });
+            break;
+          case "dataset":
+            let c = {};
+            this.attachProp(n, (r) => {
+              if (C(r)) {
+                const h = {};
+                for (const u in r)
+                  h[at(u)] = String(r[u]);
+                for (const u in c)
+                  Object.hasOwn(h, u) || (delete t.dataset[u], delete c[u]);
+                for (const u in h)
+                  c[u] !== h[u] && (t.dataset[u] = h[u], c[u] = h[u]);
+              } else
+                for (const h in c)
+                  delete t.dataset[h];
+            });
+            break;
+          case "autocomplete":
+          case "autocapitalize":
+            this.attachProp(n, (r) => {
+              typeof r == "string" ? t[s] = r : r ? t[s] = "on" : t[s] = "off";
+            });
+            break;
+          default: {
+            this.attachProp(n, (r) => {
+              t[s] = r;
+            });
+            break;
+          }
+        }
+    }
+  }
+  applyStyles(t, e, s) {
+    const n = [];
+    if (m(e)) {
+      let c;
+      const r = v(() => {
+        m(c) && c(), t.style.cssText = "", c = this.applyStyles(t, x(e), s);
+      });
+      s.push(r), n.push(r);
+    } else {
+      const c = et(e);
+      for (const r in c) {
+        const { value: h, priority: u } = c[r];
+        if (m(h)) {
+          const l = v(() => {
+            x(h) ? t.style.setProperty(r, String(x(h)), u) : t.style.removeProperty(r);
+          });
+          s.push(l), n.push(l);
+        } else h != null && t.style.setProperty(r, String(h));
+      }
+    }
+    return function() {
+      for (const r of n)
+        r(), s.splice(s.indexOf(r), 1);
+    };
+  }
+  applyClasses(t, e, s) {
+    const n = [];
+    if (m(e)) {
+      let c;
+      const r = v(() => {
+        m(c) && c(), t.removeAttribute("class"), c = this.applyClasses(t, x(e), s);
+      });
+      s.push(r), n.push(r);
+    } else {
+      const c = tt(e);
+      for (const r in c) {
+        const h = c[r];
+        if (m(h)) {
+          const u = v(() => {
+            x(h) ? t.classList.add(r) : t.classList.remove(r);
+          });
+          s.push(u), n.push(u);
+        } else h && t.classList.add(r);
+      }
+    }
+    return function() {
+      for (const r of n)
+        r(), s.splice(s.indexOf(r), 1);
+    };
+  }
+}
+function tt(i) {
+  let o = {};
+  if (D(i)) {
+    const t = i.split(" ");
+    for (const e of t)
+      o[e] = !0;
+  } else C(i) ? Object.assign(o, i) : Array.isArray(i) && Array.from(i).filter(Boolean).forEach((t) => {
+    Object.assign(o, tt(t));
+  });
+  return delete o.undefined, o;
+}
+function et(i) {
+  let o = {};
+  if (D(i)) {
+    const t = i.split(";").filter((e) => e.trim() !== "");
+    for (const e of t) {
+      const [s, n] = e.split(":"), c = {
+        value: n
+      };
+      n.includes("!important") ? (c.priority = "important", c.value = n.replace("!important", "").trim()) : c.value = n.trim(), o[G(s.trim())] = c;
+    }
+  }
+  if (C(i))
+    for (const t in i)
+      t.startsWith("--") ? o[t] = { value: i[t] } : o[G(t)] = { value: i[t] };
+  else Array.isArray(i) && Array.from(i).filter((t) => t != null).forEach((t) => {
+    Object.assign(o, et(t));
+  });
+  return o;
+}
+function q() {
+  const i = this.getRoot();
+  if (i == null) return this.tag;
+  let o = this.getRoot().tagName.toLowerCase();
+  if (i.id && (o += `#${i.id}`), i.classList.length > 0)
+    for (const t of i.classList.values())
+      o += `.${t}`;
+  return o;
+}
+function G(i) {
+  return i.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (o, t) => (t ? "-" : "") + o.toLowerCase());
+}
+const gt = [
+  // Element
+  "animationcancel",
+  "animationend",
+  "animationiteration",
+  "animationstart",
+  "auxclick",
+  "beforeinput",
+  "beforematch",
+  "beforexrselect",
+  "blur",
+  "click",
+  "compositionend",
+  "compositionstart",
+  "compositionupdate",
+  "contentvisibilityautostatechange",
+  "contextmenu",
+  "copy",
+  "cut",
+  "dblclick",
+  "focus",
+  "focusin",
+  "focusout",
+  "fullscreenchange",
+  "fullscreenerror",
+  "gotpointercapture",
+  "input",
+  "keydown",
+  "keyup",
+  "lostpointercapture",
+  "mousedown",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "paste",
+  "pointercancel",
+  "pointerdown",
+  "pointerenter",
+  "pointerleave",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerrawupdate",
+  "pointerup",
+  "scroll",
+  "scrollend",
+  "scrollsnapchange",
+  "scrollsnapchanging",
+  "securitypolicyviolation",
+  "touchcancel",
+  "touchend",
+  "touchmove",
+  "touchstart",
+  "transitioncancel",
+  "transitionend",
+  "transitionrun",
+  "transitionstart",
+  "webkitmouseforcechanged",
+  "webkitmouseforcedown",
+  "webkitmouseforceup",
+  "webkimouseforcewillbegin",
+  "wheel",
+  // HTMLElement
+  "beforetoggle",
+  "change",
+  "command",
+  "drag",
+  "dragend",
+  "dragenter",
+  "dragleave",
+  "dragover",
+  "dragstart",
+  "drop",
+  "error",
+  "load",
+  "toggle",
+  // HTMLInputElement
+  "cancel",
+  "invalid",
+  "search",
+  "select",
+  "selectionchange",
+  // HTMLFormElement
+  "formdata",
+  "reset",
+  "submit"
+];
+class wt extends k {
+  constructor(t, e, s) {
+    super();
+    a(this, "context");
+    a(this, "value");
+    a(this, "parent");
+    a(this, "node");
+    this.context = t, this.value = e, this.parent = s;
+  }
+  getRoot() {
+    var t;
+    return (t = this.node) == null ? void 0 : t.getRoot();
+  }
+  isMounted() {
+    return this.node ? this.node.isMounted() : !1;
+  }
+  mount(t, e) {
+    const s = ot(this.value, this.context);
+    this.node = s, s.mount(this.parent);
+  }
+  unmount(t = !1) {
+    var e;
+    (e = this.node) != null && e.isMounted() && this.node.unmount(!1);
+  }
+  move(t, e) {
+  }
+}
+class vt extends k {
+  constructor(t, e, s, n) {
+    super();
+    a(this, "root", document.createTextNode(""));
+    a(this, "context");
+    a(this, "items");
+    a(this, "key");
+    a(this, "render");
+    a(this, "unsubscribe", null);
+    a(this, "connectedItems", /* @__PURE__ */ new Map());
+    this.context = t, this.items = e, this.key = s, this.render = n;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, e) {
+    this.isMounted() || (t.insertBefore(this.root, (e == null ? void 0 : e.nextSibling) ?? null), this.unsubscribe = v(() => {
+      let s = this.items();
+      s == null && (s = [], this.context.warn("repeat() received empty value for items", s)), I(() => {
+        this._update(Array.from(s));
+      });
+    }));
+  }
+  unmount(t = !1) {
+    var e;
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = null), !t && this.isMounted() && ((e = this.root.parentNode) == null || e.removeChild(this.root)), this._cleanup(t);
+  }
+  move(t, e) {
+    return this.mount(t, e);
+  }
+  _cleanup(t) {
+    for (const e of this.connectedItems.values())
+      e.node.unmount(t);
+    this.connectedItems.clear();
+  }
+  _update(t) {
+    var r, h, u;
+    if (t.length === 0 || !this.isMounted())
+      return this._cleanup(!1);
+    const e = /* @__PURE__ */ new Map();
+    let s = 0;
+    for (const l of t) {
+      const p = this.key(l, s);
+      e.set(p, {
+        key: p,
+        value: l,
+        index: s++
+      });
+    }
+    const n = [];
+    for (const l of this.connectedItems.values())
+      !e.has(l.key) && l.node.isMounted() && l.node.unmount(!1);
+    ht(() => {
+      for (const l of e.values()) {
+        const p = this.connectedItems.get(l.key);
+        if (p && p.node.isMounted())
+          p.$item(l.value), p.$index(l.index), n[l.index] = p;
+        else {
+          const S = _(l.value, { equals: ut }), E = _(l.index);
+          n[l.index] = {
+            key: l.key,
+            $item: S,
+            $index: E,
+            node: new X(this.context, yt, {
+              $item: () => S(),
+              $index: () => E(),
+              render: this.render
+            })
+          };
+        }
+      }
+    });
+    for (let l = 0; l < n.length; l++) {
+      const p = n[l], S = ((r = n[l - 1]) == null ? void 0 : r.node.getRoot()) ?? this.root, E = this.connectedItems.get(p.key);
+      E && E.node.isMounted() ? p.node.move(this.root.parentElement, S) : p.node.mount(this.root.parentElement, S);
+    }
+    this.connectedItems.clear();
+    for (const l of n)
+      this.connectedItems.set(l.key, l);
+    const c = ((h = n.at(-1)) == null ? void 0 : h.node.getRoot()) ?? this.root;
+    (u = this.root.parentNode) == null || u.insertBefore(this.root, c.nextSibling);
+  }
+}
+const xt = "dolla.RepeatItemView";
+function yt(i, o) {
+  return o.setName(xt), i.render.call(o, i.$item, i.$index, o);
+}
+class st {
+  constructor(o, t) {
+    /**
+     * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
+     * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
+     */
+    a(this, "type");
+    /**
+     * Data that will be passed to a new MarkupNode instance when it is constructed.
+     * Includes a `children` prop if children were passed.
+     */
+    a(this, "props");
+    this.type = o, this.props = t;
+  }
+}
+var Nt = /* @__PURE__ */ ((i) => (i.DOM = "$dom", i.Dynamic = "$dynamic", i.Portal = "$portal", i.Repeat = "$repeat", i))(Nt || {});
+function R(i, o) {
+  return new st(i, o ?? {});
+}
+function kt(i, o, t) {
+  return R("$dynamic", {
+    source: _(() => {
+      const e = x(i);
+      return e && o ? o : !e && t ? t : null;
+    })
+  });
+}
+function Ot(i, o, t) {
+  return kt(i, t, o);
+}
+function Tt(i, o, t) {
+  return R("$repeat", { items: () => x(i), key: o, render: t });
+}
+function Ut(i, o) {
+  return R("$portal", { parent: i, content: o });
+}
+function ot(i, o = new f("$")) {
+  const t = W(o, i);
+  return t.length === 1 ? t[0] : new A(o, () => t);
+}
+function W(i, ...o) {
+  const t = o.flat(1 / 0), e = [];
+  for (const s of t)
+    if (!(s == null || s === !1)) {
+      if (s instanceof Node) {
+        e.push(new $(s));
+        continue;
+      }
+      if (s instanceof st)
+        if (m(s.type)) {
+          e.push(new X(i, s.type, s.props));
+          continue;
+        } else if (D(s.type))
+          switch (s.type) {
+            case "$dom": {
+              const n = s.props;
+              e.push(new $(n.value));
+              continue;
+            }
+            case "$dynamic": {
+              const n = s.props;
+              e.push(new A(i, n.source));
+              continue;
+            }
+            case "$portal": {
+              const n = s.props;
+              e.push(new wt(i, n.content, n.parent));
+              continue;
+            }
+            case "$repeat": {
+              const n = s.props;
+              e.push(new vt(i, n.items, n.key, n.render));
+              continue;
+            }
+            default:
+              e.push(new bt(i, s.type, s.props));
+              continue;
+          }
+        else
+          throw new TypeError(`Expected a string or view function. Got: ${s.type}`);
+      if (s instanceof k) {
+        e.push(s);
+        continue;
+      }
+      if (m(s)) {
+        e.push(new A(i, s));
+        continue;
+      }
+      e.push(new $(document.createTextNode(String(s))));
+    }
+  return e;
+}
+export {
+  f as C,
+  A as D,
+  g as L,
+  k as M,
+  X as V,
+  Tt as a,
+  Nt as b,
+  Lt as c,
+  st as d,
+  R as m,
+  Ut as p,
+  ot as r,
+  Ot as u,
+  kt as w
+};
+//# sourceMappingURL=markup-CX27GJ1M.js.map