@bbl-digital/snorre 4.2.86 → 4.2.88

package/dist/snorre.es450.js

@@ -0,0 +1,1061 @@
+import Me, { useState as _, useCallback as D, useRef as b, useEffect as E, useMemo as vt, Fragment as pt } from "react";
+import { j as v } from "./snorre.es329.js";
+var mt = Object.defineProperty, bt = Object.defineProperties, yt = Object.getOwnPropertyDescriptors, Ae = Object.getOwnPropertySymbols, Ct = Object.prototype.hasOwnProperty, xt = Object.prototype.propertyIsEnumerable, St = Math.pow, Ee = (e, t, r) => t in e ? mt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, N = (e, t) => {
+  for (var r in t || (t = {}))
+    Ct.call(t, r) && Ee(e, r, t[r]);
+  if (Ae)
+    for (var r of Ae(t))
+      xt.call(t, r) && Ee(e, r, t[r]);
+  return e;
+}, Re = (e, t) => bt(e, yt(t)), wt = (e, t, r) => {
+  const [o, i] = _(), a = b(r);
+  return E(() => {
+    a.current = r;
+  }, [r]), E(() => {
+    const n = e == null ? void 0 : e.current, c = t == null ? void 0 : t.current;
+    if (!window.IntersectionObserver || !n || !c)
+      return;
+    const l = new IntersectionObserver(
+      (u) => {
+        u.forEach((d) => {
+          i(d), a.current(d);
+        });
+      },
+      {
+        threshold: [0.05, 0.95],
+        root: c
+      }
+    );
+    return l.observe(n), () => l.disconnect();
+  }, [e, t]), o;
+}, Mt = (e, t) => `${t ? 100 / (3 * e) : 100 / e}%`, Rt = (e, t, r, o, i, a, n, c, l, u, d) => {
+  const f = d ?? Mt(e, o), g = r ? 1 : 0, y = a === "fade" ? 200 : 500;
+  let C = "auto";
+  return l && (u ? C = "100%" : r ? C = "auto" : C = "0"), {
+    width: f,
+    height: C,
+    padding: `0 ${i ? i / 2 : 0}px`,
+    transition: a ? `${n || y}ms ease 0s` : void 0,
+    transform: a === "zoom" ? `scale(${t && r ? 1 : c || 0.85})` : void 0,
+    opacity: a === "fade" ? g : 1
+  };
+}, Dt = (e, t, r) => r === "prev-cloned" ? e - t : r === "next-cloned" ? e + t : e, Nt = ({
+  count: e,
+  children: t,
+  index: r,
+  isCurrentSlide: o,
+  typeOfSlide: i,
+  wrapAround: a,
+  cellSpacing: n,
+  slideWidth: c,
+  animation: l,
+  speed: u,
+  zoomScale: d,
+  onVisibleSlideHeightChange: f,
+  adaptiveHeight: g,
+  initializedAdaptiveHeight: y,
+  updateIOEntry: C,
+  id: B,
+  carouselRef: $
+}) => {
+  var G;
+  const H = a ? Dt(r, e, i) : r, J = b(null), L = wt(J, $, (k) => {
+    C(B, (k == null ? void 0 : k.intersectionRatio) >= 0.95);
+  }), F = !!(L != null && L.isIntersecting), V = ((G = L == null ? void 0 : L.intersectionRatio) != null ? G : 1) >= 0.95, S = b(!1);
+  E(() => {
+    var k;
+    const Q = J.current;
+    if (Q) {
+      const re = (k = Q.getBoundingClientRect()) == null ? void 0 : k.height, M = S.current;
+      F && !M ? f(H, re) : !F && M && f(H, null), S.current = F;
+    }
+  }, [H, F, f]);
+  const W = o && V ? " slide-current" : "";
+  return /* @__PURE__ */ v.jsx(
+    "div",
+    Re(N({
+      ref: J
+    }, { inert: V ? void 0 : "true" }), {
+      className: `slide${W}${i ? ` ${i}` : ""}${V ? " slide-visible" : ""}`,
+      style: Rt(
+        e,
+        o,
+        V,
+        a,
+        n,
+        l,
+        u,
+        d,
+        g,
+        y,
+        c
+      ),
+      children: t
+    })
+  );
+}, jt = Nt, Tt = {
+  position: "absolute",
+  width: "1px",
+  height: "1px",
+  overflow: "hidden",
+  padding: 0,
+  margin: "-1px",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  border: 0
+}, kt = ({
+  message: e,
+  ariaLive: t = "polite"
+}) => /* @__PURE__ */ v.jsx("div", { "aria-live": t, "aria-atomic": "true", style: Tt, tabIndex: -1, children: e }), It = ({
+  currentSlide: e,
+  count: t
+}) => `Slide ${e + 1} of ${t}`, _t = kt, $e = (e, t, r, o, i, a, n) => t ? r + i : r >= o - 1 || n === "left" && r >= o - a ? r : e === "remainder" && n === "left" ? Math.min(r + i, o - a) : Math.min(r + i, o - 1), Le = (e, t, r, o, i, a) => t ? r - o : r <= 0 || a === "right" && r <= i - 1 ? r : e === "remainder" && a === "right" ? Math.max(r - o, i - 1) : Math.max(r - o, 0), Bt = (e, t, r, o, i, a, n) => {
+  if (e !== void 0)
+    return e;
+  const c = ge(
+    t,
+    o,
+    n,
+    r,
+    !1,
+    i
+  );
+  return a ? c[c.length - 1] : c[0];
+}, Fe = (e, t) => (e % t + t) % t, Ve = (e) => ({
+  border: 0,
+  background: "rgba(0,0,0,0.4)",
+  color: "white",
+  padding: 10,
+  textTransform: "uppercase",
+  opacity: e ? 0.3 : 1,
+  cursor: e ? "not-allowed" : "pointer"
+}), Ot = ({
+  cellAlign: e,
+  currentSlide: t,
+  slidesToShow: r,
+  wrapAround: o
+}) => o ? !1 : t === 0 || e === "right" && t <= r - 1, Pt = ({
+  previousSlide: e,
+  defaultControlsConfig: {
+    prevButtonClassName: t,
+    prevButtonStyle: r = {},
+    prevButtonText: o,
+    prevButtonOnClick: i
+  },
+  onUserNavigation: a,
+  previousDisabled: n
+}) => {
+  const c = (l) => {
+    i == null || i(l), !l.defaultPrevented && (a(l), l.preventDefault(), e());
+  };
+  return /* @__PURE__ */ v.jsx(
+    "button",
+    {
+      className: t,
+      style: N(N({}, Ve(n)), r),
+      disabled: n,
+      onClick: c,
+      "aria-label": "previous",
+      type: "button",
+      children: o || "Prev"
+    }
+  );
+}, At = ({
+  cellAlign: e,
+  currentSlide: t,
+  slideCount: r,
+  slidesToShow: o,
+  wrapAround: i
+}) => i ? !1 : t >= r - 1 || e === "left" && t >= r - o, Et = ({
+  nextSlide: e,
+  defaultControlsConfig: {
+    nextButtonClassName: t,
+    nextButtonStyle: r = {},
+    nextButtonText: o,
+    nextButtonOnClick: i
+  },
+  nextDisabled: a,
+  onUserNavigation: n
+}) => {
+  const c = (l) => {
+    i == null || i(l), !l.defaultPrevented && (n(l), l.preventDefault(), e());
+  };
+  return /* @__PURE__ */ v.jsx(
+    "button",
+    {
+      className: t,
+      style: N(N({}, Ve(a)), r),
+      disabled: a,
+      onClick: c,
+      "aria-label": "next",
+      type: "button",
+      children: o || "Next"
+    }
+  );
+}, ge = (e, t, r, o, i, a) => {
+  const n = [], c = t <= 0 ? 1 : t;
+  if (i) {
+    for (let l = 0; l < e; l += c)
+      n.push(l);
+    return n;
+  }
+  if (a === "center") {
+    for (let l = 0; l < e - 1; l += c)
+      n.push(l);
+    return e > 0 && n.push(e - 1), n;
+  }
+  if (a === "left") {
+    if (o >= e)
+      return [0];
+    const l = e - o;
+    for (let u = 0; u < l; u += c)
+      n.push(u);
+    return r === "remainder" ? n.push(l) : n.push(n[n.length - 1] + c), n;
+  }
+  if (a === "right") {
+    if (o >= e)
+      return [e - 1];
+    const l = o - 1;
+    if (r === "remainder") {
+      for (let u = l; u < e - 1; u += c)
+        n.push(u);
+      n.push(e - 1);
+    } else {
+      for (let u = e - 1; u > l; u -= c)
+        n.push(u);
+      n.push(n[n.length - 1] - c), n.reverse();
+    }
+    return n;
+  }
+  return n;
+}, $t = ({
+  pagingDotsIndices: e,
+  defaultControlsConfig: {
+    pagingDotsContainerClassName: t,
+    pagingDotsClassName: r,
+    pagingDotsStyle: o = {},
+    pagingDotsOnClick: i
+  },
+  currentSlide: a,
+  onUserNavigation: n,
+  slideCount: c,
+  goToSlide: l
+}) => {
+  const u = {
+    position: "relative",
+    top: -10,
+    display: "flex",
+    margin: 0,
+    padding: 0,
+    listStyleType: "none"
+  }, d = D(
+    (g) => ({
+      cursor: "pointer",
+      opacity: g ? 1 : 0.5,
+      background: "transparent",
+      border: "none",
+      fill: "black"
+    }),
+    []
+  ), f = Fe(a, c);
+  return /* @__PURE__ */ v.jsx("ul", { className: t, style: u, children: e.map((g, y) => {
+    const C = f === g || // sets navigation dots active if the current slide falls in the current index range
+    f < g && (y === 0 || f > e[y - 1]);
+    return /* @__PURE__ */ v.jsx(
+      "li",
+      {
+        className: C ? "paging-item active" : "paging-item",
+        children: /* @__PURE__ */ v.jsx(
+          "button",
+          {
+            className: r,
+            type: "button",
+            style: N(N({}, d(C)), o),
+            onClick: (B) => {
+              i == null || i(B), !B.defaultPrevented && (n(B), l(g));
+            },
+            "aria-label": `slide ${g + 1} bullet`,
+            "aria-selected": C,
+            children: /* @__PURE__ */ v.jsx(
+              "svg",
+              {
+                className: "paging-dot",
+                width: "6",
+                height: "6",
+                "aria-hidden": "true",
+                focusable: "false",
+                viewBox: "0 0 6 6",
+                children: /* @__PURE__ */ v.jsx("circle", { cx: "3", cy: "3", r: "3" })
+              }
+            )
+          }
+        )
+      },
+      g
+    );
+  }) });
+}, Lt = (e, t, r, o) => {
+  const [i, a] = _(1), n = b(Date.now()), c = b(), l = b(!0), u = b(null), d = u.current === null || u.current === r || o ? i : 0;
+  return E(() => {
+    if (u.current = r, l.current) {
+      l.current = !1;
+      return;
+    }
+    if (o)
+      return;
+    n.current = Date.now(), a(0);
+    const f = () => {
+      c.current = requestAnimationFrame(() => {
+        const g = Date.now(), y = Math.min(
+          1,
+          (g - n.current) / e
+        );
+        a(y), y < 1 ? f() : c.current = void 0;
+      });
+    };
+    return f(), () => {
+      c.current !== void 0 && (cancelAnimationFrame(c.current), a(1));
+    };
+  }, [r, e, o]), {
+    isAnimating: d !== 1,
+    value: t(d)
+  };
+}, De = (e, t, r, o, i) => {
+  const a = i ? 3 * t : t, n = 100 / a;
+  let c = i ? -100 / 3 : 0;
+  if (o === "right" && r > 1) {
+    const u = r - 1;
+    c += n * u;
+  }
+  if (o === "center" && r > 1) {
+    const d = (r - 1) / 2;
+    c += n * d;
+  }
+  const l = 100 / a * e;
+  return c - l;
+}, We = Me.forwardRef(
+  ({
+    animation: e,
+    animationDistance: t,
+    cellAlign: r,
+    children: o,
+    currentSlide: i,
+    disableAnimation: a,
+    disableEdgeSwiping: n,
+    draggedOffset: c,
+    easing: l,
+    edgeEasing: u,
+    isDragging: d,
+    scrollMode: f,
+    slideCount: g,
+    slidesToScroll: y,
+    slidesToShow: C,
+    speed: B,
+    wrapAround: $,
+    slideWidth: G,
+    setIsAnimating: H
+  }, J) => {
+    const L = $ ? 3 * g : g, F = G ? `calc(${G} * ${L})` : `${L * 100 / C}%`, V = [
+      g,
+      C,
+      r,
+      $
+    ], S = ge(
+      g,
+      y,
+      f,
+      C,
+      $,
+      r
+    );
+    let W = `${c}px`;
+    if (d && n && !$) {
+      const Y = [
+        S[0],
+        S[S.length - 1]
+      ].map(
+        (Z) => De(Z, ...V)
+      );
+      W = `clamp(${Y[1]}%, ${c}px, ${Y[0]}%)`;
+    }
+    const k = De(
+      i,
+      ...V
+    ), Q = !n && !$ && (i === S[0] && t < 0 || i === S[S.length - 1] && t > 0), { value: re, isAnimating: M } = Lt(
+      B,
+      Q ? u : l,
+      // animationDistance is assumed to be unique enough that it can be used to
+      // detect when a new animation should start. This is used in addition to
+      // currentSlide because some animations, such as those with edgeEasing, do
+      // not occur due to a change in value of currentSlide
+      i + t,
+      d || a || e === "fade"
+    );
+    let K;
+    if (d || k !== 0 || M)
+      if (d)
+        K = `translateX(${W})`;
+      else {
+        const Y = M ? (1 - re) * t : 0;
+        K = `translateX(calc(${k}% - ${Y}px))`;
+      }
+    return E(() => {
+      H(M);
+    }, [M, H]), /* @__PURE__ */ v.jsx(
+      "div",
+      {
+        ref: J,
+        className: "slider-list",
+        style: {
+          width: F,
+          textAlign: "left",
+          userSelect: "auto",
+          transform: K,
+          display: "flex"
+        },
+        children: o
+      }
+    );
+  }
+);
+We.displayName = "SliderList";
+var Ht = {
+  position: "absolute",
+  display: "flex",
+  zIndex: 1,
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0
+}, Ft = (e) => {
+  let t;
+  switch (e) {
+    case "TopLeft":
+    case "TopCenter":
+    case "TopRight":
+      t = "flex-start";
+      break;
+    case "CenterLeft":
+    case "CenterCenter":
+    case "CenterRight":
+      t = "center";
+      break;
+    case "BottomLeft":
+    case "BottomCenter":
+    case "BottomRight":
+      t = "flex-end";
+      break;
+  }
+  let r;
+  switch (e) {
+    case "TopLeft":
+    case "CenterLeft":
+    case "BottomLeft":
+      r = "flex-start";
+      break;
+    case "TopCenter":
+    case "CenterCenter":
+    case "BottomCenter":
+      r = "center";
+      break;
+    case "TopRight":
+    case "CenterRight":
+    case "BottomRight":
+      r = "flex-end";
+      break;
+  }
+  return { alignItems: t, justifyContent: r };
+}, Vt = (e) => N(N({}, Ft(e)), Ht), Wt = [
+  {
+    funcName: "renderTopLeftControls",
+    key: "TopLeft"
+    /* TopLeft */
+  },
+  {
+    funcName: "renderTopCenterControls",
+    key: "TopCenter"
+    /* TopCenter */
+  },
+  {
+    funcName: "renderTopRightControls",
+    key: "TopRight"
+    /* TopRight */
+  },
+  {
+    funcName: "renderCenterLeftControls",
+    key: "CenterLeft"
+    /* CenterLeft */
+  },
+  {
+    funcName: "renderCenterCenterControls",
+    key: "CenterCenter"
+    /* CenterCenter */
+  },
+  {
+    funcName: "renderCenterRightControls",
+    key: "CenterRight"
+    /* CenterRight */
+  },
+  {
+    funcName: "renderBottomLeftControls",
+    key: "BottomLeft"
+    /* BottomLeft */
+  },
+  {
+    funcName: "renderBottomCenterControls",
+    key: "BottomCenter"
+    /* BottomCenter */
+  },
+  {
+    funcName: "renderBottomRightControls",
+    key: "BottomRight"
+    /* BottomRight */
+  }
+], zt = (e, t, r, o, i, a, n) => {
+  if (e.withoutControls)
+    return null;
+  const c = Re(N({}, e), {
+    currentSlide: r,
+    slideCount: t
+  }), l = At(c), u = Ot(c), d = ge(
+    t,
+    n,
+    e.scrollMode,
+    e.slidesToShow,
+    e.wrapAround,
+    e.cellAlign
+  );
+  return Wt.map((f) => {
+    var g;
+    return !e[f.funcName] || typeof e[f.funcName] != "function" ? /* @__PURE__ */ v.jsx(pt, {}, f.funcName) : /* @__PURE__ */ v.jsx(
+      "div",
+      {
+        style: Re(N({}, Vt(f.key)), {
+          pointerEvents: "none"
+        }),
+        children: /* @__PURE__ */ v.jsx(
+          "div",
+          {
+            className: [
+              `slider-control-${f.key.toLowerCase()}`,
+              e.defaultControlsConfig.containerClassName || ""
+            ].join(" ").trim(),
+            style: { pointerEvents: "auto" },
+            children: (g = e[f.funcName]) == null ? void 0 : g.call(e, {
+              cellAlign: e.cellAlign,
+              cellSpacing: e.cellSpacing,
+              currentSlide: r,
+              defaultControlsConfig: e.defaultControlsConfig || {},
+              pagingDotsIndices: d,
+              goToSlide: o,
+              nextDisabled: l,
+              nextSlide: i,
+              onUserNavigation: e.onUserNavigation,
+              previousDisabled: u,
+              previousSlide: a,
+              scrollMode: e.scrollMode,
+              slideCount: t,
+              slidesToScroll: n,
+              slidesToShow: e.slidesToShow || 1,
+              vertical: e.vertical,
+              wrapAround: e.wrapAround
+            })
+          }
+        )
+      },
+      f.funcName
+    );
+  });
+}, Xt = zt, He = (e) => St(e - 1, 3) + 1, Kt = {
+  adaptiveHeight: !1,
+  adaptiveHeightAnimation: !0,
+  afterSlide: () => {
+  },
+  autoplay: !1,
+  autoplayInterval: 3e3,
+  autoplayReverse: !1,
+  beforeSlide: () => {
+  },
+  cellAlign: "left",
+  cellSpacing: 0,
+  defaultControlsConfig: {},
+  disableAnimation: !1,
+  disableEdgeSwiping: !1,
+  dragging: !0,
+  dragThreshold: 0.5,
+  easing: He,
+  edgeEasing: He,
+  enableKeyboardControls: !1,
+  frameAriaLabel: "carousel-slider",
+  keyCodeConfig: {
+    nextSlide: [39, 68, 38, 87],
+    previousSlide: [37, 65, 40, 83],
+    firstSlide: [81],
+    lastSlide: [69],
+    pause: [32]
+  },
+  onDragStart: () => {
+  },
+  onDrag: () => {
+  },
+  onDragEnd: () => {
+  },
+  onUserNavigation: () => {
+  },
+  pauseOnHover: !0,
+  renderAnnounceSlideMessage: It,
+  renderBottomCenterControls: (e) => /* @__PURE__ */ v.jsx($t, N({}, e)),
+  renderCenterLeftControls: (e) => /* @__PURE__ */ v.jsx(Pt, N({}, e)),
+  renderCenterRightControls: (e) => /* @__PURE__ */ v.jsx(Et, N({}, e)),
+  scrollMode: "page",
+  slidesToScroll: 1,
+  slidesToShow: 1,
+  speed: 500,
+  style: {},
+  swiping: !0,
+  vertical: !1,
+  withoutControls: !1,
+  wrapAround: !1,
+  children: /* @__PURE__ */ v.jsx(v.Fragment, {})
+}, qt = Kt, Ut = (e) => {
+  const [t, r] = _(e), o = b(e), i = D((a) => {
+    o.current = a, r(a);
+  }, []);
+  return [t, i, o];
+}, Gt = (e, t, r) => {
+  const [o, i, a] = Ut([]), [n, c] = _(!1), l = D(
+    (d, f) => {
+      const g = a.current;
+      let y;
+      f === null ? y = g.filter(
+        (C) => C.slideIndex !== d
+      ) : y = [...g, { slideIndex: d, height: f }], i(y), y.length >= Math.min(r, Math.ceil(t)) && c(!0);
+    },
+    [r, i, t, a]
+  ), u = vt(() => e && n ? `${Math.max(
+    0,
+    ...o.map((f) => f.height)
+  )}px` : "auto", [e, n, o]);
+  return {
+    handleVisibleSlideHeightChange: l,
+    frameHeight: u,
+    initializedAdaptiveHeight: n
+  };
+}, Jt = (e) => {
+  const t = b(null);
+  return E(() => {
+    e && (typeof e == "function" ? e(t.current) : e.current = t.current);
+  }, [e]), t;
+}, ze = Me.forwardRef(
+  (e, t) => {
+    const r = e, {
+      adaptiveHeight: o,
+      adaptiveHeightAnimation: i,
+      afterSlide: a,
+      animation: n,
+      autoplay: c,
+      autoplayInterval: l,
+      autoplayReverse: u,
+      beforeSlide: d,
+      cellAlign: f,
+      cellSpacing: g,
+      children: y,
+      className: C,
+      disableAnimation: B,
+      dragging: $,
+      dragThreshold: G,
+      enableKeyboardControls: H,
+      frameAriaLabel: J,
+      keyCodeConfig: L,
+      onDrag: F,
+      onDragEnd: V,
+      onDragStart: S,
+      onUserNavigation: W,
+      pauseOnHover: k,
+      renderAnnounceSlideMessage: Q,
+      scrollMode: re,
+      slideIndex: M,
+      slidesToScroll: K,
+      slidesToShow: Y,
+      slideWidth: Z,
+      speed: le,
+      style: Xe,
+      swiping: Ne,
+      wrapAround: j,
+      zoomScale: Ke
+    } = r, je = Me.Children.toArray(y).filter(Boolean), T = je.length, O = Z || K === "auto" ? "left" : f, z = K === "auto" ? "remainder" : re, [he, qe] = _(
+      /* @__PURE__ */ new Map()
+    ), ve = Array.from(he).filter(
+      ([, s]) => s
+    ).length, [Te, Ue] = _(ve), R = Z ? Te : Y, I = n === "fade" ? R : K === "auto" ? Math.max(Te, 1) : K, [w, Ge] = _(
+      () => Bt(
+        M,
+        T,
+        R,
+        I,
+        O,
+        u,
+        z
+      )
+    ), [ee, pe] = _(!1), [P, me] = _(!1), [ne, ke] = _(0), [Je, Qe] = _(0), [Ie, Ye] = _(!1), Ze = D(
+      (s, h) => {
+        !!he.get(s) !== h && qe((p) => {
+          const x = new Map(p);
+          return x.set(s, h), x;
+        });
+      },
+      [he]
+    ), be = b(!1);
+    E(() => {
+      P && (be.current = !0), P || Ie || (be.current || Ue(ve), be.current = !1);
+    }, [Ie, P, ve]);
+    const se = b(null), ye = b(0), q = b(null), et = b(null), Ce = b(), oe = b(null), xe = b(!0), tt = D((s) => {
+      s && s.querySelectorAll(".slider-list img").forEach((h) => h.setAttribute("draggable", "false")), q.current = s;
+    }, []);
+    E(() => (xe.current = !0, () => {
+      xe.current = !1;
+    }), []);
+    const m = Jt(t) || et, A = D(
+      (s) => {
+        if (!q.current || !m.current)
+          return;
+        const h = Fe(
+          s,
+          T
+        ), p = s !== w;
+        p && d(w, h);
+        const x = q.current.getBoundingClientRect().left - m.current.getBoundingClientRect().left, U = q.current.offsetWidth;
+        let de = De(
+          h,
+          T,
+          R,
+          O,
+          j
+        ) / 100 * U;
+        if (j) {
+          const ie = U / 3;
+          s < 0 && (de += ie), s >= T && (de -= ie);
+        }
+        Qe(de - x), p && (Ge(h), setTimeout(() => {
+          xe.current && a(h);
+        }, B ? 40 : le || 500));
+      },
+      [
+        a,
+        d,
+        m,
+        O,
+        w,
+        B,
+        le,
+        T,
+        R,
+        j
+      ]
+    ), ce = D(() => {
+      const s = $e(
+        z,
+        j,
+        w,
+        T,
+        I,
+        R,
+        O
+      );
+      w !== s && A(s);
+    }, [
+      O,
+      w,
+      A,
+      I,
+      z,
+      T,
+      R,
+      j
+    ]), ue = D(() => {
+      const s = Le(
+        z,
+        j,
+        w,
+        I,
+        R,
+        O
+      );
+      w !== s && A(s);
+    }, [
+      O,
+      w,
+      A,
+      I,
+      z,
+      R,
+      j
+    ]), _e = b(M);
+    E(() => {
+      M !== void 0 && M !== _e.current && !u && (A(M), _e.current = M);
+    }, [M, u, A]), E(() => {
+      let s = null;
+      return ee && (s = Date.now()), () => {
+        s !== null && oe.current !== null && (oe.current += Date.now() - s);
+      };
+    }, [ee]), E(() => {
+      if (c && !ee) {
+        const s = oe.current !== null ? l - (Date.now() - oe.current) : l;
+        Ce.current = setTimeout(() => {
+          oe.current = Date.now(), u ? ue() : ce();
+        }, s);
+      }
+      return c && ee && clearTimeout(Ce.current), () => {
+        clearTimeout(Ce.current);
+      };
+    }, [
+      ee,
+      c,
+      l,
+      u,
+      ue,
+      ce
+    ]);
+    const rt = (s) => {
+      let h = null;
+      if (Object.keys(L).forEach(
+        (p) => {
+          var x;
+          (x = L[p]) != null && x.includes(s.keyCode) && (h = p);
+        }
+      ), h !== null)
+        switch (s.preventDefault(), s.stopPropagation(), h) {
+          case "nextSlide":
+            W(s), ce();
+            break;
+          case "previousSlide":
+            W(s), ue();
+            break;
+          case "firstSlide":
+          case "lastSlide": {
+            W(s);
+            const p = ge(
+              T,
+              I,
+              z,
+              R,
+              j,
+              O
+            );
+            A(h === "firstSlide" ? p[0] : p[p.length - 1]);
+            break;
+          }
+          case "pause":
+            pe((p) => !p);
+            break;
+        }
+    }, X = b([]), Be = (s) => {
+      if (!P || !m.current)
+        return;
+      me(!1);
+      let h = 0;
+      if (X.current.length > 1) {
+        const ae = X.current[0], Pe = X.current[X.current.length - 1], dt = Pe.time - ae.time, gt = 9, ht = 0.92;
+        let we = gt * Math.abs((Pe.pos - ae.pos) / dt);
+        for (; Math.abs(we) > 1; )
+          h += we, we *= ht;
+      }
+      X.current = [];
+      const p = Math.abs(ne) + Math.abs(h);
+      V(s), se.current = null, ke(0);
+      const x = m.current.offsetWidth * Math.min(1, I / R), U = x * G;
+      if (p < U) {
+        A(w);
+        return;
+      }
+      const ie = R >= 2 * I ? 1 + Math.floor((p - U) / x) : 1;
+      let te = w;
+      for (let ae = 0; ae < ie; ae += 1)
+        ne > 0 ? te = $e(
+          z,
+          j,
+          te,
+          T,
+          I,
+          R,
+          O
+        ) : te = Le(
+          z,
+          j,
+          te,
+          I,
+          R,
+          O
+        );
+      te !== w && W(s), A(te);
+    }, nt = D(
+      (s) => {
+        !Ne || !q.current || !m.current || (me(!0), ye.current = q.current.getBoundingClientRect().left - m.current.getBoundingClientRect().left, S(s));
+      },
+      [m, S, Ne]
+    ), fe = D(
+      (s) => {
+        if (!P)
+          return;
+        const h = se.current === null, p = se.current !== null ? s - se.current : 0, x = ne + p, U = Date.now();
+        for (; X.current.length > 0 && !(U - X.current[0].time <= 100); )
+          X.current.shift();
+        X.current.push({ pos: x, time: U }), h || ke(x), se.current = s;
+      },
+      [P, ne]
+    ), st = D(
+      (s) => {
+        if (!P || !m.current)
+          return;
+        S(s);
+        const h = m.current.offsetWidth - s.touches[0].pageX;
+        fe(h);
+      },
+      [P, m, fe, S]
+    ), ot = D(
+      (s) => {
+        !$ || !q.current || !m.current || (me(!0), ye.current = q.current.getBoundingClientRect().left - m.current.getBoundingClientRect().left, S(s));
+      },
+      [m, $, S]
+    ), it = D(
+      (s) => {
+        if (!P || !m.current)
+          return;
+        F(s);
+        const h = s.clientX - m.current.getBoundingClientRect().left, p = m.current.offsetWidth - h;
+        fe(p);
+      },
+      [m, P, fe, F]
+    ), Oe = (s) => {
+      s.preventDefault(), Be(s);
+    }, at = D(() => {
+      k && pe(!0);
+    }, [k]), lt = D(() => {
+      k && pe(!1);
+    }, [k]), {
+      frameHeight: ct,
+      handleVisibleSlideHeightChange: ut,
+      initializedAdaptiveHeight: ft
+    } = Gt(o, R, T), Se = (s) => je.map((p, x) => /* @__PURE__ */ v.jsx(
+      jt,
+      {
+        id: `${s}-${x}`,
+        count: T,
+        index: x,
+        isCurrentSlide: w === x,
+        typeOfSlide: s,
+        wrapAround: j,
+        cellSpacing: g,
+        animation: n,
+        speed: le,
+        zoomScale: Ke,
+        onVisibleSlideHeightChange: ut,
+        slideWidth: Z,
+        updateIOEntry: Ze,
+        adaptiveHeight: o,
+        initializedAdaptiveHeight: ft,
+        carouselRef: m,
+        children: p
+      },
+      `${s}-${x}`
+    ));
+    return /* @__PURE__ */ v.jsxs(
+      "div",
+      {
+        className: "slider-container",
+        style: {
+          position: "relative"
+        },
+        onMouseEnter: at,
+        onMouseLeave: lt,
+        children: [
+          /* @__PURE__ */ v.jsx(
+            _t,
+            {
+              ariaLive: c && !ee ? "off" : "polite",
+              message: Q({
+                currentSlide: w,
+                count: T
+              })
+            }
+          ),
+          Xt(
+            r,
+            T,
+            w,
+            A,
+            ce,
+            ue,
+            I
+          ),
+          /* @__PURE__ */ v.jsx(
+            "div",
+            {
+              className: ["slider-frame", C || ""].join(" ").trim(),
+              style: N({
+                overflow: "hidden",
+                width: "100%",
+                position: "relative",
+                outline: "none",
+                touchAction: "pan-y",
+                height: ct,
+                transition: i ? "height 300ms ease-in-out" : void 0,
+                willChange: "height",
+                userSelect: "none"
+              }, Xe),
+              "aria-label": J,
+              role: "region",
+              tabIndex: H ? 0 : -1,
+              onKeyDown: H ? rt : void 0,
+              ref: m,
+              onMouseUp: Oe,
+              onMouseDown: ot,
+              onMouseMove: it,
+              onMouseLeave: Oe,
+              onTouchStart: nt,
+              onTouchEnd: Be,
+              onTouchMove: st,
+              children: /* @__PURE__ */ v.jsxs(
+                We,
+                {
+                  animationDistance: Je,
+                  cellAlign: O,
+                  currentSlide: w,
+                  disableEdgeSwiping: r.disableEdgeSwiping,
+                  draggedOffset: ye.current - ne,
+                  disableAnimation: B,
+                  easing: r.easing,
+                  edgeEasing: r.edgeEasing,
+                  isDragging: P,
+                  ref: tt,
+                  scrollMode: z,
+                  animation: n,
+                  slideCount: T,
+                  slidesToScroll: I,
+                  slidesToShow: R,
+                  speed: le,
+                  slideWidth: Z,
+                  wrapAround: j,
+                  setIsAnimating: Ye,
+                  children: [
+                    j ? Se("prev-cloned") : null,
+                    Se(),
+                    j ? Se("next-cloned") : null
+                  ]
+                }
+              )
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+ze.defaultProps = qt;
+ze.displayName = "Carousel";
+export {
+  Et as NextButton,
+  $t as PagingDots,
+  Pt as PreviousButton,
+  ze as default
+};