@equal-experts/kuat-vue 0.8.0 → 0.9.2

package/dist/CarouselNext.vue_vue_type_script_setup_true_lang-Ccl5Fhm_.js

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