@ssgoi/react 0.0.1

package/dist/index.js

@@ -0,0 +1,770 @@
+import { jsx as mt } from "react/jsx-runtime";
+import { createContext as Lt, useContext as qt, useMemo as Bt } from "react";
+import { g as _t } from "./utils-DR41YsAh.js";
+function ht(t, e) {
+  var n = {};
+  for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && e.indexOf(r) < 0 && (n[r] = t[r]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, r = Object.getOwnPropertySymbols(t); s < r.length; s++)
+      e.indexOf(r[s]) < 0 && Object.prototype.propertyIsEnumerable.call(t, r[s]) && (n[r[s]] = t[r[s]]);
+  return n;
+}
+var X = function() {
+}, V = function() {
+};
+process.env.NODE_ENV !== "production" && (X = function(t, e) {
+  !t && typeof console < "u" && console.warn(e);
+}, V = function(t, e) {
+  if (!t)
+    throw new Error(e);
+});
+const W = (t, e, n) => Math.min(Math.max(n, t), e), q = 1e-3, Wt = 0.01, ot = 10, Gt = 0.05, Ht = 1;
+function Kt({ duration: t = 800, bounce: e = 0.25, velocity: n = 0, mass: r = 1 }) {
+  let s, i;
+  X(t <= ot * 1e3, "Spring duration must be 10 seconds or less");
+  let o = 1 - e;
+  o = W(Gt, Ht, o), t = W(Wt, ot, t / 1e3), o < 1 ? (s = (a) => {
+    const p = a * o, m = p * t, u = p - n, f = G(a, o), h = Math.exp(-m);
+    return q - u / f * h;
+  }, i = (a) => {
+    const m = a * o * t, u = m * n + n, f = Math.pow(o, 2) * Math.pow(a, 2) * t, h = Math.exp(-m), x = G(Math.pow(a, 2), o);
+    return (-s(a) + q > 0 ? -1 : 1) * ((u - f) * h) / x;
+  }) : (s = (a) => {
+    const p = Math.exp(-a * t), m = (a - n) * t + 1;
+    return -q + p * m;
+  }, i = (a) => {
+    const p = Math.exp(-a * t), m = (n - a) * (t * t);
+    return p * m;
+  });
+  const l = 5 / t, c = Zt(s, i, l);
+  if (t = t * 1e3, isNaN(c))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: t
+    };
+  {
+    const a = Math.pow(c, 2) * r;
+    return {
+      stiffness: a,
+      damping: o * 2 * Math.sqrt(r * a),
+      duration: t
+    };
+  }
+}
+const zt = 12;
+function Zt(t, e, n) {
+  let r = n;
+  for (let s = 1; s < zt; s++)
+    r = r - t(r) / e(r);
+  return r;
+}
+function G(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const Jt = ["duration", "bounce"], Qt = ["stiffness", "damping", "mass"];
+function it(t, e) {
+  return e.some((n) => t[n] !== void 0);
+}
+function Xt(t) {
+  let e = Object.assign({ velocity: 0, stiffness: 100, damping: 10, mass: 1, isResolvedFromDuration: !1 }, t);
+  if (!it(t, Qt) && it(t, Jt)) {
+    const n = Kt(t);
+    e = Object.assign(Object.assign(Object.assign({}, e), n), { velocity: 0, mass: 1 }), e.isResolvedFromDuration = !0;
+  }
+  return e;
+}
+function Y(t) {
+  var { from: e = 0, to: n = 1, restSpeed: r = 2, restDelta: s } = t, i = ht(t, ["from", "to", "restSpeed", "restDelta"]);
+  const o = { done: !1, value: e };
+  let { stiffness: l, damping: c, mass: a, velocity: p, duration: m, isResolvedFromDuration: u } = Xt(i), f = at, h = at;
+  function x() {
+    const y = p ? -(p / 1e3) : 0, S = n - e, b = c / (2 * Math.sqrt(l * a)), g = Math.sqrt(l / a) / 1e3;
+    if (s === void 0 && (s = Math.min(Math.abs(n - e) / 100, 0.4)), b < 1) {
+      const d = G(g, b);
+      f = (M) => {
+        const w = Math.exp(-b * g * M);
+        return n - w * ((y + b * g * S) / d * Math.sin(d * M) + S * Math.cos(d * M));
+      }, h = (M) => {
+        const w = Math.exp(-b * g * M);
+        return b * g * w * (Math.sin(d * M) * (y + b * g * S) / d + S * Math.cos(d * M)) - w * (Math.cos(d * M) * (y + b * g * S) - d * S * Math.sin(d * M));
+      };
+    } else if (b === 1)
+      f = (d) => n - Math.exp(-g * d) * (S + (y + g * S) * d);
+    else {
+      const d = g * Math.sqrt(b * b - 1);
+      f = (M) => {
+        const w = Math.exp(-b * g * M), O = Math.min(d * M, 300);
+        return n - w * ((y + b * g * S) * Math.sinh(O) + d * S * Math.cosh(O)) / d;
+      };
+    }
+  }
+  return x(), {
+    next: (y) => {
+      const S = f(y);
+      if (u)
+        o.done = y >= m;
+      else {
+        const b = h(y) * 1e3, g = Math.abs(b) <= r, d = Math.abs(n - S) <= s;
+        o.done = g && d;
+      }
+      return o.value = o.done ? n : S, o;
+    },
+    flipTarget: () => {
+      p = -p, [e, n] = [n, e], x();
+    }
+  };
+}
+Y.needsInterpolation = (t, e) => typeof t == "string" || typeof e == "string";
+const at = (t) => 0, dt = (t, e, n) => {
+  const r = e - t;
+  return r === 0 ? 1 : (n - t) / r;
+}, tt = (t, e, n) => -n * t + n * e + t, gt = (t, e) => (n) => Math.max(Math.min(n, e), t), A = (t) => t % 1 ? Number(t.toFixed(5)) : t, N = /(-)?([\d]*\.?[\d])+/g, H = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2}(-?[\d\.]+%?)\s*[\,\/]?\s*[\d\.]*%?\))/gi, Yt = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2}(-?[\d\.]+%?)\s*[\,\/]?\s*[\d\.]*%?\))$/i;
+function j(t) {
+  return typeof t == "string";
+}
+const k = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, yt = Object.assign(Object.assign({}, k), { transform: gt(0, 1) });
+Object.assign(Object.assign({}, k), { default: 1 });
+const te = (t) => ({
+  test: (e) => j(e) && e.endsWith(t) && e.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (e) => `${e}${t}`
+}), R = te("%");
+Object.assign(Object.assign({}, R), { parse: (t) => R.parse(t) / 100, transform: (t) => R.transform(t * 100) });
+const et = (t, e) => (n) => !!(j(n) && Yt.test(n) && n.startsWith(t) || e && Object.prototype.hasOwnProperty.call(n, e)), bt = (t, e, n) => (r) => {
+  if (!j(r))
+    return r;
+  const [s, i, o, l] = r.match(N);
+  return {
+    [t]: parseFloat(s),
+    [e]: parseFloat(i),
+    [n]: parseFloat(o),
+    alpha: l !== void 0 ? parseFloat(l) : 1
+  };
+}, C = {
+  test: et("hsl", "hue"),
+  parse: bt("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: n, alpha: r = 1 }) => "hsla(" + Math.round(t) + ", " + R.transform(A(e)) + ", " + R.transform(A(n)) + ", " + A(yt.transform(r)) + ")"
+}, ee = gt(0, 255), B = Object.assign(Object.assign({}, k), { transform: (t) => Math.round(ee(t)) }), v = {
+  test: et("rgb", "red"),
+  parse: bt("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: n, alpha: r = 1 }) => "rgba(" + B.transform(t) + ", " + B.transform(e) + ", " + B.transform(n) + ", " + A(yt.transform(r)) + ")"
+};
+function ne(t) {
+  let e = "", n = "", r = "", s = "";
+  return t.length > 5 ? (e = t.substr(1, 2), n = t.substr(3, 2), r = t.substr(5, 2), s = t.substr(7, 2)) : (e = t.substr(1, 1), n = t.substr(2, 1), r = t.substr(3, 1), s = t.substr(4, 1), e += e, n += n, r += r, s += s), {
+    red: parseInt(e, 16),
+    green: parseInt(n, 16),
+    blue: parseInt(r, 16),
+    alpha: s ? parseInt(s, 16) / 255 : 1
+  };
+}
+const K = {
+  test: et("#"),
+  parse: ne,
+  transform: v.transform
+}, U = {
+  test: (t) => v.test(t) || K.test(t) || C.test(t),
+  parse: (t) => v.test(t) ? v.parse(t) : C.test(t) ? C.parse(t) : K.parse(t),
+  transform: (t) => j(t) ? t : t.hasOwnProperty("red") ? v.transform(t) : C.transform(t)
+}, xt = "${c}", St = "${n}";
+function re(t) {
+  var e, n, r, s;
+  return isNaN(t) && j(t) && ((n = (e = t.match(N)) === null || e === void 0 ? void 0 : e.length) !== null && n !== void 0 ? n : 0) + ((s = (r = t.match(H)) === null || r === void 0 ? void 0 : r.length) !== null && s !== void 0 ? s : 0) > 0;
+}
+function Mt(t) {
+  typeof t == "number" && (t = `${t}`);
+  const e = [];
+  let n = 0;
+  const r = t.match(H);
+  r && (n = r.length, t = t.replace(H, xt), e.push(...r.map(U.parse)));
+  const s = t.match(N);
+  return s && (t = t.replace(N, St), e.push(...s.map(k.parse))), { values: e, numColors: n, tokenised: t };
+}
+function wt(t) {
+  return Mt(t).values;
+}
+function vt(t) {
+  const { values: e, numColors: n, tokenised: r } = Mt(t), s = e.length;
+  return (i) => {
+    let o = r;
+    for (let l = 0; l < s; l++)
+      o = o.replace(l < n ? xt : St, l < n ? U.transform(i[l]) : A(i[l]));
+    return o;
+  };
+}
+const se = (t) => typeof t == "number" ? 0 : t;
+function oe(t) {
+  const e = wt(t);
+  return vt(t)(e.map(se));
+}
+const Ct = { test: re, parse: wt, createTransformer: vt, getAnimatableNone: oe };
+function _(t, e, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (e - t) * 6 * n : n < 1 / 2 ? e : n < 2 / 3 ? t + (e - t) * (2 / 3 - n) * 6 : t;
+}
+function lt({ hue: t, saturation: e, lightness: n, alpha: r }) {
+  t /= 360, e /= 100, n /= 100;
+  let s = 0, i = 0, o = 0;
+  if (!e)
+    s = i = o = n;
+  else {
+    const l = n < 0.5 ? n * (1 + e) : n + e - n * e, c = 2 * n - l;
+    s = _(c, l, t + 1 / 3), i = _(c, l, t), o = _(c, l, t - 1 / 3);
+  }
+  return {
+    red: Math.round(s * 255),
+    green: Math.round(i * 255),
+    blue: Math.round(o * 255),
+    alpha: r
+  };
+}
+const ie = (t, e, n) => {
+  const r = t * t, s = e * e;
+  return Math.sqrt(Math.max(0, n * (s - r) + r));
+}, ae = [K, v, C], ct = (t) => ae.find((e) => e.test(t)), ut = (t) => `'${t}' is not an animatable color. Use the equivalent color code instead.`, Ot = (t, e) => {
+  let n = ct(t), r = ct(e);
+  V(!!n, ut(t)), V(!!r, ut(e));
+  let s = n.parse(t), i = r.parse(e);
+  n === C && (s = lt(s), n = v), r === C && (i = lt(i), r = v);
+  const o = Object.assign({}, s);
+  return (l) => {
+    for (const c in o)
+      c !== "alpha" && (o[c] = ie(s[c], i[c], l));
+    return o.alpha = tt(s.alpha, i.alpha, l), n.transform(o);
+  };
+}, le = (t) => typeof t == "number", ce = (t, e) => (n) => e(t(n)), Tt = (...t) => t.reduce(ce);
+function At(t, e) {
+  return le(t) ? (n) => tt(t, e, n) : U.test(t) ? Ot(t, e) : Et(t, e);
+}
+const Rt = (t, e) => {
+  const n = [...t], r = n.length, s = t.map((i, o) => At(i, e[o]));
+  return (i) => {
+    for (let o = 0; o < r; o++)
+      n[o] = s[o](i);
+    return n;
+  };
+}, ue = (t, e) => {
+  const n = Object.assign(Object.assign({}, t), e), r = {};
+  for (const s in n)
+    t[s] !== void 0 && e[s] !== void 0 && (r[s] = At(t[s], e[s]));
+  return (s) => {
+    for (const i in r)
+      n[i] = r[i](s);
+    return n;
+  };
+};
+function ft(t) {
+  const e = Ct.parse(t), n = e.length;
+  let r = 0, s = 0, i = 0;
+  for (let o = 0; o < n; o++)
+    r || typeof e[o] == "number" ? r++ : e[o].hue !== void 0 ? i++ : s++;
+  return { parsed: e, numNumbers: r, numRGB: s, numHSL: i };
+}
+const Et = (t, e) => {
+  const n = Ct.createTransformer(e), r = ft(t), s = ft(e);
+  return r.numHSL === s.numHSL && r.numRGB === s.numRGB && r.numNumbers >= s.numNumbers ? Tt(Rt(r.parsed, s.parsed), n) : (X(!0, `Complex values '${t}' and '${e}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`), (o) => `${o > 0 ? e : t}`);
+}, fe = (t, e) => (n) => tt(t, e, n);
+function pe(t) {
+  if (typeof t == "number")
+    return fe;
+  if (typeof t == "string")
+    return U.test(t) ? Ot : Et;
+  if (Array.isArray(t))
+    return Rt;
+  if (typeof t == "object")
+    return ue;
+}
+function me(t, e, n) {
+  const r = [], s = n || pe(t[0]), i = t.length - 1;
+  for (let o = 0; o < i; o++) {
+    let l = s(t[o], t[o + 1]);
+    if (e) {
+      const c = Array.isArray(e) ? e[o] : e;
+      l = Tt(c, l);
+    }
+    r.push(l);
+  }
+  return r;
+}
+function he([t, e], [n]) {
+  return (r) => n(dt(t, e, r));
+}
+function de(t, e) {
+  const n = t.length, r = n - 1;
+  return (s) => {
+    let i = 0, o = !1;
+    if (s <= t[0] ? o = !0 : s >= t[r] && (i = r - 1, o = !0), !o) {
+      let c = 1;
+      for (; c < n && !(t[c] > s || c === r); c++)
+        ;
+      i = c - 1;
+    }
+    const l = dt(t[i], t[i + 1], s);
+    return e[i](l);
+  };
+}
+function Vt(t, e, { clamp: n = !0, ease: r, mixer: s } = {}) {
+  const i = t.length;
+  V(i === e.length, "Both input and output ranges must be the same length"), V(!r || !Array.isArray(r) || r.length === i - 1, "Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values."), t[0] > t[i - 1] && (t = [].concat(t), e = [].concat(e), t.reverse(), e.reverse());
+  const o = me(e, r, s), l = i === 2 ? he(t, o) : de(t, o);
+  return n ? (c) => l(W(t[0], t[i - 1], c)) : l;
+}
+const ge = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, ye = (t) => (e) => Math.pow(e, t), be = ye(2), xe = ge(be);
+function Se(t, e) {
+  return t.map(() => e || xe).splice(0, t.length - 1);
+}
+function Me(t) {
+  const e = t.length;
+  return t.map((n, r) => r !== 0 ? r / (e - 1) : 0);
+}
+function we(t, e) {
+  return t.map((n) => n * e);
+}
+function P({ from: t = 0, to: e = 1, ease: n, offset: r, duration: s = 300 }) {
+  const i = { done: !1, value: t }, o = Array.isArray(e) ? e : [t, e], l = we(r && r.length === o.length ? r : Me(o), s);
+  function c() {
+    return Vt(l, o, {
+      ease: Array.isArray(n) ? n : Se(o, n)
+    });
+  }
+  let a = c();
+  return {
+    next: (p) => (i.value = a(p), i.done = p >= s, i),
+    flipTarget: () => {
+      o.reverse(), a = c();
+    }
+  };
+}
+function ve({ velocity: t = 0, from: e = 0, power: n = 0.8, timeConstant: r = 350, restDelta: s = 0.5, modifyTarget: i }) {
+  const o = { done: !1, value: e };
+  let l = n * t;
+  const c = e + l, a = i === void 0 ? c : i(c);
+  return a !== c && (l = a - e), {
+    next: (p) => {
+      const m = -l * Math.exp(-p / r);
+      return o.done = !(m > s || m < -s), o.value = o.done ? a : a + m, o;
+    },
+    flipTarget: () => {
+    }
+  };
+}
+const pt = { keyframes: P, spring: Y, decay: ve };
+function Ce(t) {
+  if (Array.isArray(t.to))
+    return P;
+  if (pt[t.type])
+    return pt[t.type];
+  const e = new Set(Object.keys(t));
+  return e.has("ease") || e.has("duration") && !e.has("dampingRatio") ? P : e.has("dampingRatio") || e.has("stiffness") || e.has("mass") || e.has("damping") || e.has("restSpeed") || e.has("restDelta") ? Y : P;
+}
+const It = 1 / 60 * 1e3, Oe = typeof performance < "u" ? () => performance.now() : () => Date.now(), jt = typeof window < "u" ? (t) => window.requestAnimationFrame(t) : (t) => setTimeout(() => t(Oe()), It);
+function Te(t) {
+  let e = [], n = [], r = 0, s = !1, i = !1;
+  const o = /* @__PURE__ */ new WeakSet(), l = {
+    schedule: (c, a = !1, p = !1) => {
+      const m = p && s, u = m ? e : n;
+      return a && o.add(c), u.indexOf(c) === -1 && (u.push(c), m && s && (r = e.length)), c;
+    },
+    cancel: (c) => {
+      const a = n.indexOf(c);
+      a !== -1 && n.splice(a, 1), o.delete(c);
+    },
+    process: (c) => {
+      if (s) {
+        i = !0;
+        return;
+      }
+      if (s = !0, [e, n] = [n, e], n.length = 0, r = e.length, r)
+        for (let a = 0; a < r; a++) {
+          const p = e[a];
+          p(c), o.has(p) && (l.schedule(p), t());
+        }
+      s = !1, i && (i = !1, l.process(c));
+    }
+  };
+  return l;
+}
+const Ae = 40;
+let z = !0, I = !1, Z = !1;
+const E = {
+  delta: 0,
+  timestamp: 0
+}, F = [
+  "read",
+  "update",
+  "preRender",
+  "render",
+  "postRender"
+], $ = F.reduce((t, e) => (t[e] = Te(() => I = !0), t), {}), Re = F.reduce((t, e) => {
+  const n = $[e];
+  return t[e] = (r, s = !1, i = !1) => (I || Ie(), n.schedule(r, s, i)), t;
+}, {}), Ee = F.reduce((t, e) => (t[e] = $[e].cancel, t), {});
+F.reduce((t, e) => (t[e] = () => $[e].process(E), t), {});
+const Ve = (t) => $[t].process(E), Ft = (t) => {
+  I = !1, E.delta = z ? It : Math.max(Math.min(t - E.timestamp, Ae), 1), E.timestamp = t, Z = !0, F.forEach(Ve), Z = !1, I && (z = !1, jt(Ft));
+}, Ie = () => {
+  I = !0, z = !0, Z || jt(Ft);
+};
+function Dt(t, e, n = 0) {
+  return t - e - n;
+}
+function je(t, e, n = 0, r = !0) {
+  return r ? Dt(e + -t, e, n) : e - (t - e) + n;
+}
+function Fe(t, e, n, r) {
+  return r ? t >= e + n : t <= -n;
+}
+const De = (t) => {
+  const e = ({ delta: n }) => t(n);
+  return {
+    start: () => Re.update(e, !0),
+    stop: () => Ee.update(e)
+  };
+};
+function Pe(t) {
+  var e, n, { from: r, autoplay: s = !0, driver: i = De, elapsed: o = 0, repeat: l = 0, repeatType: c = "loop", repeatDelay: a = 0, onPlay: p, onStop: m, onComplete: u, onRepeat: f, onUpdate: h } = t, x = ht(t, ["from", "autoplay", "driver", "elapsed", "repeat", "repeatType", "repeatDelay", "onPlay", "onStop", "onComplete", "onRepeat", "onUpdate"]);
+  let { to: y } = x, S, b = 0, g = x.duration, d, M = !1, w = !0, O;
+  const nt = Ce(x);
+  !((n = (e = nt).needsInterpolation) === null || n === void 0) && n.call(e, r, y) && (O = Vt([0, 100], [r, y], {
+    clamp: !1
+  }), r = 0, y = 100);
+  const rt = nt(Object.assign(Object.assign({}, x), { from: r, to: y }));
+  function Nt() {
+    b++, c === "reverse" ? (w = b % 2 === 0, o = je(o, g, a, w)) : (o = Dt(o, g, a), c === "mirror" && rt.flipTarget()), M = !1, f && f();
+  }
+  function kt() {
+    S.stop(), u && u();
+  }
+  function Ut(L) {
+    if (w || (L = -L), o += L, !M) {
+      const st = rt.next(Math.max(0, o));
+      d = st.value, O && (d = O(d)), M = w ? st.done : o <= 0;
+    }
+    h?.(d), M && (b === 0 && (g ?? (g = o)), b < l ? Fe(o, g, a, w) && Nt() : kt());
+  }
+  function $t() {
+    p?.(), S = i(Ut), S.start();
+  }
+  return s && $t(), {
+    stop: () => {
+      m?.(), S.stop();
+    }
+  };
+}
+class T {
+  options;
+  currentValue;
+  velocity = 0;
+  isAnimating = !1;
+  controls = null;
+  constructor(e) {
+    this.options = {
+      from: e.from ?? 0,
+      to: e.to ?? 1,
+      spring: e.spring ?? { stiffness: 100, damping: 10 },
+      onUpdate: e.onUpdate ?? (() => {
+      }),
+      onComplete: e.onComplete ?? (() => {
+      }),
+      onStart: e.onStart
+    }, this.currentValue = this.options.from;
+  }
+  animate = (e = !1) => {
+    !this.isAnimating && this.options.onStart && this.options.onStart(), this.isAnimating = !0;
+    const n = e ? this.options.from : this.options.to;
+    let r = this.currentValue, s = performance.now();
+    this.controls = Pe({
+      from: this.currentValue,
+      to: n,
+      velocity: this.velocity * 1e3,
+      // Convert to px/s
+      stiffness: this.options.spring.stiffness,
+      damping: this.options.spring.damping,
+      mass: 1,
+      onUpdate: (i) => {
+        const o = performance.now(), l = (o - s) / 1e3;
+        if (l > 0) {
+          const c = (i - r) / l;
+          this.velocity = c / 1e3, r = i, s = o;
+        }
+        this.currentValue = i, this.options.onUpdate(i);
+      },
+      onComplete: () => {
+        this.currentValue = n, this.isAnimating = !1, this.controls = null, this.velocity = 0, this.options.onComplete();
+      }
+    });
+  };
+  // Animation control methods
+  forward() {
+    this.stop(), this.animate(!1);
+  }
+  backward() {
+    this.stop(), this.animate(!0);
+  }
+  reverse() {
+    const e = this.options.from;
+    if (this.options.from = this.options.to, this.options.to = e, this.isAnimating) {
+      const n = this.currentValue > (this.options.from + this.options.to) / 2;
+      this.stop(), this.animate(!n);
+    }
+  }
+  stop() {
+    this.isAnimating = !1, this.controls && (this.controls.stop(), this.controls = null);
+  }
+  // State getters
+  getVelocity() {
+    return this.velocity;
+  }
+  getCurrentValue() {
+    return this.currentValue;
+  }
+  getIsAnimating() {
+    return this.isAnimating;
+  }
+  getCurrentState() {
+    return {
+      position: this.currentValue,
+      velocity: this.velocity
+    };
+  }
+  // State setters
+  setVelocity(e) {
+    this.velocity = e;
+  }
+  setValue(e) {
+    this.currentValue = e;
+  }
+  // Configuration
+  updateOptions(e) {
+    if (this.options = { ...this.options, ...e }, this.isAnimating && this.controls) {
+      const n = this.currentValue < this.options.to;
+      this.stop(), this.animate(!n);
+    }
+  }
+  // Static factory method
+  static fromState(e, n) {
+    const r = new T(n);
+    return r.setValue(e.position), r.setVelocity(e.velocity), r;
+  }
+}
+function Ne(t, e) {
+  let n = null, r = null, s = null, i = null, o = !1;
+  const l = async (a) => {
+    if (n && n.getIsAnimating() && !o) {
+      const p = n.getCurrentState();
+      n.stop(), r && (r.remove(), r = null), o = !0;
+      const m = t();
+      if (!m.out) return;
+      const u = await Promise.resolve(m.out(a));
+      n = T.fromState(p, {
+        from: 1,
+        to: 0,
+        spring: u.spring,
+        onStart: u.onStart,
+        onUpdate: (f) => {
+          u.tick?.(f);
+        },
+        onComplete: () => {
+          n = null, o = !1, u.onEnd?.();
+        }
+      }), n.backward();
+      return;
+    }
+    if (!n || !n.getIsAnimating()) {
+      o = !0;
+      const p = t();
+      if (!p.in) return;
+      const m = await Promise.resolve(p.in(a));
+      m.prepare?.(a), n = new T({
+        from: 0,
+        to: 1,
+        spring: m.spring,
+        onStart: m.onStart,
+        onUpdate: (u) => {
+          m.tick?.(u);
+        },
+        onComplete: () => {
+          n = null, o = !1, m.onEnd?.();
+        }
+      }), n.forward();
+    }
+  };
+  function c(a) {
+    const p = () => {
+      !s || !r || (i && s.contains(i) ? s.insertBefore(r, i) : s.appendChild(r));
+    }, m = () => {
+      r && (r.remove(), r = null), n = null, o = !1, e?.onCleanupEnd?.();
+    }, u = t();
+    if (r = a.cloneNode(!0), n && n.getIsAnimating() && o) {
+      const f = n.getCurrentState();
+      if (n.stop(), o = !1, !u.in) {
+        r = null, m();
+        return;
+      }
+      Promise.resolve(u.in(r)).then(async (h) => {
+        const x = r && await u.out?.(r);
+        x?.prepare && r && x.prepare(r), p(), n = T.fromState(f, {
+          from: 0,
+          to: 1,
+          spring: h.spring,
+          onStart: h.onStart,
+          onUpdate: (y) => {
+            h.tick?.(y);
+          },
+          onComplete: () => {
+            h.onEnd?.(), m();
+          }
+        }), n.backward();
+      });
+      return;
+    }
+    if (!n || !n.getIsAnimating() || !o) {
+      if (o = !1, !u.out) {
+        r = null, m();
+        return;
+      }
+      Promise.resolve(u.out(r)).then((f) => {
+        r && f.prepare?.(r), p(), n = new T({
+          from: 1,
+          to: 0,
+          spring: f.spring,
+          onStart: f.onStart,
+          onUpdate: (h) => {
+            f.tick?.(h);
+          },
+          onComplete: () => {
+            f.onEnd?.(), m();
+          }
+        }), n.forward();
+      });
+    }
+  }
+  return (a) => a ? (s = a.parentElement, i = a.nextElementSibling, t().in && l(a), () => {
+    c(a);
+  }) : void 0;
+}
+const J = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map();
+function ke(t, e) {
+  J.set(t, e);
+  let n = Q.get(t);
+  return n || (n = Ne(
+    () => {
+      const r = J.get(t);
+      return r || (console.warn(`Transition "${String(t)}" not found`), {});
+    },
+    {
+      onCleanupEnd: () => Ue(t)
+    }
+  ), Q.set(t, n), n);
+}
+function Ue(t) {
+  J.delete(t), Q.delete(t);
+}
+function $e(t) {
+  return ke(t.key, {
+    in: t.in,
+    out: t.out
+  });
+}
+function Le(t) {
+  let e = null;
+  const n = [...t.transitions], r = [];
+  for (const u of t.transitions)
+    u.symmetric && (n.some(
+      (h) => h.from === u.to && h.to === u.from
+    ) || r.push({
+      from: u.to,
+      to: u.from,
+      transition: u.transition
+      // Don't add symmetric flag to the reverse to avoid infinite loop
+    }));
+  n.push(...r);
+  let s = null;
+  const i = /* @__PURE__ */ new Map();
+  let o = null;
+  const l = () => {
+    s && o && i.set(o, {
+      x: s.scrollLeft,
+      y: s.scrollTop
+    });
+  }, c = (u, f) => {
+    s || (s = _t(u), s.addEventListener("scroll", l, {
+      passive: !0
+    })), o = f;
+  }, a = () => {
+    const u = e?.from, f = e?.to, h = u && i.has(u) ? i.get(u) : { x: 0, y: 0 }, x = f && i.has(f) ? i.get(f) : { x: 0, y: 0 };
+    return {
+      x: -x.x + h.x,
+      y: -x.y + h.y
+    };
+  };
+  function p() {
+    if (e?.from && e?.to) {
+      const f = qe(
+        e.from,
+        e.to,
+        n
+      ) || t.defaultTransition, x = { scrollOffset: a() };
+      f && (f.out && e.outResolve && e.outResolve(
+        (y) => f.out(y, x)
+      ), f.in && e.inResolve && e.inResolve(
+        (y) => f.in(y, x)
+      )), e = null;
+    }
+  }
+  const m = async (u, f) => f === "in" && (!e || !e.from) ? () => ({}) : (e || (e = {}), f === "out" ? (e.from = u, new Promise((h) => {
+    e.outResolve = h, p();
+  })) : (e.to = u, new Promise((h) => {
+    e.inResolve = h, p();
+  })));
+  return (u) => ({
+    key: u,
+    in: async (f) => (c(f, u), (await m(u, "in"))(f)),
+    out: async (f) => (await m(u, "out"))(f)
+  });
+}
+function qe(t, e, n) {
+  for (const r of n)
+    if (D(t, r.from) && D(e, r.to))
+      return r.transition;
+  for (const r of n)
+    if ((r.from === "*" || D(t, r.from)) && (r.to === "*" || D(e, r.to)))
+      return r.transition;
+  return null;
+}
+function D(t, e) {
+  if (e === "*")
+    return !0;
+  if (e.endsWith("/*")) {
+    const n = e.slice(0, -2);
+    return t === n || t.startsWith(n + "/");
+  }
+  return t === e;
+}
+const Be = $e, Pt = Lt(null), _e = Pt.Provider, We = () => {
+  const t = qt(Pt);
+  if (!t)
+    throw new Error("useSsgoi must be used within SsgoiProvider");
+  return t;
+}, ze = ({ config: t, children: e }) => {
+  const n = Bt(
+    () => Le(t),
+    [t]
+  );
+  return /* @__PURE__ */ mt(_e, { value: n, children: e });
+}, Ze = ({
+  children: t,
+  id: e
+}) => {
+  const n = We();
+  return /* @__PURE__ */ mt("div", { ref: Be(n(e)), "data-ssgoi-transition": e, children: t });
+};
+export {
+  ze as Ssgoi,
+  Ze as SsgoiTransition,
+  Be as transition
+};