@equal-experts/kuat-vue 0.9.2 → 0.11.0

package/dist/CarouselNext.vue_vue_type_script_setup_true_lang-BvnpmYmA.js

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