@mateosuarezdev/flash 0.0.1

package/dist/index.js

@@ -0,0 +1,1335 @@
+/**
+ * @license
+ * Flash
+ * Copyright (c) 2025 Mateo Suarez. All rights reserved.
+ *
+ * Free to use in your own personal or commercial applications and projects.
+ * Unauthorized copying, modification, or distribution is strictly prohibited.
+ * See LICENSE file for full terms.
+ */
+
+import { n as L, s as w, g as I, c as m } from "./jsx-dev-runtime-BfTCjShK.js";
+import { F as $e } from "./jsx-dev-runtime-BfTCjShK.js";
+var R = Symbol.for("preact-signals");
+function T() {
+  if (p > 1)
+    p--;
+  else {
+    for (var t, e = !1; S !== void 0; ) {
+      var i = S;
+      for (S = void 0, A++; i !== void 0; ) {
+        var n = i.o;
+        if (i.o = void 0, i.f &= -3, !(8 & i.f) && H(i)) try {
+          i.c();
+        } catch (r) {
+          e || (t = r, e = !0);
+        }
+        i = n;
+      }
+    }
+    if (A = 0, p--, e) throw t;
+  }
+}
+function Ce(t) {
+  if (p > 0) return t();
+  p++;
+  try {
+    return t();
+  } finally {
+    T();
+  }
+}
+var c = void 0;
+function K(t) {
+  var e = c;
+  c = void 0;
+  try {
+    return t();
+  } finally {
+    c = e;
+  }
+}
+var S = void 0, p = 0, A = 0, E = 0;
+function G(t) {
+  if (c !== void 0) {
+    var e = t.n;
+    if (e === void 0 || e.t !== c)
+      return e = { i: 0, S: t, p: c.s, n: void 0, t: c, e: void 0, x: void 0, r: e }, c.s !== void 0 && (c.s.n = e), c.s = e, t.n = e, 32 & c.f && t.S(e), e;
+    if (e.i === -1)
+      return e.i = 0, e.n !== void 0 && (e.n.p = e.p, e.p !== void 0 && (e.p.n = e.n), e.p = c.s, e.n = void 0, c.s.n = e, c.s = e), e;
+  }
+}
+function u(t, e) {
+  this.v = t, this.i = 0, this.n = void 0, this.t = void 0, this.W = e?.watched, this.Z = e?.unwatched, this.name = e?.name;
+}
+u.prototype.brand = R;
+u.prototype.h = function() {
+  return !0;
+};
+u.prototype.S = function(t) {
+  var e = this, i = this.t;
+  i !== t && t.e === void 0 && (t.x = i, this.t = t, i !== void 0 ? i.e = t : K(function() {
+    var n;
+    (n = e.W) == null || n.call(e);
+  }));
+};
+u.prototype.U = function(t) {
+  var e = this;
+  if (this.t !== void 0) {
+    var i = t.e, n = t.x;
+    i !== void 0 && (i.x = n, t.e = void 0), n !== void 0 && (n.e = i, t.x = void 0), t === this.t && (this.t = n, n === void 0 && K(function() {
+      var r;
+      (r = e.Z) == null || r.call(e);
+    }));
+  }
+};
+u.prototype.subscribe = function(t) {
+  var e = this;
+  return g(function() {
+    var i = e.value, n = c;
+    c = void 0;
+    try {
+      t(i);
+    } finally {
+      c = n;
+    }
+  }, { name: "sub" });
+};
+u.prototype.valueOf = function() {
+  return this.value;
+};
+u.prototype.toString = function() {
+  return this.value + "";
+};
+u.prototype.toJSON = function() {
+  return this.value;
+};
+u.prototype.peek = function() {
+  var t = c;
+  c = void 0;
+  try {
+    return this.value;
+  } finally {
+    c = t;
+  }
+};
+Object.defineProperty(u.prototype, "value", { get: function() {
+  var t = G(this);
+  return t !== void 0 && (t.i = this.i), this.v;
+}, set: function(t) {
+  if (t !== this.v) {
+    if (A > 100) throw new Error("Cycle detected");
+    this.v = t, this.i++, E++, p++;
+    try {
+      for (var e = this.t; e !== void 0; e = e.x) e.t.N();
+    } finally {
+      T();
+    }
+  }
+} });
+function we(t, e) {
+  return new u(t, e);
+}
+function H(t) {
+  for (var e = t.s; e !== void 0; e = e.n) if (e.S.i !== e.i || !e.S.h() || e.S.i !== e.i) return !0;
+  return !1;
+}
+function X(t) {
+  for (var e = t.s; e !== void 0; e = e.n) {
+    var i = e.S.n;
+    if (i !== void 0 && (e.r = i), e.S.n = e, e.i = -1, e.n === void 0) {
+      t.s = e;
+      break;
+    }
+  }
+}
+function j(t) {
+  for (var e = t.s, i = void 0; e !== void 0; ) {
+    var n = e.p;
+    e.i === -1 ? (e.S.U(e), n !== void 0 && (n.n = e.n), e.n !== void 0 && (e.n.p = n)) : i = e, e.S.n = e.r, e.r !== void 0 && (e.r = void 0), e = n;
+  }
+  t.s = i;
+}
+function y(t, e) {
+  u.call(this, void 0), this.x = t, this.s = void 0, this.g = E - 1, this.f = 4, this.W = e?.watched, this.Z = e?.unwatched, this.name = e?.name;
+}
+y.prototype = new u();
+y.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === E)) return !0;
+  if (this.g = E, this.f |= 1, this.i > 0 && !H(this))
+    return this.f &= -2, !0;
+  var t = c;
+  try {
+    X(this), c = this;
+    var e = this.x();
+    (16 & this.f || this.v !== e || this.i === 0) && (this.v = e, this.f &= -17, this.i++);
+  } catch (i) {
+    this.v = i, this.f |= 16, this.i++;
+  }
+  return c = t, j(this), this.f &= -2, !0;
+};
+y.prototype.S = function(t) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (var e = this.s; e !== void 0; e = e.n) e.S.S(e);
+  }
+  u.prototype.S.call(this, t);
+};
+y.prototype.U = function(t) {
+  if (this.t !== void 0 && (u.prototype.U.call(this, t), this.t === void 0)) {
+    this.f &= -33;
+    for (var e = this.s; e !== void 0; e = e.n) e.S.U(e);
+  }
+};
+y.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var t = this.t; t !== void 0; t = t.x) t.t.N();
+  }
+};
+Object.defineProperty(y.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var t = G(this);
+  if (this.h(), t !== void 0 && (t.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} });
+function Ee(t, e) {
+  return new y(t, e);
+}
+function Y(t) {
+  var e = t.u;
+  if (t.u = void 0, typeof e == "function") {
+    p++;
+    var i = c;
+    c = void 0;
+    try {
+      e();
+    } catch (n) {
+      throw t.f &= -2, t.f |= 8, x(t), n;
+    } finally {
+      c = i, T();
+    }
+  }
+}
+function x(t) {
+  for (var e = t.s; e !== void 0; e = e.n) e.S.U(e);
+  t.x = void 0, t.s = void 0, Y(t);
+}
+function q(t) {
+  if (c !== this) throw new Error("Out-of-order effect");
+  j(this), c = t, this.f &= -2, 8 & this.f && x(this), T();
+}
+function v(t, e) {
+  this.x = t, this.u = void 0, this.s = void 0, this.o = void 0, this.f = 32, this.name = e?.name;
+}
+v.prototype.c = function() {
+  var t = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    var e = this.x();
+    typeof e == "function" && (this.u = e);
+  } finally {
+    t();
+  }
+};
+v.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, Y(this), X(this), p++;
+  var t = c;
+  return c = this, q.bind(this, t);
+};
+v.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.o = S, S = this);
+};
+v.prototype.d = function() {
+  this.f |= 8, 1 & this.f || x(this);
+};
+v.prototype.dispose = function() {
+  this.d();
+};
+function g(t, e) {
+  var i = new v(t, e);
+  try {
+    i.c();
+  } catch (r) {
+    throw i.d(), r;
+  }
+  var n = i.d.bind(i);
+  return n[Symbol.dispose] = n, n;
+}
+function Te(t) {
+  return t instanceof u ? t.peek() : t;
+}
+function Ne(t) {
+  return t instanceof u ? t.value : t;
+}
+function Ae(t, e) {
+  typeof e == "function" ? t.value = e() : t.value = e;
+}
+function xe(t) {
+  return t instanceof u ? () => t.value : t;
+}
+function Z(t, e, i = !1) {
+  const n = [];
+  for (const [r, s] of Object.entries(e))
+    if (s != null && !(r === "children" || r === "key" || r === "autoanimate")) {
+      if (typeof s == "function" && r !== "ref" && !r.startsWith("on") && r !== "viewTransitionName") {
+        const o = g(() => {
+          const a = s();
+          D(t, r, a, i);
+        });
+        n.push(o);
+        continue;
+      }
+      D(t, r, s, i);
+    }
+  return () => n.forEach((r) => r());
+}
+function D(t, e, i, n) {
+  if (e === "ref" && typeof i == "function") {
+    i(t);
+    return;
+  }
+  if (e.startsWith("on") && typeof i == "function") {
+    const r = e.slice(2).toLowerCase();
+    t.addEventListener(r, i);
+    return;
+  }
+  if (e === "class" || e === "className") {
+    const r = typeof i == "string" ? i : Array.isArray(i) ? i.filter(Boolean).join(" ") : typeof i == "object" ? Object.entries(i).filter(([s, o]) => o).map(([s]) => s).join(" ") : "";
+    n ? t.setAttribute("class", r) : t.className = r;
+    return;
+  }
+  if (e === "style") {
+    typeof i == "string" ? t.setAttribute("style", i) : typeof i == "object" && i && Object.assign(t.style, i);
+    return;
+  }
+  if (e === "viewTransitionName") {
+    t.style.viewTransitionName = i;
+    return;
+  }
+  if (!n && typeof i == "boolean") {
+    i ? t.setAttribute(e, "") : t.removeAttribute(e);
+    return;
+  }
+  t.setAttribute(e, String(i));
+}
+function J(t, e) {
+  const i = document.createTextNode(String(e));
+  t.appendChild(i);
+}
+function V(t) {
+  return {
+    type: "reactive",
+    kind: "ReactiveVNode",
+    fn: t,
+    _id: L(),
+    _dispose: null,
+    _currentChild: null,
+    _currentDom: null,
+    _placeholder: null,
+    _parent: null,
+    _renderedChildren: []
+  };
+}
+function k(t, e) {
+  if (!t && t !== 0)
+    return { vnode: null, dom: null };
+  if (typeof t == "string" || typeof t == "number" || typeof t == "boolean")
+    return { vnode: null, dom: document.createTextNode(String(t)) };
+  if (t instanceof Node)
+    return { vnode: null, dom: t };
+  if (typeof t == "object" && "type" in t) {
+    const i = t;
+    i.type !== "reactive" && (i._parent = e), e._renderedChildren.push(i);
+    const n = _(i);
+    return { vnode: i, dom: n };
+  }
+  return { vnode: null, dom: null };
+}
+class M {
+  _cancelled = !1;
+  _cancelCallbacks = [];
+  get cancelled() {
+    return this._cancelled;
+  }
+  cancel() {
+    this._cancelled || (this._cancelled = !0, this._cancelCallbacks.forEach((e) => {
+      try {
+        e();
+      } catch (i) {
+        console.error("Cancel callback error:", i);
+      }
+    }), this._cancelCallbacks = []);
+  }
+  onCancel(e) {
+    this._cancelled ? e() : this._cancelCallbacks.push(e);
+  }
+  throwIfCancelled() {
+    if (this._cancelled)
+      throw new Error("Operation cancelled");
+  }
+}
+async function U(t, e) {
+  if (!t) return;
+  const i = t, n = e || new M();
+  if ("_onBeforeExitCallbacks" in i && i._onBeforeExitCallbacks.length > 0)
+    for (const r of i._onBeforeExitCallbacks)
+      try {
+        if (n.cancelled)
+          break;
+        await r(n);
+      } catch (s) {
+        console.error("onBeforeExit error:", s);
+      }
+  if ("_onUnmountCallbacks" in i && i._onUnmountCallbacks.length > 0 && i._onUnmountCallbacks.forEach((r) => {
+    try {
+      r();
+    } catch (s) {
+      console.error("onUnmount error:", s);
+    }
+  }), i.type === "reactive") {
+    const r = i;
+    r._dispose && (r._dispose(), r._dispose = null);
+  }
+  "_renderedChildren" in i && i._renderedChildren.forEach((r) => {
+    $(r);
+  });
+}
+function $(t) {
+  if (!t) return;
+  const e = t, i = new M();
+  if (i.cancel(), "_onBeforeExitCallbacks" in e && e._onBeforeExitCallbacks.length > 0 && e._onBeforeExitCallbacks.forEach((n) => {
+    try {
+      const r = n(i);
+      r instanceof Promise && r.catch((s) => console.error("onBeforeExit error:", s));
+    } catch (r) {
+      console.error("onBeforeExit error:", r);
+    }
+  }), "_onUnmountCallbacks" in e && e._onUnmountCallbacks.length > 0 && e._onUnmountCallbacks.forEach((n) => {
+    try {
+      n();
+    } catch (r) {
+      console.error("onUnmount error:", r);
+    }
+  }), e.type === "reactive") {
+    const n = e;
+    n._dispose && (n._dispose(), n._dispose = null);
+  }
+  "_renderedChildren" in e && e._renderedChildren.forEach((n) => {
+    $(n);
+  });
+}
+let Q = 0;
+const h = /* @__PURE__ */ new WeakMap();
+async function O(t, e, i) {
+  const n = t._placeholder;
+  if (!n?.parentNode) return;
+  const r = t._currentChild, s = t._currentDom;
+  if (ee(r, e)) {
+    const f = h.get(t);
+    f && (f.token.cancel(), h.delete(t)), r && "_lifecycleState" in r && (r._lifecycleState = "mounted");
+    return;
+  }
+  if (s instanceof Text && i instanceof Text) {
+    s.nodeValue !== i.nodeValue && (s.nodeValue = i.nodeValue), t._currentDom = s, t._currentChild = e, e && "_lifecycleState" in e && (e._lifecycleState = "mounted"), h.delete(t);
+    return;
+  }
+  const o = ++Q, a = h.get(t);
+  a && a.token.cancel();
+  const l = new M();
+  if (h.set(t, { id: o, token: l }), r && "_lifecycleState" in r && (r._lifecycleState = "exiting"), r)
+    try {
+      await U(r, l);
+    } catch (f) {
+      console.error(`ReactiveVNode ${t._id}: Unmount threw:`, f);
+    }
+  const d = h.get(t);
+  if (!(!d || d.id !== o)) {
+    if (l.cancelled) {
+      h.delete(t);
+      return;
+    }
+    r && "_lifecycleState" in r && (r._lifecycleState = "exited"), s && s.remove(), i && n.parentNode.insertBefore(i, n.nextSibling), e && "_lifecycleState" in e && (e._lifecycleState = "mounted"), t._currentChild = e, t._currentDom = i, h.delete(t);
+  }
+}
+function ee(t, e) {
+  if (!t || !e || typeof t != "object" || typeof e != "object" || !("type" in t) || !("type" in e)) return !1;
+  if (typeof t.type == "function" && typeof e.type == "function") {
+    if (t.type !== e.type) return !1;
+  } else if (typeof t.type == "string" && typeof e.type == "string") {
+    if (t.type !== e.type) return !1;
+  } else
+    return !1;
+  const i = "props" in t ? t.props?.key : void 0, n = "props" in e ? e.props?.key : void 0;
+  return i !== n ? !1 : "_lifecycleState" in t && t._lifecycleState === "exiting";
+}
+function te(t, e) {
+  const i = t._listState;
+  i ? ne(t, e, i) : ie(t, e);
+}
+function ie(t, e) {
+  const i = t._placeholder;
+  if (!i?.parentNode) return;
+  const n = [];
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r], o = P(s, r), { vnode: a, dom: l } = k(s, t);
+    l && i.parentNode.appendChild(l), n.push({ key: o, vnode: a, dom: l });
+  }
+  t._listState = { items: n };
+}
+function ne(t, e, i) {
+  const n = t._placeholder;
+  if (!n?.parentNode) return;
+  const r = /* @__PURE__ */ new Map();
+  for (const a of i.items)
+    r.set(a.key, a);
+  const s = /* @__PURE__ */ new Set(), o = [];
+  for (let a = 0; a < e.length; a++) {
+    const l = e[a], d = P(l, a);
+    s.add(d);
+    const f = r.get(d);
+    f ? (o.push(f), r.delete(d)) : re(t, l, o);
+  }
+  r.size > 0 && se(r), oe(n, o), t._listState = { items: o };
+}
+function re(t, e, i) {
+  const n = P(e, i.length), { vnode: r, dom: s } = k(e, t);
+  i.push({ key: n, vnode: r, dom: s });
+}
+function se(t) {
+  for (const [e, i] of t)
+    i.vnode && U(i.vnode), i.dom?.parentNode && i.dom.parentNode.removeChild(i.dom);
+}
+function oe(t, e) {
+  const i = t.parentNode;
+  if (!i) return;
+  let n = t;
+  for (const r of e)
+    r.dom && (n.nextSibling !== r.dom && i.insertBefore(r.dom, n.nextSibling), n = r.dom);
+}
+function P(t, e) {
+  return t && typeof t == "object" && "key" in t ? t.key ?? e : e;
+}
+function B(t, e, i = null, n = !1) {
+  if (!e) return;
+  (Array.isArray(e) ? e : [e]).forEach((s) => {
+    if (s) {
+      if (Array.isArray(s) && B(t, s, i, n), typeof s == "string" || typeof s == "number")
+        J(t, s);
+      else if (typeof s == "function") {
+        const o = V(s);
+        o._parent = i, i && i._renderedChildren.push(o);
+        const a = document.createComment("reactive");
+        t.appendChild(a), o._placeholder = a;
+        const l = g(() => {
+          const d = s();
+          if (Array.isArray(d))
+            te(o, d);
+          else {
+            const { vnode: f, dom: N } = k(d, o);
+            O(o, f, N);
+          }
+        });
+        o._dispose = l;
+      } else if (s instanceof Node)
+        t.append(s);
+      else if (s && typeof s == "object" && "type" in s) {
+        const o = s;
+        "type" in o && o.type !== "reactive" && (o._parent = i), i && i._renderedChildren.push(o);
+        const a = _(o, n);
+        a && t.append(a);
+      }
+    }
+  });
+}
+const ae = "http://www.w3.org/2000/svg";
+function W(t, e = !1) {
+  if (t._dom)
+    return t._dom;
+  const i = e || t.type === "svg", n = i ? document.createElementNS(ae, t.type) : document.createElement(t.type), r = Z(n, t.props, i);
+  return t._onUnmountCallbacks.push(r), t.props.children && B(n, t.props.children, t, i), t._dom = n, t._lifecycleState = "mounted", t._onMountCallbacks.length > 0 && t._onMountCallbacks.forEach((s) => s()), n;
+}
+function _(t, e = !1) {
+  if ("type" in t && t.type === "reactive")
+    return t._placeholder;
+  if (typeof t.type == "string")
+    return W(t, e);
+  const i = t;
+  w(i);
+  const n = i.type(i.props);
+  if (w(null), !n) return null;
+  let r = null;
+  if (typeof n == "string" || typeof n == "number" || typeof n == "boolean")
+    r = document.createTextNode(String(n));
+  else if (n instanceof Node)
+    i._element = n, r = n;
+  else if (n && typeof n == "object" && "type" in n) {
+    const s = n;
+    "type" in s && s.type !== "reactive" && (s._parent = i, i._renderedChildren.push(s));
+    const o = _(s, e);
+    o && (i._element = o), r = o;
+  }
+  return r && i._onMountCallbacks.length > 0 && i._onMountCallbacks.forEach((s) => {
+    s();
+  }), r && (i._lifecycleState = "mounted"), r;
+}
+function Me(t, e) {
+  const i = t instanceof Node ? t : _(t);
+  i && e.append(i);
+}
+function le(t) {
+  return document.createTreeWalker(
+    t,
+    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+    null
+  );
+}
+function ce(t, e = "self") {
+  const i = le(t);
+  return e === "children" && i.firstChild(), {
+    walker: i,
+    isSVG: !1
+  };
+}
+function ue(t, e, i, n) {
+  if (e === "class" || e === "className") {
+    const r = typeof i == "string" ? i : Array.isArray(i) ? i.filter(Boolean).join(" ") : typeof i == "object" ? Object.entries(i).filter(([s, o]) => o).map(([s]) => s).join(" ") : "";
+    n ? t.setAttribute("class", r) : t.className = r;
+    return;
+  }
+  if (e === "style") {
+    typeof i == "string" ? t.setAttribute("style", i) : typeof i == "object" && i && Object.assign(t.style, i);
+    return;
+  }
+  if (e === "viewTransitionName") {
+    t.style.viewTransitionName = i;
+    return;
+  }
+  if (!n && typeof i == "boolean") {
+    i ? t.setAttribute(e, "") : t.removeAttribute(e);
+    return;
+  }
+  t.setAttribute(e, String(i));
+}
+function fe(t, e, i = !1, n) {
+  const r = [];
+  for (const [s, o] of Object.entries(e))
+    if (o != null && !(s === "children" || s === "key" || s === "autoanimate")) {
+      if (s === "ref" && typeof o == "function") {
+        n && console.log("→ Attaching ref"), o(t);
+        continue;
+      }
+      if (s.startsWith("on") && typeof o == "function") {
+        const a = s.slice(2).toLowerCase();
+        n && console.log(`→ Attaching event: ${a}`), t.addEventListener(a, o);
+        continue;
+      }
+      if (typeof o == "function" && s !== "ref" && s !== "viewTransitionName") {
+        n && console.log(`→ Reactive prop: ${s}`);
+        const a = g(() => {
+          const l = o();
+          ue(t, s, l, i);
+        });
+        r.push(a);
+        continue;
+      }
+    }
+  return () => r.forEach((s) => s());
+}
+function de(t, e, i = null, n) {
+  if (!e) return;
+  const r = Array.isArray(e) ? e : [e];
+  if (!n.walker.firstChild() && r.length > 0) {
+    console.warn("Hydration mismatch: VNode has children but DOM is empty");
+    return;
+  }
+  for (const o of r)
+    !o && o !== 0 || he(o, t, i, n);
+  n.walker.parentNode();
+}
+function he(t, e, i, n) {
+  if (!(!t && t !== 0)) {
+    if (typeof t == "string" || typeof t == "number" || typeof t == "boolean") {
+      const r = n.walker.currentNode;
+      r.nodeType === Node.TEXT_NODE ? (n.debug && console.log("→ Hydrated text node"), n.walker.nextSibling()) : console.warn(
+        `Hydration mismatch: expected text node but found ${r.nodeName}`
+      );
+      return;
+    }
+    if (typeof t == "function") {
+      n.debug && console.log("→ Hydrating reactive child");
+      const r = V(t);
+      r._parent = i, i && i._renderedChildren.push(r);
+      const s = n.walker.currentNode, o = t();
+      if (o && typeof o == "object" && "type" in o) {
+        const f = o;
+        b(f, n), r._currentChild = f, r._currentDom = f._dom ?? f._element;
+      } else (typeof o == "string" || typeof o == "number" || typeof o == "boolean") && (r._currentDom = s), n.walker.nextSibling();
+      const a = document.createComment("reactive");
+      r._currentDom?.parentNode && r._currentDom.parentNode.insertBefore(
+        a,
+        r._currentDom
+      ), r._placeholder = a;
+      let l = !0;
+      const d = g(() => {
+        const f = t();
+        if (l) {
+          l = !1;
+          return;
+        }
+        const { vnode: N, dom: z } = k(f, r);
+        O(r, N, z);
+      });
+      r._dispose = d;
+      return;
+    }
+    if (t instanceof Node) {
+      n.walker.nextSibling();
+      return;
+    }
+    if (t && typeof t == "object" && "type" in t) {
+      const r = t;
+      "type" in r && r.type !== "reactive" && r.type !== "suspended" && (r._parent = i), i && i._renderedChildren.push(r), b(r, n);
+    }
+  }
+}
+function pe(t, e) {
+  const i = e.walker.currentNode;
+  if (i.nodeType !== Node.ELEMENT_NODE)
+    return console.warn(
+      `Hydration mismatch: expected element <${t.type}> but found ${i.nodeName}`
+    ), F(t, i, e);
+  const n = i, r = n.tagName.toLowerCase();
+  if (r !== t.type.toLowerCase())
+    return console.warn(
+      `Hydration mismatch: expected <${t.type}> but found <${r}>`
+    ), F(t, i, e);
+  const s = e.isSVG || t.type === "svg", o = e.isSVG;
+  e.isSVG = s, t._dom = n, e.debug && console.log(`→ Attached existing <${t.type}> DOM`);
+  const a = fe(n, t.props, s, e.debug);
+  return t._onUnmountCallbacks.push(a), t.props.children && de(n, t.props.children, t, e), t._lifecycleState = "mounted", t._onMountCallbacks.length > 0 && t._onMountCallbacks.forEach((l) => l()), e.isSVG = o, e.walker.nextSibling(), n;
+}
+function F(t, e, i) {
+  i.debug && console.log(`→ Fallback: rendering <${t.type}> fresh`);
+  const n = e.parentNode, r = e.nextSibling;
+  n?.removeChild(e);
+  const s = W(t, i.isSVG);
+  return n && (r ? n.insertBefore(s, r) : n.appendChild(s)), i.walker.nextSibling(), s;
+}
+function b(t, e) {
+  if ("type" in t && t.type === "reactive")
+    return e.debug && console.log(`Hydrating ReactiveVNode #${t._id}`), me(t, e);
+  if ("type" in t && t.type === "suspended")
+    return e.debug && console.log(
+      `Hydrating SuspendedVNode: ${t._componentName}`
+    ), be(t, e);
+  if (typeof t.type == "string")
+    return e.debug && console.log(`Hydrating <${t.type}>`), pe(t, e);
+  const i = t.type.name || "Anonymous";
+  return e.debug && console.log(`Hydrating Component: ${i}`), ye(t, e);
+}
+function ye(t, e) {
+  w(t);
+  const i = t.type(t.props);
+  if (w(null), !i) return null;
+  if (typeof i == "object" && "type" in i && i.type === "suspended")
+    return b(i, e);
+  let n = null;
+  if (typeof i == "string" || typeof i == "number" || typeof i == "boolean") {
+    const r = e.walker.currentNode;
+    r.nodeType === Node.TEXT_NODE && (t._element = r, n = r, e.walker.nextSibling());
+  } else if (i instanceof Node)
+    t._element = i, n = i, e.walker.nextSibling();
+  else if (i && typeof i == "object" && "type" in i) {
+    const r = i;
+    "type" in r && r.type !== "reactive" && (r._parent = t, t._renderedChildren.push(r));
+    const s = b(r, e);
+    s && (t._element = s), n = s;
+  }
+  return n && t._onMountCallbacks.length > 0 && (e.debug && console.log(
+    `→ Firing ${t._onMountCallbacks.length} onMount callback(s)`
+  ), t._onMountCallbacks.forEach((r) => r())), n && (t._lifecycleState = "mounted"), n;
+}
+function me(t, e) {
+  const i = t.fn(), n = e.walker.currentNode, r = document.createComment("reactive");
+  if (n.parentNode?.insertBefore(r, n), t._placeholder = r, i && typeof i == "object" && "type" in i) {
+    const a = i;
+    b(a, e), t._currentChild = a, t._currentDom = a._dom ?? a._element;
+  } else (typeof i == "string" || typeof i == "number" || typeof i == "boolean") && (t._currentDom = n), e.walker.nextSibling();
+  let s = !0;
+  const o = g(() => {
+    const a = t.fn();
+    if (s) {
+      s = !1, e.debug && console.log("→ Reactive effect setup (skipping initial)");
+      return;
+    }
+    const { vnode: l, dom: d } = k(a, t);
+    O(t, l, d);
+  });
+  return t._dispose = o, t._currentDom;
+}
+function be(t, e) {
+  const i = e.walker.currentNode;
+  if (i.nodeType === Node.ELEMENT_NODE && i.hasAttribute("data-suspended")) {
+    const r = i;
+    return r.getAttribute("data-suspended-state") === "resolved" ? (t._state = "resolved", e.walker.firstChild(), t.promise.then((o) => {
+      t._state = "resolved";
+    }).catch((o) => {
+      t._state = "error";
+      const a = typeof t.errorFallback == "function" ? t.errorFallback(o) : t.errorFallback;
+      r.innerHTML = "";
+      const l = C(a, e.isSVG);
+      l && r.appendChild(l);
+    }), e.walker.parentNode(), e.walker.nextSibling(), r) : (t._state = "pending", t.promise.then((o) => {
+      t._state = "resolved", r.innerHTML = "";
+      const a = C(o, e.isSVG);
+      a && r.appendChild(a);
+    }).catch((o) => {
+      t._state = "error";
+      const a = typeof t.errorFallback == "function" ? t.errorFallback(o) : t.errorFallback;
+      r.innerHTML = "";
+      const l = C(a, e.isSVG);
+      l && r.appendChild(l);
+    }), e.walker.nextSibling(), r);
+  }
+  console.warn("Hydration mismatch: expected suspended container");
+  const n = _(t, e.isSVG);
+  return e.walker.nextSibling(), n;
+}
+function C(t, e) {
+  return !t && t !== 0 ? null : typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? document.createTextNode(String(t)) : t instanceof Node ? t : typeof t == "object" && "type" in t ? _(
+    //todo handle suspendedvnode
+    //@ts-ignore
+    t,
+    e
+  ) : typeof t == "function" ? C(t(), e) : null;
+}
+function Oe(t, e, i = "self") {
+  const n = ce(e, i);
+  b(t, n);
+}
+function Pe(t, e = "Loading...", i = "Error") {
+  return (n) => ({
+    type: "suspended",
+    kind: "SuspendedVNode",
+    promise: t(n),
+    fallback: e,
+    errorFallback: i,
+    _id: L(),
+    _componentName: t.name || "AsyncComponent",
+    _parent: null,
+    _renderedChildren: [],
+    _currentChild: null,
+    _state: "pending"
+  });
+}
+function De(t) {
+  const e = Symbol("context");
+  return {
+    _id: e,
+    _defaultValue: t,
+    provide(i) {
+      if (typeof document > "u") return;
+      const n = I();
+      if (!n)
+        throw new Error("context.provide() called outside of component render");
+      n._contextMap || (n._contextMap = /* @__PURE__ */ new Map()), n._contextMap.set(e, i);
+    }
+  };
+}
+function Fe(t) {
+  if (typeof document > "u") return t._defaultValue;
+  const e = I();
+  if (!e)
+    throw new Error("useContext called outside of component render");
+  let i = e;
+  for (; i; ) {
+    if (i.kind === "VNode" && i._contextMap?.has(t._id))
+      return i._contextMap.get(t._id);
+    i = i._parent;
+  }
+  return t._defaultValue;
+}
+function Le(t) {
+  if (!(typeof document > "u")) {
+    if (m === null)
+      throw new Error("onMount must be called inside a component during render");
+    m._onMountCallbacks.push(t);
+  }
+}
+function Ie(t) {
+  if (!(typeof document > "u")) {
+    if (m === null)
+      throw new Error(
+        "onUnmount must be called inside a component during render"
+      );
+    m._onUnmountCallbacks.push(t);
+  }
+}
+function Ke(t) {
+  if (!(typeof document > "u")) {
+    if (m === null)
+      throw new Error(
+        "onBeforeExit must be called inside a component during render"
+      );
+    m._onBeforeExitCallbacks.push(t);
+  }
+}
+function Ge(t) {
+  if (!(typeof document > "u"))
+    try {
+      t();
+    } catch (e) {
+      console.error(e);
+    }
+}
+class He {
+  // One-time callbacks
+  readCallbacks = /* @__PURE__ */ new Set();
+  updateCallbacks = /* @__PURE__ */ new Set();
+  renderCallbacks = /* @__PURE__ */ new Set();
+  // Keep-alive callbacks (run every frame until cancelled)
+  readKeepAlive = /* @__PURE__ */ new Set();
+  updateKeepAlive = /* @__PURE__ */ new Set();
+  renderKeepAlive = /* @__PURE__ */ new Set();
+  isProcessing = !1;
+  frameScheduled = !1;
+  frameId = null;
+  lastTimestamp = 0;
+  currentDelta = 0;
+  // FPS tracking (optional)
+  trackFPS;
+  fpsHistorySize;
+  fpsHistory = [];
+  constructor(e = {}) {
+    this.trackFPS = e.trackFPS ?? !1, this.fpsHistorySize = e.fpsHistorySize ?? 60;
+  }
+  // --------------------------------------------------------------------------
+  // Public API
+  // --------------------------------------------------------------------------
+  /**
+   * Schedule a callback to run in the READ phase (for DOM measurements)
+   * Use this for: offsetHeight, getBoundingClientRect, getComputedStyle, etc.
+   *
+   * @param callback - Function to execute during the read phase
+   * @param keepAlive - If true, callback runs every frame until cancelled
+   * @returns The callback function (can be passed to cancelFrame)
+   *
+   * @example
+   * frame.read(() => {
+   *   const height = element.offsetHeight;
+   * });
+   *
+   * // With frame data if needed
+   * frame.read((data) => {
+   *   console.log('Delta:', data.delta);
+   * });
+   */
+  read(e, i = !1) {
+    return i ? this.readKeepAlive.add(e) : this.readCallbacks.add(e), this.scheduleFrame(), e;
+  }
+  /**
+   * Schedule a callback to run in the UPDATE phase (for calculations)
+   * Use this for: computing animation values, business logic, etc.
+   *
+   * @param callback - Function to execute during the update phase
+   * @param keepAlive - If true, callback runs every frame until cancelled
+   * @returns The callback function (can be passed to cancelFrame)
+   *
+   * @example
+   * frame.update(() => {
+   *   position += velocity;
+   * });
+   *
+   * // Delta-time independent animation
+   * frame.update((data) => {
+   *   position += velocity * (data.delta / 1000);
+   * }, true);
+   */
+  update(e, i = !1) {
+    return i ? this.updateKeepAlive.add(e) : this.updateCallbacks.add(e), this.scheduleFrame(), e;
+  }
+  /**
+   * Schedule a callback to run in the RENDER phase (for DOM writes)
+   * Use this for: style updates, classList changes, DOM mutations, etc.
+   *
+   * @param callback - Function to execute during the render phase
+   * @param keepAlive - If true, callback runs every frame until cancelled
+   * @returns The callback function (can be passed to cancelFrame)
+   *
+   * @example
+   * frame.render(() => {
+   *   element.style.transform = `translateX(${x}px)`;
+   * });
+   */
+  render(e, i = !1) {
+    return i ? this.renderKeepAlive.add(e) : this.renderCallbacks.add(e), this.scheduleFrame(), e;
+  }
+  chain(e) {
+    let i, n;
+    "read" in e && this.readCallbacks.add((r) => {
+      i = e.read(r);
+    }), "update" in e ? (this.updateCallbacks.add((r) => {
+      n = e.update(
+        i,
+        r
+      );
+    }), this.renderCallbacks.add((r) => {
+      e.render(n, r);
+    })) : this.renderCallbacks.add((r) => {
+      e.render(i, r);
+    }), this.scheduleFrame();
+  }
+  /**
+   * Cancel a scheduled callback from all phases
+   *
+   * @param callback - The callback function to cancel
+   */
+  cancel(e) {
+    this.readCallbacks.delete(e), this.updateCallbacks.delete(e), this.renderCallbacks.delete(e), this.readKeepAlive.delete(e), this.updateKeepAlive.delete(e), this.renderKeepAlive.delete(e);
+  }
+  /**
+   * Cancel all scheduled callbacks and stop the frame loop
+   */
+  cancelAll() {
+    this.frameId !== null && (cancelAnimationFrame(this.frameId), this.frameId = null), this.readCallbacks.clear(), this.updateCallbacks.clear(), this.renderCallbacks.clear(), this.readKeepAlive.clear(), this.updateKeepAlive.clear(), this.renderKeepAlive.clear(), this.isProcessing = !1, this.frameScheduled = !1, this.lastTimestamp = 0, this.currentDelta = 0, this.trackFPS && (this.fpsHistory = []);
+  }
+  /**
+   * Get current frame data (timestamp and delta)
+   */
+  get data() {
+    return {
+      timestamp: this.lastTimestamp,
+      delta: this.currentDelta || 16.67
+      // Fallback for first frame
+    };
+  }
+  /**
+   * Check if frame loop is currently running
+   */
+  get isRunning() {
+    return this.isProcessing || this.readKeepAlive.size > 0 || this.updateKeepAlive.size > 0 || this.renderKeepAlive.size > 0;
+  }
+  /**
+   * Get current instantaneous FPS
+   * Only available if trackFPS is enabled
+   */
+  get fps() {
+    return this.trackFPS ? this.currentDelta > 0 ? 1e3 / this.currentDelta : 0 : (console.warn("FPS tracking is disabled. Enable with { trackFPS: true }"), 0);
+  }
+  /**
+   * Get average FPS over the history window
+   * Only available if trackFPS is enabled
+   */
+  get averageFps() {
+    if (!this.trackFPS)
+      return console.warn("FPS tracking is disabled. Enable with { trackFPS: true }"), 0;
+    if (this.fpsHistory.length === 0) return 0;
+    const e = this.fpsHistory.reduce((i, n) => i + n, 0);
+    return Math.round(e / this.fpsHistory.length);
+  }
+  /**
+   * Get estimated refresh rate (rounded FPS)
+   * Only available if trackFPS is enabled
+   */
+  get refreshRate() {
+    return this.trackFPS ? Math.round(this.averageFps) : (console.warn("FPS tracking is disabled. Enable with { trackFPS: true }"), 0);
+  }
+  // --------------------------------------------------------------------------
+  // Private Methods
+  // --------------------------------------------------------------------------
+  scheduleFrame() {
+    this.frameScheduled || this.isProcessing || (this.frameScheduled = !0, this.frameId = requestAnimationFrame((e) => {
+      this.processFrame(e);
+    }));
+  }
+  processFrame(e) {
+    this.isProcessing = !0, this.frameScheduled = !1, this.lastTimestamp === 0 ? this.currentDelta = 16.67 : this.currentDelta = e - this.lastTimestamp, this.lastTimestamp = e, this.trackFPS && this.currentDelta > 0 && (this.fpsHistory.push(1e3 / this.currentDelta), this.fpsHistory.length > this.fpsHistorySize && this.fpsHistory.shift());
+    const i = this.data;
+    this.executeCallbacks(this.readCallbacks, i), this.executeCallbacks(this.readKeepAlive, i), this.executeCallbacks(this.updateCallbacks, i), this.executeCallbacks(this.updateKeepAlive, i), this.executeCallbacks(this.renderCallbacks, i), this.executeCallbacks(this.renderKeepAlive, i), this.isProcessing = !1, this.hasKeepAliveCallbacks() && this.scheduleFrame();
+  }
+  executeCallbacks(e, i) {
+    e.forEach((n) => {
+      try {
+        n(i);
+      } catch (r) {
+        console.error("Frame callback error:", r);
+      }
+    }), this.isKeepAliveSet(e) || e.clear();
+  }
+  hasKeepAliveCallbacks() {
+    return this.readKeepAlive.size > 0 || this.updateKeepAlive.size > 0 || this.renderKeepAlive.size > 0;
+  }
+  isKeepAliveSet(e) {
+    return e === this.readKeepAlive || e === this.updateKeepAlive || e === this.renderKeepAlive;
+  }
+}
+class ve {
+  gestureId = 0;
+  activeGestures = /* @__PURE__ */ new Map();
+  disabledGestures = /* @__PURE__ */ new Map();
+  capturedId;
+  gestureWithPriority = /* @__PURE__ */ new Map();
+  maxPriority = -1 / 0;
+  /**
+   * Creates a new gesture ID
+   */
+  newId() {
+    return ++this.gestureId;
+  }
+  /**
+   * Check if a gesture can start
+   */
+  canStart(e) {
+    if (this.capturedId !== void 0)
+      return !1;
+    const i = this.disabledGestures.get(e);
+    return !(i && i.size > 0);
+  }
+  /**
+   * Register a gesture as wanting to start
+   */
+  start(e, i, n) {
+    return this.canStart(i) ? (this.activeGestures.set(e, i), this.gestureWithPriority.set(e, n), this.maxPriority = Math.max(this.maxPriority, n), !0) : !1;
+  }
+  /**
+   * Attempt to capture control with this gesture
+   */
+  capture(e, i, n) {
+    return !this.activeGestures.has(e) && !this.start(e, i, n) ? !1 : n >= this.maxPriority ? (this.capturedId = e, this.activeGestures.forEach((r, s) => {
+      s !== e && this.release(s);
+    }), !0) : (this.release(e), !1);
+  }
+  /**
+   * Release a gesture's attempt to capture
+   */
+  release(e) {
+    const i = this.activeGestures.get(e);
+    this.activeGestures.delete(e);
+    const n = this.gestureWithPriority.get(e);
+    if (this.gestureWithPriority.delete(e), this.capturedId === e && (this.capturedId = void 0), n === this.maxPriority && (this.maxPriority = -1 / 0, this.gestureWithPriority.forEach((r) => {
+      this.maxPriority = Math.max(this.maxPriority, r);
+    })), i) {
+      const r = this.disabledGestures.get(i);
+      r && (r.delete(e), r.size === 0 && this.disabledGestures.delete(i));
+    }
+  }
+  /**
+   * Disable a specific gesture type
+   */
+  disableGesture(e, i) {
+    let n = this.disabledGestures.get(e);
+    n || (n = /* @__PURE__ */ new Set(), this.disabledGestures.set(e, n)), n.add(i);
+  }
+  /**
+   * Enable a previously disabled gesture type
+   */
+  enableGesture(e, i) {
+    const n = this.disabledGestures.get(e);
+    n && (n.delete(i), n.size === 0 && this.disabledGestures.delete(e));
+  }
+  /**
+   * Create a gesture through this controller
+   */
+  createGesture(e, i) {
+    const n = this.newId(), r = i.name || "gesture-" + n, s = i.priority ?? 0;
+    return new _e(this, n, e, r, s, i);
+  }
+}
+const ge = new ve();
+class _e {
+  // Private members
+  el;
+  options;
+  details;
+  minTouches;
+  maxTouches;
+  threshold;
+  direction;
+  lastMoveTime = 0;
+  prevX = 0;
+  prevY = 0;
+  initialDistance = 0;
+  initialAngle = 0;
+  boundOnStart;
+  boundOnMove;
+  boundOnEnd;
+  passive;
+  // future update
+  // private passive: boolean | {onStart: boolean, onMove: boolean, onEnd: boolean};
+  hasPassedThreshold = !1;
+  controller;
+  id;
+  name;
+  priority;
+  useThreshold;
+  constructor(e, i, n, r, s, o) {
+    this.controller = e, this.id = i, this.el = n, this.options = o, this.name = r, this.priority = s * 1e3 + i, this.minTouches = o.minTouches ?? 1, this.maxTouches = o.maxTouches ?? 1 / 0, this.passive = o.passive ?? !0, this.threshold = o.threshold ?? 0, this.direction = o.direction ?? "all", this.useThreshold = this.threshold > 0, this.details = {
+      type: this.name,
+      isTracking: !1,
+      startX: 0,
+      startY: 0,
+      currentX: 0,
+      currentY: 0,
+      deltaX: 0,
+      deltaY: 0,
+      velocityX: 0,
+      velocityY: 0,
+      touchCount: 0,
+      scale: 1,
+      rotation: 0
+    }, this.boundOnStart = this.onStart.bind(this), this.boundOnMove = this.onMove.bind(this), this.boundOnEnd = this.onEnd.bind(this);
+  }
+  /**
+   * Calculate distance between two touch points
+   */
+  getDistance(e) {
+    if (e.length < 2) return 0;
+    const i = e[0].clientX - e[1].clientX, n = e[0].clientY - e[1].clientY;
+    return Math.sqrt(i * i + n * n);
+  }
+  /**
+   * Calculate angle between two touch points in degrees
+   */
+  getAngle(e) {
+    if (e.length < 2) return 0;
+    const i = e[1].clientX - e[0].clientX, n = e[1].clientY - e[0].clientY;
+    return Math.atan2(n, i) * 180 / Math.PI;
+  }
+  /**
+   * Get center point of all touches
+   */
+  getCenter(e) {
+    if ("touches" in e) {
+      if (e.touches.length === 0) return { x: 0, y: 0 };
+      let i = 0, n = 0;
+      for (let r = 0; r < e.touches.length; r++)
+        i += e.touches[r].clientX, n += e.touches[r].clientY;
+      return {
+        x: i / e.touches.length,
+        y: n / e.touches.length
+      };
+    } else
+      return { x: e.clientX, y: e.clientY };
+  }
+  /**
+   * Check if the gesture can start based on touch count
+   */
+  canStart(e) {
+    const n = "touches" in e ? e.touches.length : 1;
+    return n >= this.minTouches && n <= this.maxTouches && this.controller.canStart(this.name);
+  }
+  /**
+   * Check if we've moved enough to pass the threshold
+   */
+  checkThreshold() {
+    if (!this.useThreshold) return !0;
+    const { deltaX: e, deltaY: i } = this.details;
+    return this.direction === "x" ? Math.abs(e) >= this.threshold : this.direction === "y" ? Math.abs(i) >= this.threshold : Math.sqrt(e * e + i * i) >= this.threshold;
+  }
+  onStart(e) {
+    if (!this.canStart(e)) return;
+    const i = "touches" in e, n = this.getCenter(e);
+    this.details.startX = n.x, this.details.startY = n.y, this.details.currentX = n.x, this.details.currentY = n.y, this.details.touchCount = i ? e.touches.length : 1, this.details.event = e, i && e.touches.length >= 2 ? (this.initialDistance = this.getDistance(e.touches), this.initialAngle = this.getAngle(e.touches)) : (this.initialDistance = 0, this.initialAngle = 0), !(this.options.canStart && !this.options.canStart(this.details)) && (this.passive || e.preventDefault(), this.details.isTracking = !0, this.details.deltaX = 0, this.details.deltaY = 0, this.details.velocityX = 0, this.details.velocityY = 0, this.details.scale = 1, this.details.rotation = 0, this.hasPassedThreshold = !this.useThreshold, this.lastMoveTime = Date.now(), this.prevX = n.x, this.prevY = n.y, this.controller.start(this.id, this.name, this.priority), this.useThreshold || this.tryCapture());
+  }
+  onMove(e) {
+    if (!this.details.isTracking) return;
+    this.passive || e.preventDefault();
+    const i = "touches" in e, n = this.getCenter(e), r = Date.now(), s = r - this.lastMoveTime;
+    if (this.details.currentX = n.x, this.details.currentY = n.y, this.details.deltaX = this.details.currentX - this.details.startX, this.details.deltaY = this.details.currentY - this.details.startY, this.details.touchCount = i ? e.touches.length : 1, this.details.event = e, i && e.touches.length >= 2) {
+      const o = this.getDistance(e.touches), a = this.getAngle(e.touches);
+      this.initialDistance > 0 && (this.details.scale = o / this.initialDistance);
+      let l = a - this.initialAngle;
+      l > 180 && (l -= 360), l < -180 && (l += 360), this.details.rotation = l;
+    } else
+      this.details.scale = 1, this.details.rotation = 0;
+    if (s > 0 && (this.details.velocityX = (this.details.currentX - this.prevX) / s, this.details.velocityY = (this.details.currentY - this.prevY) / s), this.prevX = this.details.currentX, this.prevY = this.details.currentY, this.lastMoveTime = r, !this.hasPassedThreshold && this.checkThreshold()) {
+      this.hasPassedThreshold = !0, this.tryCapture();
+      return;
+    }
+    this.hasPassedThreshold && this.options.onMove && this.options.onMove(this.details);
+  }
+  tryCapture() {
+    this.controller.capture(this.id, this.name, this.priority) && this.options.onStart && this.options.onStart(this.details);
+  }
+  onEnd(e) {
+    if (!this.details.isTracking) return;
+    this.passive || e.preventDefault();
+    const i = "touches" in e;
+    this.details.touchCount = i ? e.touches.length : 0, this.details.event = e, this.controller.release(this.id), this.details.isTracking = !1, this.hasPassedThreshold = !this.useThreshold, this.options.onEnd && this.options.onEnd(this.details);
+  }
+  /**
+   * Public method to initialize the gesture
+   */
+  init() {
+    if (!this.el) return;
+    const e = { passive: this.passive }, i = { passive: this.passive }, n = { passive: this.passive };
+    this.el.addEventListener("touchstart", this.boundOnStart, e), document.addEventListener("touchmove", this.boundOnMove, i), document.addEventListener("touchend", this.boundOnEnd, n), document.addEventListener("touchcancel", this.boundOnEnd, n), this.el.addEventListener("mousedown", this.boundOnStart, e), document.addEventListener("mousemove", this.boundOnMove, i), document.addEventListener("mouseup", this.boundOnEnd, n), document.addEventListener("mouseleave", this.boundOnEnd, n);
+  }
+  /**
+   * Public method to clean up the gesture
+   */
+  destroy() {
+    this.el && (this.el.removeEventListener("touchstart", this.boundOnStart), document.removeEventListener("touchmove", this.boundOnMove), document.removeEventListener("touchend", this.boundOnEnd), document.removeEventListener("touchcancel", this.boundOnEnd), this.el.removeEventListener("mousedown", this.boundOnStart), document.removeEventListener("mousemove", this.boundOnMove), document.removeEventListener("mouseup", this.boundOnEnd), document.removeEventListener("mouseleave", this.boundOnEnd), this.controller.release(this.id));
+  }
+}
+function Xe(t, e) {
+  return ge.createGesture(t, e);
+}
+function je(t) {
+  typeof document > "u" || (document.startViewTransition ? document.startViewTransition(t) : t());
+}
+let Se = 0;
+function Ye(t, e = [], i = {
+  duration: 500,
+  namePrefix: "vt"
+}) {
+  if (!document.startViewTransition) {
+    t();
+    return;
+  }
+  const n = e.map(
+    (s, o) => `${i.namePrefix}-${++Se}-${o}`
+  );
+  e.forEach((s, o) => {
+    s.style.viewTransitionName = n[o];
+  }), document.startViewTransition(() => {
+    t();
+  }).finished.finally(() => {
+    e.forEach((s) => {
+      s.style.viewTransitionName = "";
+    });
+  }), document.documentElement.style.setProperty(
+    "--vt-duration",
+    `${i.duration}ms`
+  );
+}
+export {
+  y as Computed,
+  v as Effect,
+  $e as Fragment,
+  He as FrameScheduler,
+  u as Signal,
+  Ce as batch,
+  Ee as computed,
+  De as createContext,
+  Xe as createGesture,
+  g as effect,
+  Ne as get,
+  Oe as hydrate,
+  xe as link,
+  Ke as onBeforeExit,
+  Ge as onLoad,
+  Le as onMount,
+  Ie as onUnmount,
+  Te as peek,
+  Me as render,
+  Ae as set,
+  we as signal,
+  je as startViewTransition,
+  Pe as suspend,
+  Fe as useContext,
+  Ye as withViewTransition
+};