@orchidui/dashboard 1.8.1-93 → 1.8.1-96

package/dist/ui/carousel/useCarousel.js

@@ -0,0 +1,1288 @@
+import { isRef as jt, shallowRef as zt, onMounted as Kt, onBeforeUnmount as cn, watch as Rt, ref as Gt } from "vue";
+import { f as un } from "../../index-OpE2oGce.js";
+function fn(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Ht(t) {
+  return fn(t) || Array.isArray(t);
+}
+function an() {
+  return !!(typeof window < "u" && window.document && window.document.createElement);
+}
+function It(t, n) {
+  const r = Object.keys(t), s = Object.keys(n);
+  if (r.length !== s.length) return !1;
+  const c = JSON.stringify(Object.keys(t.breakpoints || {})), e = JSON.stringify(Object.keys(n.breakpoints || {}));
+  return c !== e ? !1 : r.every((o) => {
+    const u = t[o], i = n[o];
+    return typeof u == "function" ? `${u}` == `${i}` : !Ht(u) || !Ht(i) ? u === i : It(u, i);
+  });
+}
+function qt(t) {
+  return t.concat().sort((n, r) => n.name > r.name ? 1 : -1).map((n) => n.options);
+}
+function ln(t, n) {
+  if (t.length !== n.length) return !1;
+  const r = qt(t), s = qt(n);
+  return r.every((c, e) => {
+    const o = s[e];
+    return It(c, o);
+  });
+}
+function Tt(t) {
+  return typeof t == "number";
+}
+function Et(t) {
+  return typeof t == "string";
+}
+function ht(t) {
+  return typeof t == "boolean";
+}
+function Ut(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function P(t) {
+  return Math.abs(t);
+}
+function At(t) {
+  return Math.sign(t);
+}
+function ft(t, n) {
+  return P(t - n);
+}
+function dn(t, n) {
+  if (t === 0 || n === 0 || P(t) <= P(n)) return 0;
+  const r = ft(P(t), P(n));
+  return P(r / t);
+}
+function pn(t) {
+  return Math.round(t * 100) / 100;
+}
+function at(t) {
+  return lt(t).map(Number);
+}
+function j(t) {
+  return t[pt(t)];
+}
+function pt(t) {
+  return Math.max(0, t.length - 1);
+}
+function Ot(t, n) {
+  return n === pt(t);
+}
+function $t(t, n = 0) {
+  return Array.from(Array(t), (r, s) => n + s);
+}
+function lt(t) {
+  return Object.keys(t);
+}
+function Qt(t, n) {
+  return [t, n].reduce((r, s) => (lt(s).forEach((c) => {
+    const e = r[c], o = s[c], u = Ut(e) && Ut(o);
+    r[c] = u ? Qt(e, o) : o;
+  }), r), {});
+}
+function Lt(t, n) {
+  return typeof n.MouseEvent < "u" && t instanceof n.MouseEvent;
+}
+function mn(t, n) {
+  const r = {
+    start: s,
+    center: c,
+    end: e
+  };
+  function s() {
+    return 0;
+  }
+  function c(i) {
+    return e(i) / 2;
+  }
+  function e(i) {
+    return n - i;
+  }
+  function o(i, f) {
+    return Et(t) ? r[t](i) : t(n, i, f);
+  }
+  return {
+    measure: o
+  };
+}
+function dt() {
+  let t = [];
+  function n(c, e, o, u = {
+    passive: !0
+  }) {
+    let i;
+    if ("addEventListener" in c)
+      c.addEventListener(e, o, u), i = () => c.removeEventListener(e, o, u);
+    else {
+      const f = c;
+      f.addListener(o), i = () => f.removeListener(o);
+    }
+    return t.push(i), s;
+  }
+  function r() {
+    t = t.filter((c) => c());
+  }
+  const s = {
+    add: n,
+    clear: r
+  };
+  return s;
+}
+function gn(t, n, r, s) {
+  const c = dt(), e = 1e3 / 60;
+  let o = null, u = 0, i = 0;
+  function f() {
+    c.add(t, "visibilitychange", () => {
+      t.hidden && d();
+    });
+  }
+  function g() {
+    y(), c.clear();
+  }
+  function a(h) {
+    if (!i) return;
+    o || (o = h, r(), r());
+    const l = h - o;
+    for (o = h, u += l; u >= e; )
+      r(), u -= e;
+    const S = u / e;
+    s(S), i && (i = n.requestAnimationFrame(a));
+  }
+  function p() {
+    i || (i = n.requestAnimationFrame(a));
+  }
+  function y() {
+    n.cancelAnimationFrame(i), o = null, u = 0, i = 0;
+  }
+  function d() {
+    o = null, u = 0;
+  }
+  return {
+    init: f,
+    destroy: g,
+    start: p,
+    stop: y,
+    update: r,
+    render: s
+  };
+}
+function hn(t, n) {
+  const r = n === "rtl", s = t === "y", c = s ? "y" : "x", e = s ? "x" : "y", o = !s && r ? -1 : 1, u = g(), i = a();
+  function f(d) {
+    const {
+      height: m,
+      width: h
+    } = d;
+    return s ? m : h;
+  }
+  function g() {
+    return s ? "top" : r ? "right" : "left";
+  }
+  function a() {
+    return s ? "bottom" : r ? "left" : "right";
+  }
+  function p(d) {
+    return d * o;
+  }
+  return {
+    scroll: c,
+    cross: e,
+    startEdge: u,
+    endEdge: i,
+    measureSize: f,
+    direction: p
+  };
+}
+function tt(t = 0, n = 0) {
+  const r = P(t - n);
+  function s(f) {
+    return f < t;
+  }
+  function c(f) {
+    return f > n;
+  }
+  function e(f) {
+    return s(f) || c(f);
+  }
+  function o(f) {
+    return e(f) ? s(f) ? t : n : f;
+  }
+  function u(f) {
+    return r ? f - r * Math.ceil((f - n) / r) : f;
+  }
+  return {
+    length: r,
+    max: n,
+    min: t,
+    constrain: o,
+    reachedAny: e,
+    reachedMax: c,
+    reachedMin: s,
+    removeOffset: u
+  };
+}
+function Jt(t, n, r) {
+  const {
+    constrain: s
+  } = tt(0, t), c = t + 1;
+  let e = o(n);
+  function o(p) {
+    return r ? P((c + p) % c) : s(p);
+  }
+  function u() {
+    return e;
+  }
+  function i(p) {
+    return e = o(p), a;
+  }
+  function f(p) {
+    return g().set(u() + p);
+  }
+  function g() {
+    return Jt(t, u(), r);
+  }
+  const a = {
+    get: u,
+    set: i,
+    add: f,
+    clone: g
+  };
+  return a;
+}
+function Sn(t, n, r, s, c, e, o, u, i, f, g, a, p, y, d, m, h, l, S) {
+  const {
+    cross: x,
+    direction: L
+  } = t, D = ["INPUT", "SELECT", "TEXTAREA"], I = {
+    passive: !1
+  }, v = dt(), E = dt(), T = tt(50, 225).constrain(y.measure(20)), w = {
+    mouse: 300,
+    touch: 400
+  }, A = {
+    mouse: 500,
+    touch: 600
+  }, k = d ? 43 : 25;
+  let z = !1, R = 0, G = 0, _ = !1, X = !1, U = !1, $ = !1;
+  function rt(b) {
+    if (!S) return;
+    function O(N) {
+      (ht(S) || S(b, N)) && it(N);
+    }
+    const C = n;
+    v.add(C, "dragstart", (N) => N.preventDefault(), I).add(C, "touchmove", () => {
+    }, I).add(C, "touchend", () => {
+    }).add(C, "touchstart", O).add(C, "mousedown", O).add(C, "touchcancel", F).add(C, "contextmenu", F).add(C, "click", Q, !0);
+  }
+  function H() {
+    v.clear(), E.clear();
+  }
+  function nt() {
+    const b = $ ? r : n;
+    E.add(b, "touchmove", B, I).add(b, "touchend", F).add(b, "mousemove", B, I).add(b, "mouseup", F);
+  }
+  function et(b) {
+    const O = b.nodeName || "";
+    return D.includes(O);
+  }
+  function K() {
+    return (d ? A : w)[$ ? "mouse" : "touch"];
+  }
+  function st(b, O) {
+    const C = a.add(At(b) * -1), N = g.byDistance(b, !d).distance;
+    return d || P(b) < T ? N : h && O ? N * 0.5 : g.byIndex(C.get(), 0).distance;
+  }
+  function it(b) {
+    const O = Lt(b, s);
+    $ = O, U = d && O && !b.buttons && z, z = ft(c.get(), o.get()) >= 2, !(O && b.button !== 0) && (et(b.target) || (_ = !0, e.pointerDown(b), f.useFriction(0).useDuration(0), c.set(o), nt(), R = e.readPoint(b), G = e.readPoint(b, x), p.emit("pointerDown")));
+  }
+  function B(b) {
+    if (!Lt(b, s) && b.touches.length >= 2) return F(b);
+    const C = e.readPoint(b), N = e.readPoint(b, x), q = ft(C, R), J = ft(N, G);
+    if (!X && !$ && (!b.cancelable || (X = q > J, !X)))
+      return F(b);
+    const Z = e.pointerMove(b);
+    q > m && (U = !0), f.useFriction(0.3).useDuration(0.75), u.start(), c.add(L(Z)), b.preventDefault();
+  }
+  function F(b) {
+    const C = g.byDistance(0, !1).index !== a.get(), N = e.pointerUp(b) * K(), q = st(L(N), C), J = dn(N, q), Z = k - 10 * J, Y = l + J / 50;
+    X = !1, _ = !1, E.clear(), f.useDuration(Z).useFriction(Y), i.distance(q, !d), $ = !1, p.emit("pointerUp");
+  }
+  function Q(b) {
+    U && (b.stopPropagation(), b.preventDefault(), U = !1);
+  }
+  function V() {
+    return _;
+  }
+  return {
+    init: rt,
+    destroy: H,
+    pointerDown: V
+  };
+}
+function yn(t, n) {
+  let s, c;
+  function e(a) {
+    return a.timeStamp;
+  }
+  function o(a, p) {
+    const d = `client${(p || t.scroll) === "x" ? "X" : "Y"}`;
+    return (Lt(a, n) ? a : a.touches[0])[d];
+  }
+  function u(a) {
+    return s = a, c = a, o(a);
+  }
+  function i(a) {
+    const p = o(a) - o(c), y = e(a) - e(s) > 170;
+    return c = a, y && (s = a), p;
+  }
+  function f(a) {
+    if (!s || !c) return 0;
+    const p = o(c) - o(s), y = e(a) - e(s), d = e(a) - e(c) > 170, m = p / y;
+    return y && !d && P(m) > 0.1 ? m : 0;
+  }
+  return {
+    pointerDown: u,
+    pointerMove: i,
+    pointerUp: f,
+    readPoint: o
+  };
+}
+function bn() {
+  function t(r) {
+    const {
+      offsetTop: s,
+      offsetLeft: c,
+      offsetWidth: e,
+      offsetHeight: o
+    } = r;
+    return {
+      top: s,
+      right: c + e,
+      bottom: s + o,
+      left: c,
+      width: e,
+      height: o
+    };
+  }
+  return {
+    measure: t
+  };
+}
+function xn(t) {
+  function n(s) {
+    return t * (s / 100);
+  }
+  return {
+    measure: n
+  };
+}
+function vn(t, n, r, s, c, e, o) {
+  const u = [t].concat(s);
+  let i, f, g = [], a = !1;
+  function p(h) {
+    return c.measureSize(o.measure(h));
+  }
+  function y(h) {
+    if (!e) return;
+    f = p(t), g = s.map(p);
+    function l(S) {
+      for (const x of S) {
+        if (a) return;
+        const L = x.target === t, D = s.indexOf(x.target), I = L ? f : g[D], v = p(L ? t : s[D]);
+        if (P(v - I) >= 0.5) {
+          h.reInit(), n.emit("resize");
+          break;
+        }
+      }
+    }
+    i = new ResizeObserver((S) => {
+      (ht(e) || e(h, S)) && l(S);
+    }), r.requestAnimationFrame(() => {
+      u.forEach((S) => i.observe(S));
+    });
+  }
+  function d() {
+    a = !0, i && i.disconnect();
+  }
+  return {
+    init: y,
+    destroy: d
+  };
+}
+function En(t, n, r, s, c, e) {
+  let o = 0, u = 0, i = c, f = e, g = t.get(), a = 0;
+  function p() {
+    const I = s.get() - t.get(), v = !i;
+    let E = 0;
+    return v ? (o = 0, r.set(s), t.set(s), E = I) : (r.set(t), o += I / i, o *= f, g += o, t.add(o), E = g - a), u = At(E), a = g, D;
+  }
+  function y() {
+    const I = s.get() - n.get();
+    return P(I) < 1e-3;
+  }
+  function d() {
+    return i;
+  }
+  function m() {
+    return u;
+  }
+  function h() {
+    return o;
+  }
+  function l() {
+    return x(c);
+  }
+  function S() {
+    return L(e);
+  }
+  function x(I) {
+    return i = I, D;
+  }
+  function L(I) {
+    return f = I, D;
+  }
+  const D = {
+    direction: m,
+    duration: d,
+    velocity: h,
+    seek: p,
+    settled: y,
+    useBaseFriction: S,
+    useBaseDuration: l,
+    useFriction: L,
+    useDuration: x
+  };
+  return D;
+}
+function Ln(t, n, r, s, c) {
+  const e = c.measure(10), o = c.measure(50), u = tt(0.1, 0.99);
+  let i = !1;
+  function f() {
+    return !(i || !t.reachedAny(r.get()) || !t.reachedAny(n.get()));
+  }
+  function g(y) {
+    if (!f()) return;
+    const d = t.reachedMin(n.get()) ? "min" : "max", m = P(t[d] - n.get()), h = r.get() - n.get(), l = u.constrain(m / o);
+    r.subtract(h * l), !y && P(h) < e && (r.set(t.constrain(r.get())), s.useDuration(25).useBaseFriction());
+  }
+  function a(y) {
+    i = !y;
+  }
+  return {
+    shouldConstrain: f,
+    constrain: g,
+    toggleActive: a
+  };
+}
+function In(t, n, r, s, c) {
+  const e = tt(-n + t, 0), o = a(), u = g(), i = p();
+  function f(d, m) {
+    return ft(d, m) <= 1;
+  }
+  function g() {
+    const d = o[0], m = j(o), h = o.lastIndexOf(d), l = o.indexOf(m) + 1;
+    return tt(h, l);
+  }
+  function a() {
+    return r.map((d, m) => {
+      const {
+        min: h,
+        max: l
+      } = e, S = e.constrain(d), x = !m, L = Ot(r, m);
+      return x ? l : L || f(h, S) ? h : f(l, S) ? l : S;
+    }).map((d) => parseFloat(d.toFixed(3)));
+  }
+  function p() {
+    if (n <= t + c) return [e.max];
+    if (s === "keepSnaps") return o;
+    const {
+      min: d,
+      max: m
+    } = u;
+    return o.slice(d, m);
+  }
+  return {
+    snapsContained: i,
+    scrollContainLimit: u
+  };
+}
+function Tn(t, n, r) {
+  const s = n[0], c = r ? s - t : j(n);
+  return {
+    limit: tt(c, s)
+  };
+}
+function An(t, n, r, s) {
+  const e = n.min + 0.1, o = n.max + 0.1, {
+    reachedMin: u,
+    reachedMax: i
+  } = tt(e, o);
+  function f(p) {
+    return p === 1 ? i(r.get()) : p === -1 ? u(r.get()) : !1;
+  }
+  function g(p) {
+    if (!f(p)) return;
+    const y = t * (p * -1);
+    s.forEach((d) => d.add(y));
+  }
+  return {
+    loop: g
+  };
+}
+function On(t) {
+  const {
+    max: n,
+    length: r
+  } = t;
+  function s(e) {
+    const o = e - n;
+    return r ? o / -r : 0;
+  }
+  return {
+    get: s
+  };
+}
+function Dn(t, n, r, s, c) {
+  const {
+    startEdge: e,
+    endEdge: o
+  } = t, {
+    groupSlides: u
+  } = c, i = a().map(n.measure), f = p(), g = y();
+  function a() {
+    return u(s).map((m) => j(m)[o] - m[0][e]).map(P);
+  }
+  function p() {
+    return s.map((m) => r[e] - m[e]).map((m) => -P(m));
+  }
+  function y() {
+    return u(f).map((m) => m[0]).map((m, h) => m + i[h]);
+  }
+  return {
+    snaps: f,
+    snapsAligned: g
+  };
+}
+function Mn(t, n, r, s, c, e) {
+  const {
+    groupSlides: o
+  } = c, {
+    min: u,
+    max: i
+  } = s, f = g();
+  function g() {
+    const p = o(e), y = !t || n === "keepSnaps";
+    return r.length === 1 ? [e] : y ? p : p.slice(u, i).map((d, m, h) => {
+      const l = !m, S = Ot(h, m);
+      if (l) {
+        const x = j(h[0]) + 1;
+        return $t(x);
+      }
+      if (S) {
+        const x = pt(e) - j(h)[0] + 1;
+        return $t(x, j(h)[0]);
+      }
+      return d;
+    });
+  }
+  return {
+    slideRegistry: f
+  };
+}
+function Pn(t, n, r, s, c) {
+  const {
+    reachedAny: e,
+    removeOffset: o,
+    constrain: u
+  } = s;
+  function i(d) {
+    return d.concat().sort((m, h) => P(m) - P(h))[0];
+  }
+  function f(d) {
+    const m = t ? o(d) : u(d), h = n.map((S, x) => ({
+      diff: g(S - m, 0),
+      index: x
+    })).sort((S, x) => P(S.diff) - P(x.diff)), {
+      index: l
+    } = h[0];
+    return {
+      index: l,
+      distance: m
+    };
+  }
+  function g(d, m) {
+    const h = [d, d + r, d - r];
+    if (!t) return d;
+    if (!m) return i(h);
+    const l = h.filter((S) => At(S) === m);
+    return l.length ? i(l) : j(h) - r;
+  }
+  function a(d, m) {
+    const h = n[d] - c.get(), l = g(h, m);
+    return {
+      index: d,
+      distance: l
+    };
+  }
+  function p(d, m) {
+    const h = c.get() + d, {
+      index: l,
+      distance: S
+    } = f(h), x = !t && e(h);
+    if (!m || x) return {
+      index: l,
+      distance: d
+    };
+    const L = n[l] - S, D = d + g(L, 0);
+    return {
+      index: l,
+      distance: D
+    };
+  }
+  return {
+    byDistance: p,
+    byIndex: a,
+    shortcut: g
+  };
+}
+function wn(t, n, r, s, c, e, o) {
+  function u(a) {
+    const p = a.distance, y = a.index !== n.get();
+    e.add(p), p && (s.duration() ? t.start() : (t.update(), t.render(1), t.update())), y && (r.set(n.get()), n.set(a.index), o.emit("select"));
+  }
+  function i(a, p) {
+    const y = c.byDistance(a, p);
+    u(y);
+  }
+  function f(a, p) {
+    const y = n.clone().set(a), d = c.byIndex(y.get(), p);
+    u(d);
+  }
+  return {
+    distance: i,
+    index: f
+  };
+}
+function Cn(t, n, r, s, c, e, o, u) {
+  const i = {
+    passive: !0,
+    capture: !0
+  };
+  let f = 0;
+  function g(y) {
+    if (!u) return;
+    function d(m) {
+      if ((/* @__PURE__ */ new Date()).getTime() - f > 10) return;
+      o.emit("slideFocusStart"), t.scrollLeft = 0;
+      const S = r.findIndex((x) => x.includes(m));
+      Tt(S) && (c.useDuration(0), s.index(S, 0), o.emit("slideFocus"));
+    }
+    e.add(document, "keydown", a, !1), n.forEach((m, h) => {
+      e.add(m, "focus", (l) => {
+        (ht(u) || u(y, l)) && d(h);
+      }, i);
+    });
+  }
+  function a(y) {
+    y.code === "Tab" && (f = (/* @__PURE__ */ new Date()).getTime());
+  }
+  return {
+    init: g
+  };
+}
+function ut(t) {
+  let n = t;
+  function r() {
+    return n;
+  }
+  function s(i) {
+    n = o(i);
+  }
+  function c(i) {
+    n += o(i);
+  }
+  function e(i) {
+    n -= o(i);
+  }
+  function o(i) {
+    return Tt(i) ? i : i.get();
+  }
+  return {
+    get: r,
+    set: s,
+    add: c,
+    subtract: e
+  };
+}
+function Xt(t, n) {
+  const r = t.scroll === "x" ? o : u, s = n.style;
+  let c = null, e = !1;
+  function o(p) {
+    return `translate3d(${p}px,0px,0px)`;
+  }
+  function u(p) {
+    return `translate3d(0px,${p}px,0px)`;
+  }
+  function i(p) {
+    if (e) return;
+    const y = pn(t.direction(p));
+    y !== c && (s.transform = r(y), c = y);
+  }
+  function f(p) {
+    e = !p;
+  }
+  function g() {
+    e || (s.transform = "", n.getAttribute("style") || n.removeAttribute("style"));
+  }
+  return {
+    clear: g,
+    to: i,
+    toggleActive: f
+  };
+}
+function Fn(t, n, r, s, c, e, o, u, i) {
+  const g = at(c), a = at(c).reverse(), p = l().concat(S());
+  function y(v, E) {
+    return v.reduce((T, w) => T - c[w], E);
+  }
+  function d(v, E) {
+    return v.reduce((T, w) => y(T, E) > 0 ? T.concat([w]) : T, []);
+  }
+  function m(v) {
+    return e.map((E, T) => ({
+      start: E - s[T] + 0.5 + v,
+      end: E + n - 0.5 + v
+    }));
+  }
+  function h(v, E, T) {
+    const w = m(E);
+    return v.map((A) => {
+      const k = T ? 0 : -r, z = T ? r : 0, R = T ? "end" : "start", G = w[A][R];
+      return {
+        index: A,
+        loopPoint: G,
+        slideLocation: ut(-1),
+        translate: Xt(t, i[A]),
+        target: () => u.get() > G ? k : z
+      };
+    });
+  }
+  function l() {
+    const v = o[0], E = d(a, v);
+    return h(E, r, !1);
+  }
+  function S() {
+    const v = n - o[0] - 1, E = d(g, v);
+    return h(E, -r, !0);
+  }
+  function x() {
+    return p.every(({
+      index: v
+    }) => {
+      const E = g.filter((T) => T !== v);
+      return y(E, n) <= 0.1;
+    });
+  }
+  function L() {
+    p.forEach((v) => {
+      const {
+        target: E,
+        translate: T,
+        slideLocation: w
+      } = v, A = E();
+      A !== w.get() && (T.to(A), w.set(A));
+    });
+  }
+  function D() {
+    p.forEach((v) => v.translate.clear());
+  }
+  return {
+    canLoop: x,
+    clear: D,
+    loop: L,
+    loopPoints: p
+  };
+}
+function Nn(t, n, r) {
+  let s, c = !1;
+  function e(i) {
+    if (!r) return;
+    function f(g) {
+      for (const a of g)
+        if (a.type === "childList") {
+          i.reInit(), n.emit("slidesChanged");
+          break;
+        }
+    }
+    s = new MutationObserver((g) => {
+      c || (ht(r) || r(i, g)) && f(g);
+    }), s.observe(t, {
+      childList: !0
+    });
+  }
+  function o() {
+    s && s.disconnect(), c = !0;
+  }
+  return {
+    init: e,
+    destroy: o
+  };
+}
+function kn(t, n, r, s) {
+  const c = {};
+  let e = null, o = null, u, i = !1;
+  function f() {
+    u = new IntersectionObserver((d) => {
+      i || (d.forEach((m) => {
+        const h = n.indexOf(m.target);
+        c[h] = m;
+      }), e = null, o = null, r.emit("slidesInView"));
+    }, {
+      root: t.parentElement,
+      threshold: s
+    }), n.forEach((d) => u.observe(d));
+  }
+  function g() {
+    u && u.disconnect(), i = !0;
+  }
+  function a(d) {
+    return lt(c).reduce((m, h) => {
+      const l = parseInt(h), {
+        isIntersecting: S
+      } = c[l];
+      return (d && S || !d && !S) && m.push(l), m;
+    }, []);
+  }
+  function p(d = !0) {
+    if (d && e) return e;
+    if (!d && o) return o;
+    const m = a(d);
+    return d && (e = m), d || (o = m), m;
+  }
+  return {
+    init: f,
+    destroy: g,
+    get: p
+  };
+}
+function Bn(t, n, r, s, c, e) {
+  const {
+    measureSize: o,
+    startEdge: u,
+    endEdge: i
+  } = t, f = r[0] && c, g = d(), a = m(), p = r.map(o), y = h();
+  function d() {
+    if (!f) return 0;
+    const S = r[0];
+    return P(n[u] - S[u]);
+  }
+  function m() {
+    if (!f) return 0;
+    const S = e.getComputedStyle(j(s));
+    return parseFloat(S.getPropertyValue(`margin-${i}`));
+  }
+  function h() {
+    return r.map((S, x, L) => {
+      const D = !x, I = Ot(L, x);
+      return D ? p[x] + g : I ? p[x] + a : L[x + 1][u] - S[u];
+    }).map(P);
+  }
+  return {
+    slideSizes: p,
+    slideSizesWithGaps: y,
+    startGap: g,
+    endGap: a
+  };
+}
+function Vn(t, n, r, s, c, e, o, u, i) {
+  const {
+    startEdge: f,
+    endEdge: g,
+    direction: a
+  } = t, p = Tt(r);
+  function y(l, S) {
+    return at(l).filter((x) => x % S === 0).map((x) => l.slice(x, x + S));
+  }
+  function d(l) {
+    return l.length ? at(l).reduce((S, x, L) => {
+      const D = j(S) || 0, I = D === 0, v = x === pt(l), E = c[f] - e[D][f], T = c[f] - e[x][g], w = !s && I ? a(o) : 0, A = !s && v ? a(u) : 0, k = P(T - A - (E + w));
+      return L && k > n + i && S.push(x), v && S.push(l.length), S;
+    }, []).map((S, x, L) => {
+      const D = Math.max(L[x - 1] || 0);
+      return l.slice(D, S);
+    }) : [];
+  }
+  function m(l) {
+    return p ? y(l, r) : d(l);
+  }
+  return {
+    groupSlides: m
+  };
+}
+function jn(t, n, r, s, c, e, o) {
+  const {
+    align: u,
+    axis: i,
+    direction: f,
+    startIndex: g,
+    loop: a,
+    duration: p,
+    dragFree: y,
+    dragThreshold: d,
+    inViewThreshold: m,
+    slidesToScroll: h,
+    skipSnaps: l,
+    containScroll: S,
+    watchResize: x,
+    watchSlides: L,
+    watchDrag: D,
+    watchFocus: I
+  } = e, v = 2, E = bn(), T = E.measure(n), w = r.map(E.measure), A = hn(i, f), k = A.measureSize(T), z = xn(k), R = mn(u, k), G = !a && !!S, _ = a || !!S, {
+    slideSizes: X,
+    slideSizesWithGaps: U,
+    startGap: $,
+    endGap: rt
+  } = Bn(A, T, w, r, _, c), H = Vn(A, k, h, a, T, w, $, rt, v), {
+    snaps: nt,
+    snapsAligned: et
+  } = Dn(A, R, T, w, H), K = -j(nt) + j(U), {
+    snapsContained: st,
+    scrollContainLimit: it
+  } = In(k, K, et, S, v), B = G ? st : et, {
+    limit: F
+  } = Tn(K, B, a), Q = Jt(pt(B), g, a), V = Q.clone(), M = at(r), b = ({
+    dragHandler: ot,
+    scrollBody: xt,
+    scrollBounds: vt,
+    options: {
+      loop: mt
+    }
+  }) => {
+    mt || vt.constrain(ot.pointerDown()), xt.seek();
+  }, O = ({
+    scrollBody: ot,
+    translate: xt,
+    location: vt,
+    offsetLocation: mt,
+    previousLocation: Zt,
+    scrollLooper: Wt,
+    slideLooper: tn,
+    dragHandler: nn,
+    animation: en,
+    eventHandler: Ct,
+    scrollBounds: on,
+    options: {
+      loop: Ft
+    }
+  }, Nt) => {
+    const kt = ot.settled(), rn = !on.shouldConstrain(), Bt = Ft ? kt : kt && rn, Vt = Bt && !nn.pointerDown();
+    Vt && en.stop();
+    const sn = vt.get() * Nt + Zt.get() * (1 - Nt);
+    mt.set(sn), Ft && (Wt.loop(ot.direction()), tn.loop()), xt.to(mt.get()), Vt && Ct.emit("settle"), Bt || Ct.emit("scroll");
+  }, C = gn(s, c, () => b(bt), (ot) => O(bt, ot)), N = 0.68, q = B[Q.get()], J = ut(q), Z = ut(q), Y = ut(q), W = ut(q), ct = En(J, Y, Z, W, p, N), St = Pn(a, B, K, F, W), yt = wn(C, Q, V, ct, St, W, o), Mt = On(F), Pt = dt(), Yt = kn(n, r, o, m), {
+    slideRegistry: wt
+  } = Mn(G, S, B, it, H, M), _t = Cn(t, r, wt, yt, ct, Pt, o, I), bt = {
+    ownerDocument: s,
+    ownerWindow: c,
+    eventHandler: o,
+    containerRect: T,
+    slideRects: w,
+    animation: C,
+    axis: A,
+    dragHandler: Sn(A, t, s, c, W, yn(A, c), J, C, yt, ct, St, Q, o, z, y, d, l, N, D),
+    eventStore: Pt,
+    percentOfView: z,
+    index: Q,
+    indexPrevious: V,
+    limit: F,
+    location: J,
+    offsetLocation: Y,
+    previousLocation: Z,
+    options: e,
+    resizeHandler: vn(n, o, c, r, A, x, E),
+    scrollBody: ct,
+    scrollBounds: Ln(F, Y, W, ct, z),
+    scrollLooper: An(K, F, Y, [J, Y, Z, W]),
+    scrollProgress: Mt,
+    scrollSnapList: B.map(Mt.get),
+    scrollSnaps: B,
+    scrollTarget: St,
+    scrollTo: yt,
+    slideLooper: Fn(A, k, K, X, U, nt, B, Y, r),
+    slideFocus: _t,
+    slidesHandler: Nn(n, o, L),
+    slidesInView: Yt,
+    slideIndexes: M,
+    slideRegistry: wt,
+    slidesToScroll: H,
+    target: W,
+    translate: Xt(A, n)
+  };
+  return bt;
+}
+function zn() {
+  let t = {}, n;
+  function r(f) {
+    n = f;
+  }
+  function s(f) {
+    return t[f] || [];
+  }
+  function c(f) {
+    return s(f).forEach((g) => g(n, f)), i;
+  }
+  function e(f, g) {
+    return t[f] = s(f).concat([g]), i;
+  }
+  function o(f, g) {
+    return t[f] = s(f).filter((a) => a !== g), i;
+  }
+  function u() {
+    t = {};
+  }
+  const i = {
+    init: r,
+    emit: c,
+    off: o,
+    on: e,
+    clear: u
+  };
+  return i;
+}
+const Rn = {
+  align: "center",
+  axis: "x",
+  container: null,
+  slides: null,
+  containScroll: "trimSnaps",
+  direction: "ltr",
+  slidesToScroll: 1,
+  inViewThreshold: 0,
+  breakpoints: {},
+  dragFree: !1,
+  dragThreshold: 10,
+  loop: !1,
+  skipSnaps: !1,
+  duration: 25,
+  startIndex: 0,
+  active: !0,
+  watchDrag: !0,
+  watchResize: !0,
+  watchSlides: !0,
+  watchFocus: !0
+};
+function Gn(t) {
+  function n(e, o) {
+    return Qt(e, o || {});
+  }
+  function r(e) {
+    const o = e.breakpoints || {}, u = lt(o).filter((i) => t.matchMedia(i).matches).map((i) => o[i]).reduce((i, f) => n(i, f), {});
+    return n(e, u);
+  }
+  function s(e) {
+    return e.map((o) => lt(o.breakpoints || {})).reduce((o, u) => o.concat(u), []).map(t.matchMedia);
+  }
+  return {
+    mergeOptions: n,
+    optionsAtMedia: r,
+    optionsMediaQueries: s
+  };
+}
+function Hn(t) {
+  let n = [];
+  function r(e, o) {
+    return n = o.filter(({
+      options: u
+    }) => t.optionsAtMedia(u).active !== !1), n.forEach((u) => u.init(e, t)), o.reduce((u, i) => Object.assign(u, {
+      [i.name]: i
+    }), {});
+  }
+  function s() {
+    n = n.filter((e) => e.destroy());
+  }
+  return {
+    init: r,
+    destroy: s
+  };
+}
+function gt(t, n, r) {
+  const s = t.ownerDocument, c = s.defaultView, e = Gn(c), o = Hn(e), u = dt(), i = zn(), {
+    mergeOptions: f,
+    optionsAtMedia: g,
+    optionsMediaQueries: a
+  } = e, {
+    on: p,
+    off: y,
+    emit: d
+  } = i, m = A;
+  let h = !1, l, S = f(Rn, gt.globalOptions), x = f(S), L = [], D, I, v;
+  function E() {
+    const {
+      container: M,
+      slides: b
+    } = x;
+    I = (Et(M) ? t.querySelector(M) : M) || t.children[0];
+    const C = Et(b) ? I.querySelectorAll(b) : b;
+    v = [].slice.call(C || I.children);
+  }
+  function T(M) {
+    const b = jn(t, I, v, s, c, M, i);
+    if (M.loop && !b.slideLooper.canLoop()) {
+      const O = Object.assign({}, M, {
+        loop: !1
+      });
+      return T(O);
+    }
+    return b;
+  }
+  function w(M, b) {
+    h || (S = f(S, M), x = g(S), L = b || L, E(), l = T(x), a([S, ...L.map(({
+      options: O
+    }) => O)]).forEach((O) => u.add(O, "change", A)), x.active && (l.translate.to(l.location.get()), l.animation.init(), l.slidesInView.init(), l.slideFocus.init(V), l.eventHandler.init(V), l.resizeHandler.init(V), l.slidesHandler.init(V), l.options.loop && l.slideLooper.loop(), I.offsetParent && v.length && l.dragHandler.init(V), D = o.init(V, L)));
+  }
+  function A(M, b) {
+    const O = H();
+    k(), w(f({
+      startIndex: O
+    }, M), b), i.emit("reInit");
+  }
+  function k() {
+    l.dragHandler.destroy(), l.eventStore.clear(), l.translate.clear(), l.slideLooper.clear(), l.resizeHandler.destroy(), l.slidesHandler.destroy(), l.slidesInView.destroy(), l.animation.destroy(), o.destroy(), u.clear();
+  }
+  function z() {
+    h || (h = !0, u.clear(), k(), i.emit("destroy"), i.clear());
+  }
+  function R(M, b, O) {
+    !x.active || h || (l.scrollBody.useBaseFriction().useDuration(b === !0 ? 0 : x.duration), l.scrollTo.index(M, O || 0));
+  }
+  function G(M) {
+    const b = l.index.add(1).get();
+    R(b, M, -1);
+  }
+  function _(M) {
+    const b = l.index.add(-1).get();
+    R(b, M, 1);
+  }
+  function X() {
+    return l.index.add(1).get() !== H();
+  }
+  function U() {
+    return l.index.add(-1).get() !== H();
+  }
+  function $() {
+    return l.scrollSnapList;
+  }
+  function rt() {
+    return l.scrollProgress.get(l.offsetLocation.get());
+  }
+  function H() {
+    return l.index.get();
+  }
+  function nt() {
+    return l.indexPrevious.get();
+  }
+  function et() {
+    return l.slidesInView.get();
+  }
+  function K() {
+    return l.slidesInView.get(!1);
+  }
+  function st() {
+    return D;
+  }
+  function it() {
+    return l;
+  }
+  function B() {
+    return t;
+  }
+  function F() {
+    return I;
+  }
+  function Q() {
+    return v;
+  }
+  const V = {
+    canScrollNext: X,
+    canScrollPrev: U,
+    containerNode: F,
+    internalEngine: it,
+    destroy: z,
+    off: y,
+    on: p,
+    emit: d,
+    plugins: st,
+    previousScrollSnap: nt,
+    reInit: m,
+    rootNode: B,
+    scrollNext: G,
+    scrollPrev: _,
+    scrollProgress: rt,
+    scrollSnapList: $,
+    scrollTo: R,
+    selectedScrollSnap: H,
+    slideNodes: Q,
+    slidesInView: et,
+    slidesNotInView: K
+  };
+  return w(n, r), setTimeout(() => i.emit("init"), 0), V;
+}
+gt.globalOptions = void 0;
+function Dt(t = {}, n = []) {
+  const r = jt(t), s = jt(n);
+  let c = r ? t.value : t, e = s ? n.value : n;
+  const o = zt(), u = zt();
+  function i() {
+    u.value && u.value.reInit(c, e);
+  }
+  return Kt(() => {
+    !an() || !o.value || (gt.globalOptions = Dt.globalOptions, u.value = gt(o.value, c, e));
+  }), cn(() => {
+    u.value && u.value.destroy();
+  }), r && Rt(t, (f) => {
+    It(c, f) || (c = f, i());
+  }), s && Rt(n, (f) => {
+    ln(e, f) || (e = f, i());
+  }), [o, u];
+}
+Dt.globalOptions = void 0;
+const [Kn, qn] = un(
+  ({
+    opts: t,
+    orientation: n,
+    plugins: r
+  }, s) => {
+    const [c, e] = Dt({
+      ...t,
+      axis: n === "horizontal" ? "x" : "y"
+    }, r);
+    function o() {
+      var a;
+      (a = e.value) == null || a.scrollPrev();
+    }
+    function u() {
+      var a;
+      (a = e.value) == null || a.scrollNext();
+    }
+    const i = Gt(!1), f = Gt(!1);
+    function g(a) {
+      i.value = (a == null ? void 0 : a.canScrollNext()) || !1, f.value = (a == null ? void 0 : a.canScrollPrev()) || !1;
+    }
+    return Kt(() => {
+      var a, p, y;
+      e.value && ((a = e.value) == null || a.on("init", g), (p = e.value) == null || p.on("reInit", g), (y = e.value) == null || y.on("select", g), s("init-api", e.value));
+    }), { carouselRef: c, carouselApi: e, canScrollPrev: f, canScrollNext: i, scrollPrev: o, scrollNext: u, orientation: n };
+  }
+);
+function Qn() {
+  const t = qn();
+  if (!t)
+    throw new Error("useCarousel must be used within a <Carousel />");
+  return t;
+}
+export {
+  Qn as useCarousel,
+  Kn as useProvideCarousel
+};