@manyducks.co/dolla 2.0.0-alpha.8 → 2.0.0

package/dist/markup-8jNhoqDe.js

@@ -0,0 +1,1089 @@
+import { b as u, t as q, a as L, i as O, h as F } from "./typeChecking-5kmX0ulW.js";
+import { u as v, i as G, g as w, n as _, p as N, e as m, t as D, q as T, v as z, f as H, x as Y, y as Z, s as J, m as Q, l as X, b as tt, w as U, d as et } from "./logger-Aqi9m1CF.js";
+var d = /* @__PURE__ */ ((n) => (n.WILL_MOUNT = "willMount", n.DID_MOUNT = "didMount", n.WILL_UNMOUNT = "willUnmount", n.DID_UNMOUNT = "didUnmount", n.DISPOSE = "dispose", n))(d || {});
+const k = Symbol("name"), l = Symbol("lifecycle"), b = Symbol("parent"), y = Symbol("stores"), f = Symbol("state");
+class st {
+  context;
+  state = 0;
+  listeners = /* @__PURE__ */ new Map();
+  bound;
+  constructor(t) {
+    this.context = t;
+  }
+  /**
+   * Listen for a certain event to be emitted. Listeners are called when the event results in a state change.
+   */
+  on(t, s) {
+    const e = this.listeners.get(t);
+    e ? e.add(s) : this.listeners.set(t, /* @__PURE__ */ new Set([s]));
+  }
+  /**
+   * Stop a particular listener from being called when an event is emitted.
+   */
+  off(t, s) {
+    const e = this.listeners.get(t);
+    e && (e.delete(s), e.size === 0 && this.listeners.delete(t));
+  }
+  /**
+   * Advance the lifecycle state machine.
+   */
+  emit(t) {
+    switch (t) {
+      case "willMount": {
+        this.state < 1 ? (this.state = 1, this.notify(t)) : this.context.crash(new Error(`Tried to WILL_MOUNT context at state ${this.state}`));
+        break;
+      }
+      case "didMount": {
+        this.state >= 1 && this.state < 2 ? (this.state = 2, this.notify(t)) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case "willUnmount": {
+        this.state >= 2 && this.state < 3 ? (this.notify(t), this.state = 3) : this.context.crash(new Error(`Tried to WILL_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case "didUnmount": {
+        this.state >= 3 && this.state < 4 ? (this.state = 4 % 4, this.notify(t)) : this.context.crash(new Error(`Tried to DID_UNMOUNT context at state ${this.state}`));
+        break;
+      }
+      case "dispose": {
+        this.state === 0 ? (this.notify(t), this.listeners.clear(), this.bound = void 0, this.context[f] = 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(t) {
+    this.bound ? this.bound.add(t) : this.bound = /* @__PURE__ */ new Set([t]);
+  }
+  /**
+   * Call all the event's listeners and re-emit to bound contexts.
+   */
+  notify(t) {
+    const s = this.listeners.get(t);
+    if (s)
+      for (const e of s)
+        e();
+    if (this.bound)
+      for (const e of this.bound)
+        e[l].emit(t);
+  }
+}
+class h {
+  #t;
+  [k];
+  [l] = new st(this);
+  [b];
+  [y];
+  [f];
+  get isMounted() {
+    const { state: t } = this[l];
+    return t >= 2 && t < 4;
+  }
+  /**
+   * Returns a new Context with this one as its parent.
+   */
+  static createChildOf(t, s, e) {
+    const o = new h(s, e);
+    return o[b] = t, e?.bindLifecycleToParent && t[l].bind(o), o;
+  }
+  /**
+   * Emit a lifecycle event to `context`.
+   */
+  static emit(t, s) {
+    t[l].emit(s);
+  }
+  constructor(t, s) {
+    this.#t = t, this[k] = v(t);
+    const e = G(() => w(this.#t), s?.logger), o = Object.getOwnPropertyDescriptors(e);
+    for (const r in o)
+      Object.defineProperty(this, r, o[r]);
+  }
+  /**
+   * Returns the current name of this context.
+   */
+  getName() {
+    return v(this.#t);
+  }
+  /**
+   * Sets a new name for this context.
+   */
+  setName(t) {
+    this.#t = t, this[k] = v(t);
+  }
+  /**
+   * Creates an instance of a store and attaches it to this context.
+   */
+  provideStore(t, s) {
+    if (this[y]?.get(t)) {
+      let o = t.name ? `'${t.name}'` : "this store";
+      throw this.crash(new Error(`An instance of ${o} was already added on this context.`));
+    }
+    const e = h.createChildOf(this, t.name, {
+      bindLifecycleToParent: !0,
+      logger: { tag: _(), tagName: "uid" }
+    });
+    try {
+      this[y] || (this[y] = /* @__PURE__ */ new Map());
+      const o = N(e), r = t(s);
+      N(o), this[y].set(t, r);
+    } catch (o) {
+      throw this.crash(o);
+    }
+    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.
+   */
+  useStore(t) {
+    if (!u(t))
+      throw new Error("Invalid store.");
+    let s = this, e;
+    for (; e = s[y]?.get(t), e == null && s[b] != null; )
+      s = s[b];
+    if (e == null)
+      throw this.crash(new Error(`Store '${t.name}' is not provided by this context.`));
+    return e;
+  }
+  /**
+   * Registers a `listener` to be called at a specific transition point during this context's lifecycle.
+   *
+   * Prefer `useMount` and `useUnmount` hooks for general usage.
+   */
+  onLifecycleTransition(t, s) {
+    return this[l].on(t, s), () => this[l].off(t, s);
+  }
+  effect(t) {
+    const s = () => {
+      try {
+        return t();
+      } 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[l].state >= 1) {
+      const e = m(s);
+      return this[l].on("didUnmount", e), e;
+    } else {
+      let e, o = !1;
+      return this[l].on("willMount", () => {
+        o || (e = m(s), this[l].on("didUnmount", e));
+      }), () => {
+        e != null && (o = !0, e());
+      };
+    }
+  }
+  getState(t, s) {
+    const e = s?.immediate ?? !1;
+    let o = this, r;
+    for (; r = o[f]?.get(t), r === void 0 && !e && o[b] != null; )
+      o = o[b];
+    if (r === void 0) {
+      if (s != null && Object.hasOwn(s, "fallback"))
+        return s.fallback;
+      throw new Error(`Expected a value for '${String(t)}' but got undefined.`);
+    }
+    return r;
+  }
+  /**
+   * Returns a Map containing all state values available to this context.
+   *
+   * Pass `options.immediate` to only include state stored on this context.
+   * By default all state stored on parent contexts is also included.
+   */
+  getStateMap(t) {
+    let s = this;
+    const e = t?.immediate ?? !1, o = [];
+    for (; s[f] && o.push(...s[f].entries()), !e && s[b] != null; )
+      s = s[b];
+    return new Map(o.reverse());
+  }
+  setState(...t) {
+    if (this[f] || (this[f] = /* @__PURE__ */ new Map()), t.length === 2)
+      this[f].set(t[0], t[1]);
+    else if (q(t[0]) === "array")
+      for (const [s, e] of t[0])
+        e === void 0 ? this[f].delete(s) : this[f].set(s, e);
+    else
+      throw new Error("Invalid arguments.");
+    return this;
+  }
+}
+function bt(n, t) {
+  return new h(n, t);
+}
+class x {
+  /**
+   * 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(t, s) {
+    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(t) {
+    throw new Error("unmount method is not implemented");
+  }
+  /**
+   * Moves a node without unmounting and remounting (if the browser supports Element.moveBefore).
+   */
+  move(t, s) {
+    throw new Error("move method is not implemented");
+  }
+}
+class M extends x {
+  root;
+  constructor(t) {
+    super(), this.root = t;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentNode != null;
+  }
+  mount(t, s) {
+    t.insertBefore(this.root, s?.nextSibling ?? null);
+  }
+  unmount(t = !1) {
+    !t && this.root.parentNode && this.root.parentNode.removeChild(this.root);
+  }
+  move(t, s) {
+    if ("moveBefore" in t && this.root instanceof Element)
+      try {
+        t.moveBefore(this.root, s?.nextSibling ?? null);
+      } catch {
+        this.mount(t, s);
+      }
+    else
+      this.mount(t, s);
+  }
+}
+class E extends x {
+  root = document.createTextNode("");
+  children = [];
+  context;
+  $slot;
+  unsubscribe;
+  constructor(t, s) {
+    super(), this.context = t, this.$slot = s;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, s) {
+    this.isMounted() || (t.insertBefore(this.root, s?.nextSibling ?? null), this.unsubscribe = m(() => {
+      try {
+        const e = this.$slot();
+        v(() => {
+          this.update(D(e));
+        });
+      } catch (e) {
+        this.context.crash(e);
+      }
+    }));
+  }
+  unmount(t = !1) {
+    this.unsubscribe?.(), this.isMounted() && (T(this.root.parentElement, this.root, this.children[0]?.getRoot() ?? null), this.root.parentNode?.removeChild(this.root), this.cleanup(t));
+  }
+  move(t, s) {
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, s?.nextSibling ?? null);
+        for (let e = 0; e < this.children.length; e++)
+          this.children[e].move(t, this.children[e - 1]?.getRoot() ?? this.root);
+        t.moveBefore(this.root, this.children.at(-1)?.getRoot()?.nextSibling ?? null);
+      } catch {
+        this.mount(t, s);
+      }
+    else
+      this.mount(t, s);
+  }
+  cleanup(t) {
+    for (const s of this.children)
+      s.isMounted() && s.unmount(t);
+    this.children.length = 0;
+  }
+  update(t) {
+    if (this.cleanup(!1), t.length === 0 || !this.isMounted()) return;
+    const s = C(this.context, t);
+    for (const r of s) {
+      const i = this.children.at(-1)?.getRoot() || this.root;
+      r.mount(this.root.parentElement, i), this.children.push(r);
+    }
+    const e = this.root.parentElement, o = this.children.at(-1)?.getRoot()?.nextSibling ?? null;
+    T(e, this.root, o);
+  }
+}
+const I = Symbol("Ref.EMPTY");
+function ot(...n) {
+  return it.bind({ current: n.length ? n[0] : I });
+}
+function it(...n) {
+  if (n.length)
+    this.current = n[0];
+  else if (this.current === I)
+    throw new Error("Ref getter was called, but ref has no value! Be sure to set your refs before accessing them.");
+  return this.current;
+}
+const $ = Symbol("ViewNode");
+class B extends x {
+  id = _();
+  props;
+  context;
+  view;
+  node;
+  /**
+   * @param context - Parent contenxt to link to.
+   * @param view - View function to mount.
+   * @param props - Props to pass to view function.
+   */
+  constructor(t, s, e) {
+    super(), this.context = h.createChildOf(t, s.name ?? "anonymous view", {
+      logger: {
+        tag: this.id,
+        tagName: "uid"
+      }
+    }), this.context.setState($, this), this.props = e, this.view = s;
+  }
+  getRoot() {
+    return this.node?.getRoot();
+  }
+  isMounted() {
+    return this.context.isMounted;
+  }
+  mount(t, s) {
+    const e = this.isMounted();
+    if (!e) {
+      const { context: o, props: r, view: i } = this;
+      try {
+        const c = N(o), a = i(r);
+        N(c), a != null && a !== !1 && (this.node = V(a, o));
+      } catch (c) {
+        throw c instanceof Error && o.crash(c), c;
+      }
+      h.emit(this.context, d.WILL_MOUNT);
+    }
+    this.node && this.node.mount(t, s), e || h.emit(this.context, d.DID_MOUNT);
+  }
+  unmount(t = !1) {
+    h.emit(this.context, d.WILL_UNMOUNT), this.node && this.node.unmount(t), h.emit(this.context, d.DID_UNMOUNT), h.emit(this.context, d.DISPOSE);
+  }
+  move(t, s) {
+    this.node?.move(t, s);
+  }
+}
+const nt = (n) => /^on[A-Z]/.test(n), S = Symbol("HTML.isSVG"), rt = ["class", "className", "ref", "mixin", "children"];
+class ct extends x {
+  root;
+  id = z();
+  tag;
+  props;
+  context;
+  childNodes = [];
+  unsubscribers = [];
+  // Track the ref so we can nullify it on unmount.
+  ref;
+  // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+  canClickAway = !1;
+  constructor(t, s, e) {
+    if (super(), this.tag = s, this.props = e, this.context = h.createChildOf(t, P.bind(this)), s.toLowerCase() === "svg" && this.context.setState(S, !0), this.context.getState(S, { fallback: !1 }) ? this.root = document.createElementNS("http://www.w3.org/2000/svg", s) : this.root = document.createElement(s), H() === "development") {
+      const o = this.context.getState($, { fallback: null });
+      o && (this.root.dataset.view = o.context.getName());
+    }
+    if (e.ref)
+      if (u(e.ref))
+        this.ref = e.ref, this.ref(this.root);
+      else
+        throw new Error("Expected ref to be a function. Got: " + e.ref);
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.context.isMounted;
+  }
+  mount(t, s) {
+    const e = this.isMounted();
+    if (!e) {
+      const { props: o } = this;
+      if (o.mixin)
+        for (const i of D(o.mixin)) {
+          const c = h.createChildOf(this.context, P.bind(this), {
+            bindLifecycleToParent: !0,
+            logger: { tagName: i.name === "mixin" ? void 0 : "mixin", tag: i.name }
+          }), a = N(c);
+          i(this.root, c), N(a);
+        }
+      h.emit(this.context, d.WILL_MOUNT);
+      const r = o.className ?? o.class;
+      this.applyProps(this.root, o), o.style && this.applyStyles(this.root, o.style, this.unsubscribers), r && this.applyClasses(this.root, r, this.unsubscribers), o.children && (this.childNodes = C(this.context, o.children));
+    }
+    if (!e)
+      for (let o = 0; o < this.childNodes.length; o++) {
+        const r = this.childNodes[o], i = o > 0 ? this.childNodes[o - 1].getRoot() : void 0;
+        r.mount(this.root, i);
+      }
+    this.root.parentNode === t && "moveBefore" in t ? t.moveBefore(this.root, s?.nextSibling ?? null) : t.insertBefore(this.root, s?.nextSibling ?? null), this.canClickAway = !0, e || h.emit(this.context, d.DID_MOUNT);
+  }
+  unmount(t = !1) {
+    h.emit(this.context, d.WILL_UNMOUNT), t || this.root.parentNode?.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, h.emit(this.context, d.DID_UNMOUNT), h.emit(this.context, d.DISPOSE), queueMicrotask(() => {
+      this.ref && this.ref(I);
+    });
+  }
+  move(t, s) {
+    if ("moveBefore" in t)
+      try {
+        t.moveBefore(this.root, s?.nextSibling ?? null);
+      } catch {
+        this.mount(t, s);
+      }
+    else
+      this.mount(t, s);
+  }
+  attachProp(t, s, e) {
+    u(t) ? this.unsubscribers.push(
+      m(() => {
+        try {
+          s(t());
+        } catch (o) {
+          this.context.error(o), this.context.crash(o);
+        }
+      })
+    ) : s(t);
+  }
+  getKey(t) {
+    return this.id + ":" + t;
+  }
+  applyProps(t, s) {
+    for (const e in Y(rt, s)) {
+      const o = s[e];
+      if (e === "on:clickoutside" || e === "onClickOutside" || e === "onclickoutside") {
+        const r = (c) => {
+          this.canClickAway && !t.contains(c.target) && o(c);
+        }, i = { capture: !0 };
+        window.addEventListener("click", r, i), this.unsubscribers.push(() => {
+          window.removeEventListener("click", r, i);
+        });
+      } else if (e.startsWith("prop:")) {
+        const r = e.substring(5);
+        this.attachProp(
+          o,
+          (i) => {
+            t[r] = i;
+          },
+          this.getKey(r)
+        );
+      } else if (e.startsWith("on:")) {
+        const r = e.substring(3);
+        let i;
+        u(o) ? (t.addEventListener(r, o), this.unsubscribers.push(() => {
+          t.removeEventListener(r, o);
+        })) : this.attachProp(
+          o,
+          (c) => {
+            !c && i ? t.removeEventListener(r, i) : c != null && (i && i !== c && t.removeEventListener(r, i), t.addEventListener(r, c)), i = c;
+          },
+          this.getKey(r)
+        );
+      } else if (e.startsWith("attr:")) {
+        const r = e.substring(5).toLowerCase();
+        this.attachProp(
+          o,
+          (i) => {
+            i != null ? t.setAttribute(r, String(i)) : t.removeAttribute(r);
+          },
+          this.getKey(r)
+        );
+      } else if (u(o) && nt(e)) {
+        const r = e.slice(2).toLowerCase(), i = o;
+        t.addEventListener(r, i), this.unsubscribers.push(() => {
+          t.removeEventListener(r, i);
+        });
+      } else if (e.startsWith("on") && u(o) && at.includes(e.substring(2)))
+        t[e] = o, this.unsubscribers.push(() => {
+          t[e] = void 0;
+        });
+      else if (e.includes("-"))
+        this.attachProp(
+          o,
+          (r) => {
+            r == null ? t.removeAttribute(e) : t.setAttribute(e, String(r));
+          },
+          this.getKey(e)
+        );
+      else if (this.context.getState(S, { fallback: !1 }))
+        this.attachProp(
+          o,
+          (r) => {
+            r != null ? t.setAttribute(e, String(s[e])) : t.removeAttribute(e);
+          },
+          this.getKey(e)
+        );
+      else
+        switch (e) {
+          case "contentEditable":
+          case "value":
+            this.attachProp(
+              o,
+              (i) => {
+                t[e] = String(i);
+              },
+              this.getKey(e)
+            );
+            break;
+          case "for":
+            this.attachProp(
+              o,
+              (i) => {
+                t.htmlFor = i;
+              },
+              this.getKey(e)
+            );
+            break;
+          case "innerHTML":
+            this.attachProp(
+              o,
+              (i) => {
+                t.innerHTML = i;
+              },
+              this.getKey(e)
+            );
+            break;
+          case "title":
+            this.attachProp(
+              o,
+              (i) => {
+                i == null ? t.removeAttribute(e) : t.setAttribute(e, String(i));
+              },
+              this.getKey(e)
+            );
+          case "checked":
+            this.attachProp(
+              o,
+              (i) => {
+                t.checked = i, i ? t.setAttribute("checked", "") : t.removeAttribute("checked");
+              },
+              this.getKey(e)
+            );
+            break;
+          case "dataset":
+            let r = {};
+            this.attachProp(
+              o,
+              (i) => {
+                if (L(i)) {
+                  const c = {};
+                  for (const a in i)
+                    c[Z(a)] = String(i[a]);
+                  for (const a in r)
+                    Object.hasOwn(c, a) || (delete t.dataset[a], delete r[a]);
+                  for (const a in c)
+                    r[a] !== c[a] && (t.dataset[a] = c[a], r[a] = c[a]);
+                } else
+                  for (const c in r)
+                    delete t.dataset[c];
+              },
+              this.getKey(e)
+            );
+            break;
+          case "autocomplete":
+          case "autocapitalize":
+            this.attachProp(
+              o,
+              (i) => {
+                typeof i == "string" ? t[e] = i : i ? t[e] = "on" : t[e] = "off";
+              },
+              this.getKey(e)
+            );
+            break;
+          default: {
+            this.attachProp(
+              o,
+              (i) => {
+                t[e] = i;
+              },
+              this.getKey(e)
+            );
+            break;
+          }
+        }
+    }
+  }
+  applyStyles(t, s, e) {
+    const o = [];
+    if (u(s)) {
+      let r;
+      const i = m(() => {
+        u(r) && r(), t.style.cssText = "", r = this.applyStyles(t, w(s), e);
+      });
+      e.push(i), o.push(i);
+    } else {
+      const r = W(s);
+      for (const i in r) {
+        const { value: c, priority: a } = r[i];
+        if (u(c)) {
+          const g = m(() => {
+            w(c) ? t.style.setProperty(i, String(A(w(c))), a) : t.style.removeProperty(i);
+          });
+          e.push(g), o.push(g);
+        } else c != null && t.style.setProperty(i, String(A(c)));
+      }
+    }
+    return function() {
+      for (const i of o)
+        i(), e.splice(e.indexOf(i), 1);
+    };
+  }
+  applyClasses(t, s, e) {
+    const o = [];
+    if (u(s)) {
+      let r;
+      const i = m(() => {
+        u(r) && r(), t.removeAttribute("class"), r = this.applyClasses(t, w(s), e);
+      });
+      e.push(i), o.push(i);
+    } else {
+      const r = K(s);
+      for (const i in r) {
+        const c = r[i];
+        if (u(c)) {
+          const a = m(() => {
+            w(c) ? t.classList.add(i) : t.classList.remove(i);
+          });
+          e.push(a), o.push(a);
+        } else c && t.classList.add(i);
+      }
+    }
+    return function() {
+      for (const i of o)
+        i(), e.splice(e.indexOf(i), 1);
+    };
+  }
+}
+function K(n) {
+  let t = {};
+  if (O(n)) {
+    const s = n.split(" ");
+    for (const e of s)
+      t[e] = !0;
+  } else L(n) ? Object.assign(t, n) : Array.isArray(n) && Array.from(n).filter(Boolean).forEach((s) => {
+    Object.assign(t, K(s));
+  });
+  return delete t.undefined, t;
+}
+function W(n) {
+  let t = {};
+  if (O(n)) {
+    const s = n.split(";").filter((e) => e.trim() !== "");
+    for (const e of s) {
+      const [o, r] = e.split(":"), i = {
+        value: r
+      };
+      r.includes("!important") ? (i.priority = "important", i.value = r.replace("!important", "").trim()) : i.value = r.trim(), t[R(o.trim())] = i;
+    }
+  }
+  if (L(n))
+    for (const s in n)
+      s.startsWith("--") ? t[s] = { value: n[s] } : t[R(s)] = { value: n[s] };
+  else Array.isArray(n) && Array.from(n).filter((s) => s != null).forEach((s) => {
+    Object.assign(t, W(s));
+  });
+  return t;
+}
+function P() {
+  const n = this.getRoot();
+  if (n == null) return this.tag;
+  let t = this.getRoot().tagName.toLowerCase();
+  if (n.id && (t += `#${n.id}`), n.classList.length > 0)
+    for (const s of n.classList.values())
+      t += `.${s}`;
+  return t;
+}
+function R(n) {
+  return n.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, s) => (s ? "-" : "") + t.toLowerCase());
+}
+function A(n) {
+  return F(n) ? `${n}px` : n;
+}
+const at = [
+  // 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 ht extends x {
+  context;
+  value;
+  parent;
+  node;
+  constructor(t, s, e) {
+    super(), this.context = t, this.value = s, this.parent = e;
+  }
+  getRoot() {
+    return this.node?.getRoot();
+  }
+  isMounted() {
+    return this.node ? this.node.isMounted() : !1;
+  }
+  mount(t, s) {
+    const e = V(this.value, this.context);
+    this.node = e, e.mount(this.parent);
+  }
+  unmount(t = !1) {
+    this.node?.isMounted() && this.node.unmount(!1);
+  }
+  move(t, s) {
+  }
+}
+function p(n) {
+  const t = X();
+  if (!t)
+    throw new Error("No context found; hooks can only be called in the body of a View, Store or Mixin.");
+  return n != null && t.setName(n), t;
+}
+function yt(n) {
+  return p().useStore(n);
+}
+function wt(n, t) {
+  return p().provideStore(n, t).useStore(n);
+}
+function xt(n) {
+  const t = p();
+  t.onLifecycleTransition("didMount", () => {
+    const s = n();
+    s && t.onLifecycleTransition("didUnmount", s);
+  });
+}
+function vt(n) {
+  p().onLifecycleTransition("didUnmount", n);
+}
+function ut(n, t) {
+  return p(), J(n, t);
+}
+function Nt(n, t, s) {
+  return p(), Q(n, { ...s, deps: t });
+}
+function kt(n, t) {
+  const [s, e] = ut(t);
+  return [s, (r) => {
+    e((i) => n(i, r));
+  }];
+}
+function Mt(n, t) {
+  const s = p();
+  t ? s.effect(() => {
+    for (const e of t) w(e);
+    return v(n);
+  }) : s.effect(n);
+}
+function St(...n) {
+  p();
+  const t = ot(...n);
+  return Object.defineProperty(t, "current", { get: t, set: t }), t;
+}
+class lt extends x {
+  root = document.createTextNode("");
+  context;
+  items;
+  key;
+  render;
+  unsubscribe = null;
+  connectedItems = /* @__PURE__ */ new Map();
+  constructor(t, s, e, o) {
+    super(), this.context = t, this.items = s, this.key = e, this.render = o;
+  }
+  getRoot() {
+    return this.root;
+  }
+  isMounted() {
+    return this.root.parentElement != null;
+  }
+  mount(t, s) {
+    this.isMounted() || (t.insertBefore(this.root, s?.nextSibling ?? null), this.unsubscribe = m(() => {
+      let e = this.items();
+      e == null && (e = [], this.context.warn("repeat() received empty value for items", e)), v(() => {
+        this._update(Array.from(e));
+      });
+    }));
+  }
+  unmount(t = !1) {
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = null), !t && this.isMounted() && this.root.parentNode?.removeChild(this.root), this._cleanup(!0);
+  }
+  move(t, s) {
+    return this.mount(t, s);
+  }
+  _cleanup(t) {
+    for (const s of this.connectedItems.values())
+      s.node.unmount(t);
+    this.connectedItems.clear();
+  }
+  _update(t) {
+    if (t.length === 0 || !this.isMounted())
+      return this._cleanup(!1);
+    const s = /* @__PURE__ */ new Map();
+    let e = 0;
+    for (const i of t) {
+      const c = this.key(i, e);
+      s.set(c, {
+        key: c,
+        value: i,
+        index: e++
+      });
+    }
+    const o = [];
+    for (const i of this.connectedItems.values())
+      !s.has(i.key) && i.node.isMounted() && i.node.unmount(!1);
+    tt(() => {
+      for (const i of s.values()) {
+        const c = this.connectedItems.get(i.key);
+        if (c && c.node.isMounted())
+          c.item.set(i.value), c.index.set(i.index), o[i.index] = c;
+        else {
+          const a = U(i.value, { equals: et }), g = U(i.index);
+          o[i.index] = {
+            key: i.key,
+            item: a,
+            index: g,
+            node: new B(this.context, ft, {
+              item: () => a(),
+              index: () => g(),
+              render: this.render
+            })
+          };
+        }
+      }
+    });
+    for (let i = 0; i < o.length; i++) {
+      const c = o[i], a = o[i - 1]?.node.getRoot() ?? this.root, g = this.connectedItems.get(c.key);
+      g && g.node.isMounted() ? c.node.move(this.root.parentElement, a) : c.node.mount(this.root.parentElement, a);
+    }
+    this.connectedItems.clear();
+    for (const i of o)
+      this.connectedItems.set(i.key, i);
+    const r = o.at(-1)?.node.getRoot() ?? this.root;
+    this.root.parentNode?.insertBefore(this.root, r.nextSibling);
+  }
+}
+const dt = "dolla.RepeatItemView";
+function ft(n) {
+  return p(dt), n.render(n.item, n.index);
+}
+class j {
+  /**
+   * 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 ""
+   */
+  type;
+  /**
+   * Data that will be passed to a new MarkupNode instance when it is constructed.
+   * Includes a `children` prop if children were passed.
+   */
+  props;
+  constructor(t, s) {
+    this.type = t, this.props = s;
+  }
+}
+var mt = /* @__PURE__ */ ((n) => (n.DOM = "$dom", n.Dynamic = "$dynamic", n.Portal = "$portal", n.Repeat = "$repeat", n))(mt || {});
+function Et(n, t) {
+  return new j(n, t ?? {});
+}
+function V(n, t = new h("$")) {
+  const s = C(t, n);
+  return s.length === 1 ? s[0] : new E(t, () => s);
+}
+function C(n, ...t) {
+  const s = t.flat(1 / 0), e = [];
+  for (const o of s)
+    if (!(o == null || o === !1)) {
+      if (o instanceof Node) {
+        e.push(new M(o));
+        continue;
+      }
+      if (o instanceof j)
+        if (u(o.type)) {
+          e.push(new B(n, o.type, o.props));
+          continue;
+        } else if (O(o.type))
+          switch (o.type) {
+            case "$dom": {
+              const r = o.props;
+              e.push(new M(r.value));
+              continue;
+            }
+            case "$dynamic": {
+              const r = o.props;
+              e.push(new E(n, r.source));
+              continue;
+            }
+            case "$portal": {
+              const r = o.props;
+              e.push(new ht(n, r.content, r.parent));
+              continue;
+            }
+            case "$repeat": {
+              const r = o.props;
+              e.push(new lt(n, r.items, r.key, r.render));
+              continue;
+            }
+            default:
+              e.push(new ct(n, o.type, o.props));
+              continue;
+          }
+        else
+          throw new TypeError(`Expected a string or view function. Got: ${o.type}`);
+      if (o instanceof x) {
+        e.push(o);
+        continue;
+      }
+      if (u(o)) {
+        e.push(new E(n, o));
+        continue;
+      }
+      e.push(new M(document.createTextNode(String(o))));
+    }
+  return e;
+}
+export {
+  h as C,
+  E as D,
+  d as L,
+  j as M,
+  lt as R,
+  B as V,
+  mt as a,
+  bt as b,
+  Et as c,
+  x as d,
+  ot as e,
+  yt as f,
+  wt as g,
+  xt as h,
+  vt as i,
+  ut as j,
+  Nt as k,
+  kt as l,
+  Mt as m,
+  St as n,
+  V as r,
+  p as u
+};
+//# sourceMappingURL=markup-8jNhoqDe.js.map