react-spring-carousel 3.0.0-beta078 → 3.0.0-beta080

package/dist/index.es3.js

@@ -0,0 +1,1087 @@
+import { u as Se, j as N } from "./useThumbsModule-08e90459.js";
+import { useSpring as Xe, useIsomorphicLayoutEffect as Je, config as G } from "@react-spring/web";
+import { useRef as x, useEffect as z, createContext as Qe, useCallback as Ue, useContext as Ze } from "react";
+import { u as et, a as tt } from "./use-gesture-react.esm-9eb8841a.js";
+var Te = function() {
+  if (typeof Map < "u")
+    return Map;
+  function e(t, r) {
+    var i = -1;
+    return t.some(function(u, f) {
+      return u[0] === r ? (i = f, !0) : !1;
+    }), i;
+  }
+  return (
+    /** @class */
+    function() {
+      function t() {
+        this.__entries__ = [];
+      }
+      return Object.defineProperty(t.prototype, "size", {
+        /**
+         * @returns {boolean}
+         */
+        get: function() {
+          return this.__entries__.length;
+        },
+        enumerable: !0,
+        configurable: !0
+      }), t.prototype.get = function(r) {
+        var i = e(this.__entries__, r), u = this.__entries__[i];
+        return u && u[1];
+      }, t.prototype.set = function(r, i) {
+        var u = e(this.__entries__, r);
+        ~u ? this.__entries__[u][1] = i : this.__entries__.push([r, i]);
+      }, t.prototype.delete = function(r) {
+        var i = this.__entries__, u = e(i, r);
+        ~u && i.splice(u, 1);
+      }, t.prototype.has = function(r) {
+        return !!~e(this.__entries__, r);
+      }, t.prototype.clear = function() {
+        this.__entries__.splice(0);
+      }, t.prototype.forEach = function(r, i) {
+        i === void 0 && (i = null);
+        for (var u = 0, f = this.__entries__; u < f.length; u++) {
+          var a = f[u];
+          r.call(i, a[1], a[0]);
+        }
+      }, t;
+    }()
+  );
+}(), me = typeof window < "u" && typeof document < "u" && window.document === document, ee = function() {
+  return typeof global < "u" && global.Math === Math ? global : typeof self < "u" && self.Math === Math ? self : typeof window < "u" && window.Math === Math ? window : Function("return this")();
+}(), nt = function() {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(ee) : function(e) {
+    return setTimeout(function() {
+      return e(Date.now());
+    }, 1e3 / 60);
+  };
+}(), rt = 2;
+function it(e, t) {
+  var r = !1, i = !1, u = 0;
+  function f() {
+    r && (r = !1, e()), i && s();
+  }
+  function a() {
+    nt(f);
+  }
+  function s() {
+    var l = Date.now();
+    if (r) {
+      if (l - u < rt)
+        return;
+      i = !0;
+    } else
+      r = !0, i = !1, setTimeout(a, t);
+    u = l;
+  }
+  return s;
+}
+var ot = 20, ct = ["top", "right", "bottom", "left", "width", "height", "size", "weight"], st = typeof MutationObserver < "u", ut = (
+  /** @class */
+  function() {
+    function e() {
+      this.connected_ = !1, this.mutationEventsAdded_ = !1, this.mutationsObserver_ = null, this.observers_ = [], this.onTransitionEnd_ = this.onTransitionEnd_.bind(this), this.refresh = it(this.refresh.bind(this), ot);
+    }
+    return e.prototype.addObserver = function(t) {
+      ~this.observers_.indexOf(t) || this.observers_.push(t), this.connected_ || this.connect_();
+    }, e.prototype.removeObserver = function(t) {
+      var r = this.observers_, i = r.indexOf(t);
+      ~i && r.splice(i, 1), !r.length && this.connected_ && this.disconnect_();
+    }, e.prototype.refresh = function() {
+      var t = this.updateObservers_();
+      t && this.refresh();
+    }, e.prototype.updateObservers_ = function() {
+      var t = this.observers_.filter(function(r) {
+        return r.gatherActive(), r.hasActive();
+      });
+      return t.forEach(function(r) {
+        return r.broadcastActive();
+      }), t.length > 0;
+    }, e.prototype.connect_ = function() {
+      !me || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), st ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
+        attributes: !0,
+        childList: !0,
+        characterData: !0,
+        subtree: !0
+      })) : (document.addEventListener("DOMSubtreeModified", this.refresh), this.mutationEventsAdded_ = !0), this.connected_ = !0);
+    }, e.prototype.disconnect_ = function() {
+      !me || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
+    }, e.prototype.onTransitionEnd_ = function(t) {
+      var r = t.propertyName, i = r === void 0 ? "" : r, u = ct.some(function(f) {
+        return !!~i.indexOf(f);
+      });
+      u && this.refresh();
+    }, e.getInstance = function() {
+      return this.instance_ || (this.instance_ = new e()), this.instance_;
+    }, e.instance_ = null, e;
+  }()
+), Fe = function(e, t) {
+  for (var r = 0, i = Object.keys(t); r < i.length; r++) {
+    var u = i[r];
+    Object.defineProperty(e, u, {
+      value: t[u],
+      enumerable: !1,
+      writable: !1,
+      configurable: !0
+    });
+  }
+  return e;
+}, L = function(e) {
+  var t = e && e.ownerDocument && e.ownerDocument.defaultView;
+  return t || ee;
+}, Me = ne(0, 0, 0, 0);
+function te(e) {
+  return parseFloat(e) || 0;
+}
+function Ie(e) {
+  for (var t = [], r = 1; r < arguments.length; r++)
+    t[r - 1] = arguments[r];
+  return t.reduce(function(i, u) {
+    var f = e["border-" + u + "-width"];
+    return i + te(f);
+  }, 0);
+}
+function at(e) {
+  for (var t = ["top", "right", "bottom", "left"], r = {}, i = 0, u = t; i < u.length; i++) {
+    var f = u[i], a = e["padding-" + f];
+    r[f] = te(a);
+  }
+  return r;
+}
+function lt(e) {
+  var t = e.getBBox();
+  return ne(0, 0, t.width, t.height);
+}
+function ft(e) {
+  var t = e.clientWidth, r = e.clientHeight;
+  if (!t && !r)
+    return Me;
+  var i = L(e).getComputedStyle(e), u = at(i), f = u.left + u.right, a = u.top + u.bottom, s = te(i.width), l = te(i.height);
+  if (i.boxSizing === "border-box" && (Math.round(s + f) !== t && (s -= Ie(i, "left", "right") + f), Math.round(l + a) !== r && (l -= Ie(i, "top", "bottom") + a)), !ht(e)) {
+    var d = Math.round(s + f) - t, T = Math.round(l + a) - r;
+    Math.abs(d) !== 1 && (s -= d), Math.abs(T) !== 1 && (l -= T);
+  }
+  return ne(u.left, u.top, s, l);
+}
+var dt = function() {
+  return typeof SVGGraphicsElement < "u" ? function(e) {
+    return e instanceof L(e).SVGGraphicsElement;
+  } : function(e) {
+    return e instanceof L(e).SVGElement && typeof e.getBBox == "function";
+  };
+}();
+function ht(e) {
+  return e === L(e).document.documentElement;
+}
+function vt(e) {
+  return me ? dt(e) ? lt(e) : ft(e) : Me;
+}
+function pt(e) {
+  var t = e.x, r = e.y, i = e.width, u = e.height, f = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, a = Object.create(f.prototype);
+  return Fe(a, {
+    x: t,
+    y: r,
+    width: i,
+    height: u,
+    top: r,
+    right: t + i,
+    bottom: u + r,
+    left: t
+  }), a;
+}
+function ne(e, t, r, i) {
+  return { x: e, y: t, width: r, height: i };
+}
+var mt = (
+  /** @class */
+  function() {
+    function e(t) {
+      this.broadcastWidth = 0, this.broadcastHeight = 0, this.contentRect_ = ne(0, 0, 0, 0), this.target = t;
+    }
+    return e.prototype.isActive = function() {
+      var t = vt(this.target);
+      return this.contentRect_ = t, t.width !== this.broadcastWidth || t.height !== this.broadcastHeight;
+    }, e.prototype.broadcastRect = function() {
+      var t = this.contentRect_;
+      return this.broadcastWidth = t.width, this.broadcastHeight = t.height, t;
+    }, e;
+  }()
+), gt = (
+  /** @class */
+  function() {
+    function e(t, r) {
+      var i = pt(r);
+      Fe(this, { target: t, contentRect: i });
+    }
+    return e;
+  }()
+), bt = (
+  /** @class */
+  function() {
+    function e(t, r, i) {
+      if (this.activeObservations_ = [], this.observations_ = new Te(), typeof t != "function")
+        throw new TypeError("The callback provided as parameter 1 is not a function.");
+      this.callback_ = t, this.controller_ = r, this.callbackCtx_ = i;
+    }
+    return e.prototype.observe = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof L(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var r = this.observations_;
+        r.has(t) || (r.set(t, new mt(t)), this.controller_.addObserver(this), this.controller_.refresh());
+      }
+    }, e.prototype.unobserve = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof L(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var r = this.observations_;
+        r.has(t) && (r.delete(t), r.size || this.controller_.removeObserver(this));
+      }
+    }, e.prototype.disconnect = function() {
+      this.clearActive(), this.observations_.clear(), this.controller_.removeObserver(this);
+    }, e.prototype.gatherActive = function() {
+      var t = this;
+      this.clearActive(), this.observations_.forEach(function(r) {
+        r.isActive() && t.activeObservations_.push(r);
+      });
+    }, e.prototype.broadcastActive = function() {
+      if (this.hasActive()) {
+        var t = this.callbackCtx_, r = this.activeObservations_.map(function(i) {
+          return new gt(i.target, i.broadcastRect());
+        });
+        this.callback_.call(t, r, t), this.clearActive();
+      }
+    }, e.prototype.clearActive = function() {
+      this.activeObservations_.splice(0);
+    }, e.prototype.hasActive = function() {
+      return this.activeObservations_.length > 0;
+    }, e;
+  }()
+), Oe = typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : new Te(), Re = (
+  /** @class */
+  function() {
+    function e(t) {
+      if (!(this instanceof e))
+        throw new TypeError("Cannot call a class as a function.");
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      var r = ut.getInstance(), i = new bt(t, r, this);
+      Oe.set(this, i);
+    }
+    return e;
+  }()
+);
+[
+  "observe",
+  "unobserve",
+  "disconnect"
+].forEach(function(e) {
+  Re.prototype[e] = function() {
+    var t;
+    return (t = Oe.get(this))[e].apply(t, arguments);
+  };
+});
+var yt = function() {
+  return typeof ee.ResizeObserver < "u" ? ee.ResizeObserver : Re;
+}(), ge = {}, xt = {
+  get exports() {
+    return ge;
+  },
+  set exports(e) {
+    ge = e;
+  }
+};
+/*!
+* screenfull
+* v5.2.0 - 2021-11-03
+* (c) Sindre Sorhus; MIT License
+*/
+(function(e) {
+  (function() {
+    var t = typeof window < "u" && typeof window.document < "u" ? window.document : {}, r = e.exports, i = function() {
+      for (var a, s = [
+        [
+          "requestFullscreen",
+          "exitFullscreen",
+          "fullscreenElement",
+          "fullscreenEnabled",
+          "fullscreenchange",
+          "fullscreenerror"
+        ],
+        // New WebKit
+        [
+          "webkitRequestFullscreen",
+          "webkitExitFullscreen",
+          "webkitFullscreenElement",
+          "webkitFullscreenEnabled",
+          "webkitfullscreenchange",
+          "webkitfullscreenerror"
+        ],
+        // Old WebKit
+        [
+          "webkitRequestFullScreen",
+          "webkitCancelFullScreen",
+          "webkitCurrentFullScreenElement",
+          "webkitCancelFullScreen",
+          "webkitfullscreenchange",
+          "webkitfullscreenerror"
+        ],
+        [
+          "mozRequestFullScreen",
+          "mozCancelFullScreen",
+          "mozFullScreenElement",
+          "mozFullScreenEnabled",
+          "mozfullscreenchange",
+          "mozfullscreenerror"
+        ],
+        [
+          "msRequestFullscreen",
+          "msExitFullscreen",
+          "msFullscreenElement",
+          "msFullscreenEnabled",
+          "MSFullscreenChange",
+          "MSFullscreenError"
+        ]
+      ], l = 0, d = s.length, T = {}; l < d; l++)
+        if (a = s[l], a && a[1] in t) {
+          for (l = 0; l < a.length; l++)
+            T[s[0][l]] = a[l];
+          return T;
+        }
+      return !1;
+    }(), u = {
+      change: i.fullscreenchange,
+      error: i.fullscreenerror
+    }, f = {
+      request: function(a, s) {
+        return new Promise(function(l, d) {
+          var T = function() {
+            this.off("change", T), l();
+          }.bind(this);
+          this.on("change", T), a = a || t.documentElement;
+          var $ = a[i.requestFullscreen](s);
+          $ instanceof Promise && $.then(T).catch(d);
+        }.bind(this));
+      },
+      exit: function() {
+        return new Promise(function(a, s) {
+          if (!this.isFullscreen) {
+            a();
+            return;
+          }
+          var l = function() {
+            this.off("change", l), a();
+          }.bind(this);
+          this.on("change", l);
+          var d = t[i.exitFullscreen]();
+          d instanceof Promise && d.then(l).catch(s);
+        }.bind(this));
+      },
+      toggle: function(a, s) {
+        return this.isFullscreen ? this.exit() : this.request(a, s);
+      },
+      onchange: function(a) {
+        this.on("change", a);
+      },
+      onerror: function(a) {
+        this.on("error", a);
+      },
+      on: function(a, s) {
+        var l = u[a];
+        l && t.addEventListener(l, s, !1);
+      },
+      off: function(a, s) {
+        var l = u[a];
+        l && t.removeEventListener(l, s, !1);
+      },
+      raw: i
+    };
+    if (!i) {
+      r ? e.exports = { isEnabled: !1 } : window.screenfull = { isEnabled: !1 };
+      return;
+    }
+    Object.defineProperties(f, {
+      isFullscreen: {
+        get: function() {
+          return !!t[i.fullscreenElement];
+        }
+      },
+      element: {
+        enumerable: !0,
+        get: function() {
+          return t[i.fullscreenElement];
+        }
+      },
+      isEnabled: {
+        enumerable: !0,
+        get: function() {
+          return !!t[i.fullscreenEnabled];
+        }
+      }
+    }), r ? e.exports = f : window.screenfull = f;
+  })();
+})(xt);
+const P = ge;
+function wt({
+  mainCarouselWrapperRef: e,
+  onFullScreenChange: t,
+  handleResize: r
+}) {
+  const i = x(!1);
+  z(() => {
+    function l() {
+      document.fullscreenElement && (u(!0), t(!0), r && r()), document.fullscreenElement || (u(!1), t(!1), r && r());
+    }
+    if (P.isEnabled)
+      return P.on("change", l), () => {
+        P.isEnabled && P.off("change", l);
+      };
+  }, []);
+  function u(l) {
+    i.current = l;
+  }
+  function f() {
+    return i.current;
+  }
+  function a(l) {
+    P.isEnabled && P.request(l || e.current);
+  }
+  function s() {
+    P.isEnabled && P.exit();
+  }
+  return {
+    enterFullscreen: a,
+    exitFullscreen: s,
+    getIsFullscreen: f
+  };
+}
+function Rt({
+  items: e,
+  init: t = !0,
+  withThumbs: r,
+  thumbsSlideAxis: i = "x",
+  itemsPerSlide: u = 1,
+  slideType: f = "fixed",
+  gutter: a = 0,
+  withLoop: s = !1,
+  startEndGutter: l = 0,
+  carouselSlideAxis: d = "x",
+  disableGestures: T = !1,
+  draggingSlideTreshold: $,
+  slideWhenThresholdIsReached: ye = !1,
+  freeScroll: h,
+  enableFreeScrollDrag: Ce,
+  initialStartingPosition: re,
+  prepareThumbsData: ke,
+  initialActiveItem: O = 0,
+  animateWhenActiveItemChange: Pe = !0,
+  getControllerRef: ie
+}) {
+  const R = u > e.length ? e.length : u, K = x(!1), S = x($ ?? 0), C = x("initial"), oe = x("initial"), ce = x("initial"), _ = x(O), m = x(O === 0), p = x(f === "fixed" && O === e.length - 1), g = x(null), E = x(null), se = x(!0), ue = x(0), ae = x(0), b = x(0), ze = x(s), We = x(f), Ne = x(h), D = x(!1), X = Ue(() => s ? [
+    ...e.map((n) => ({
+      ...n,
+      id: `prev-repeated-item-${n.id}`
+    })),
+    ...e,
+    ...e.map((n) => ({
+      ...n,
+      id: `next-repeated-item-${n.id}`
+    }))
+  ] : [...e], [e, s])(), [W, I] = Xe(
+    () => ({
+      val: 0,
+      pause: !t,
+      onChange: ({ value: n }) => {
+        h && g.current ? (d === "x" ? g.current.scrollLeft = Math.abs(n.val) : g.current.scrollTop = Math.abs(n.val), Z()) : E.current && (d === "x" ? E.current.style.transform = `translate3d(${n.val}px, 0px,0px)` : E.current.style.transform = `translate3d(0px,${n.val}px,0px)`);
+      }
+    }),
+    [h]
+  ), { emitEvent: J, useListenToCustomEvent: Q } = et(), { thumbsFragment: $e, handleScroll: De } = Se({
+    withThumbs: !!r,
+    thumbsSlideAxis: i,
+    prepareThumbsData: ke,
+    items: e,
+    renderThumbFnProps: {
+      getIsActiveItem: pe,
+      getIsPrevItem: ve,
+      useListenToCustomEvent: Q,
+      getIsNextItem: he
+    }
+  }), { enterFullscreen: xe, exitFullscreen: we, getIsFullscreen: _e } = wt({
+    mainCarouselWrapperRef: g,
+    handleResize: () => U(),
+    onFullScreenChange: (n) => {
+      J({
+        eventName: "onFullscreenChange",
+        isFullscreen: n
+      });
+    }
+  });
+  function je(n) {
+    return f === "fixed" && !h ? {
+      marginRight: `${n ? 0 : a}px`,
+      flex: `1 0 calc(100% / ${R} - ${a * (R - 1) / R}px)`
+    } : {
+      marginRight: `${n ? 0 : a}px`
+    };
+  }
+  function y() {
+    var c;
+    const n = (c = g.current) == null ? void 0 : c.querySelector(".use-spring-carousel-item");
+    if (!n)
+      throw Error("No carousel items available!");
+    return n.getBoundingClientRect()[d === "x" ? "width" : "height"] + a;
+  }
+  function j({ from: n, to: c, nextActiveItem: o, immediate: v = !1, slideMode: M }) {
+    oe.current = M, typeof o == "number" && (h || (_.current = o), J({
+      eventName: "onSlideStartChange",
+      slideActionType: C.current,
+      slideMode: oe.current,
+      nextItem: {
+        startReached: m.current,
+        endReached: p.current,
+        index: h ? -1 : _.current,
+        id: h ? "" : e[_.current].id
+      }
+    })), b.current = c, I.start({
+      immediate: v,
+      from: {
+        val: n
+      },
+      to: {
+        val: c
+      },
+      config: {
+        ...G.default,
+        velocity: W.val.velocity
+      },
+      onRest(H) {
+        !v && H.finished && J({
+          eventName: "onSlideChange",
+          slideActionType: C.current,
+          slideMode: oe.current,
+          currentItem: {
+            startReached: m.current,
+            endReached: p.current,
+            index: h ? -1 : _.current,
+            id: h ? "" : e[_.current].id
+          }
+        });
+      }
+    }), r && !v && De(_.current);
+  }
+  function w() {
+    var n;
+    return s ? y() * e.length : Math.round(
+      Number(
+        (n = E.current) == null ? void 0 : n[d === "x" ? "scrollWidth" : "scrollHeight"]
+      ) - E.current.getBoundingClientRect()[d === "x" ? "width" : "height"] - l * 2
+    );
+  }
+  function qe() {
+    const n = `calc(100% - ${l * 2}px)`;
+    return {
+      width: d === "x" ? n : "100%",
+      height: d === "y" ? n : "100%"
+    };
+  }
+  function le() {
+    var c;
+    const n = (c = E.current) == null ? void 0 : c.querySelector(".use-spring-carousel-item");
+    if (!n)
+      throw Error("No carousel items available!");
+    return n.getBoundingClientRect()[d === "x" ? "width" : "height"] + a;
+  }
+  function fe(n) {
+    const c = d === "x" ? "left" : "top", o = E.current;
+    o && (s ? (o.style.top = "0px", o.style.left = "0px", o.style[c] = `-${n - l}px`, m.current = !1, p.current = !1) : (o.style.left = "0px", o.style.top = "0px"));
+  }
+  function U(n = !1) {
+    if (E.current && n && (E.current.style.transform = "translate3d(0px, 0px,0px)", E.current.style.left = "0", E.current.style.top = "0"), f === "fixed" && fe(
+      re === "center" ? le() * e.length - y() * Math.round((R - 1) / 2) : re === "end" ? le() * e.length - y() * Math.round(R - 1) : le() * e.length
+    ), f === "fluid") {
+      if (p.current && w() !== Math.abs(b.current) && !s) {
+        const c = -w();
+        b.current = c, I.start({
+          immediate: !0,
+          val: b.current
+        });
+        return;
+      }
+      if (Math.abs(b.current) > 0 && w() !== Math.abs(b.current) && !s && !h && ce.current === "backward") {
+        const c = ue.current - w(), o = b.current + c;
+        return I.start({
+          immediate: !0,
+          val: o
+        }), () => {
+          b.current = o;
+        };
+      }
+      return;
+    }
+    if (!h && f === "fixed") {
+      const c = -(y() * _.current);
+      if (Math.abs(c) > w() && !s) {
+        const o = -w();
+        p.current = !0, b.current = o, I.start({
+          immediate: !0,
+          val: b.current
+        });
+      } else
+        b.current = c, I.start({
+          immediate: !0,
+          val: c
+        });
+      setTimeout(() => {
+        K.current = !1;
+      }, 0);
+    }
+  }
+  function k() {
+    return h && g.current ? g.current[d === "x" ? "scrollLeft" : "scrollTop"] : W.val.get();
+  }
+  function Y(n, c) {
+    if (h && n === "next") {
+      const o = b.current + y();
+      return o > w() ? w() : o;
+    }
+    if (h && n === "prev") {
+      const o = b.current - y();
+      return o < 0 ? 0 : o;
+    }
+    return n === "next" ? typeof c == "number" ? -(c * y()) : b.current - y() : typeof c == "number" ? -(c * y()) : b.current + y();
+  }
+  function q({ type: n, index: c, immediate: o }) {
+    if (!t || D.current || m.current && !s)
+      return;
+    p.current && (ce.current = "backward"), C.current = "prev", p.current = !1;
+    const v = typeof c == "number" ? c : _.current - 1;
+    if (h && Z(), !s) {
+      const M = h ? Y("prev", c) - y() / 3 < 0 : Y("prev", c) + y() / 3 > 0;
+      if (m.current)
+        return;
+      if (M) {
+        m.current = !0, p.current = !1, j({
+          slideMode: n,
+          from: k(),
+          to: 0,
+          nextActiveItem: 0,
+          immediate: o
+        });
+        return;
+      }
+    }
+    if (s && (m.current || v < 0)) {
+      m.current = !1, p.current = !0, j({
+        slideMode: n,
+        from: k() - y() * e.length,
+        to: -(y() * e.length) + y(),
+        nextActiveItem: e.length - 1,
+        immediate: o
+      });
+      return;
+    }
+    v === 0 && (m.current = !0), (v === e.length - 1 || v === -1) && (p.current = !0), j({
+      slideMode: n,
+      from: k(),
+      to: Y("prev", c),
+      nextActiveItem: v,
+      immediate: o
+    });
+  }
+  function V({ type: n, index: c, immediate: o }) {
+    if (!t || D.current || p.current && !s)
+      return;
+    m.current && (ce.current = "forward"), C.current = "next", m.current = !1;
+    const v = c || _.current + 1;
+    if (h && Z(), !s) {
+      const M = Math.abs(Y("next", c)) > w() - y() / 3;
+      if (p.current)
+        return;
+      if (M) {
+        m.current = !1, p.current = !0, j({
+          slideMode: n,
+          from: k(),
+          to: h ? w() : -w(),
+          nextActiveItem: v,
+          immediate: o
+        });
+        return;
+      }
+    }
+    if (s && (p.current || v > e.length - 1)) {
+      p.current = !1, m.current = !0, j({
+        slideMode: n,
+        from: k() + y() * e.length,
+        to: 0,
+        nextActiveItem: 0,
+        immediate: o
+      });
+      return;
+    }
+    v === 0 && (m.current = !0), v === e.length - 1 && (p.current = !0), j({
+      slideMode: n,
+      from: k(),
+      to: Y("next", c),
+      nextActiveItem: v,
+      immediate: o
+    });
+  }
+  function Ve() {
+    $ ? S.current = $ : S.current = Math.floor(y() / 2 / 2);
+  }
+  function Ee() {
+    !se.current && E.current && (ue.current = w(), ze.current = s, We.current = f, Ne.current = h, ae.current = window.innerWidth, b.current = 0, de({ id: 0, immediate: !0, shouldReset: !0 }), Ve(), U());
+  }
+  const Be = tt(
+    (n) => {
+      const c = n.dragging, o = n.offset[d === "x" ? 0 : 1], v = n.movement[d === "x" ? 0 : 1], M = n.direction[d === "x" ? 0 : 1], H = v > S.current, A = v < -S.current, Ke = w();
+      if (c) {
+        if (M > 0 ? C.current = "prev" : C.current = "next", J({
+          ...n,
+          eventName: "onDrag",
+          slideActionType: C.current
+        }), h) {
+          if (o > 0) {
+            I.start({
+              from: {
+                val: k()
+              },
+              to: {
+                val: 0
+              },
+              config: {
+                velocity: n.velocity,
+                friction: 50,
+                tension: 1e3
+              }
+            }), n.cancel();
+            return;
+          }
+          I.start({
+            from: {
+              val: k()
+            },
+            to: {
+              val: -o
+            },
+            config: {
+              velocity: n.velocity,
+              friction: 50,
+              tension: 1e3
+            }
+          });
+          return;
+        }
+        I.start({
+          val: o,
+          config: {
+            velocity: n.velocity,
+            friction: 50,
+            tension: 1e3
+          }
+        }), ye && A ? (V({ type: "drag" }), n.cancel()) : ye && H && (q({ type: "drag" }), n.cancel()), Ke - Math.abs(o) < -(y() * 2) && n.cancel();
+        return;
+      }
+      if (n.last && h && o > 0) {
+        I.start({
+          from: {
+            val: k()
+          },
+          to: {
+            val: 0
+          },
+          config: {
+            velocity: n.velocity,
+            friction: 50,
+            tension: 1e3
+          }
+        });
+        return;
+      }
+      n.last && !n.canceled && h && (C.current === "prev" && q({ type: "drag" }), C.current === "next" && V({ type: "drag" })), n.last && !n.canceled && !h && (A ? !s && p.current ? I.start({
+        val: -w(),
+        config: {
+          ...G.default,
+          velocity: n.velocity
+        }
+      }) : V({ type: "drag" }) : H ? !s && m.current ? I.start({
+        val: 0,
+        config: {
+          ...G.default,
+          velocity: n.velocity
+        }
+      }) : q({ type: "drag" }) : I.start({
+        val: b.current,
+        config: {
+          ...G.default,
+          velocity: n.velocity
+        }
+      })), n.last && n.canceled && I.start({
+        val: b.current,
+        config: {
+          ...G.default,
+          velocity: n.velocity
+        }
+      });
+    },
+    {
+      enabled: t && !T && !h || !!h && !!Ce,
+      axis: d,
+      from: () => h && g.current ? [
+        -g.current.scrollLeft,
+        -g.current.scrollTop
+      ] : d === "x" ? [W.val.get(), W.val.get()] : [W.val.get(), W.val.get()]
+    }
+  );
+  function He() {
+    return h ? d === "x" ? {
+      overflowX: "auto"
+    } : {
+      overflowY: "auto"
+    } : {};
+  }
+  function Z() {
+    g.current && (b.current = g.current[d === "x" ? "scrollLeft" : "scrollTop"], g.current[d === "x" ? "scrollLeft" : "scrollTop"] === 0 && (m.current = !0, p.current = !1), g.current[d === "x" ? "scrollLeft" : "scrollTop"] > 0 && g.current[d === "x" ? "scrollLeft" : "scrollTop"] < w() && (m.current = !1, p.current = !1), g.current[d === "x" ? "scrollLeft" : "scrollTop"] === w() && (m.current = !1, p.current = !0));
+  }
+  function Ae() {
+    return h ? {
+      onWheel() {
+        W.val.stop(), Z();
+      }
+    } : {};
+  }
+  function B(n, c) {
+    let o = 0;
+    if (typeof n == "string" ? o = e.findIndex((v) => v.id === n) : o = n, o < 0 || o >= e.length) {
+      if (c)
+        throw new Error(c);
+      console.error(`The item doesn't exist; check that the id provided - ${n} - is correct.`), o = -1;
+    }
+    return o;
+  }
+  function de({ id: n, immediate: c, shouldReset: o, type: v }) {
+    if (!t || D.current)
+      return;
+    m.current = !1, p.current = !1;
+    const M = B(
+      n,
+      "The item you want to slide to doesn't exist; check the provided id."
+    );
+    if (M === _.current && !o)
+      return;
+    const H = B(e[_.current].id), A = B(e[M].id);
+    A > H ? V({
+      type: v || o ? "initial" : "click",
+      index: A,
+      immediate: c
+    }) : q({
+      type: v || o ? "initial" : "click",
+      index: A,
+      immediate: c
+    });
+  }
+  function he(n) {
+    const c = B(n, "The item doesn't exist; check the provided id."), o = _.current;
+    return s && o === e.length - 1 ? c === 0 : c === o + 1;
+  }
+  function ve(n) {
+    const c = B(n, "The item doesn't exist; check the provided id."), o = _.current;
+    return s && o === 0 ? c === e.length - 1 : c === o - 1;
+  }
+  function pe(n) {
+    return B(n, "The item you want to check doesn't exist; check the provided id.") === _.current;
+  }
+  function Le() {
+    return T ? "unset" : d === "x" ? "pan-y" : "pan-x";
+  }
+  const F = h ? {
+    useListenToCustomEvent: Q,
+    enterFullscreen: xe,
+    exitFullscreen: we,
+    getIsFullscreen: _e,
+    slideToPrevItem: (n = !0) => {
+      q({
+        type: "click",
+        immediate: !n
+      });
+    },
+    slideToNextItem: (n = !0) => {
+      V({
+        type: "click",
+        immediate: !n
+      });
+    }
+  } : {
+    useListenToCustomEvent: Q,
+    enterFullscreen: xe,
+    exitFullscreen: we,
+    getIsFullscreen: _e,
+    slideToPrevItem: (n = !0) => {
+      q({
+        type: "click",
+        immediate: !n
+      });
+    },
+    slideToNextItem: (n = !0) => {
+      V({
+        type: "click",
+        immediate: !n
+      });
+    },
+    slideToItem: (n, c = !0) => {
+      de({ id: n, immediate: !c });
+    },
+    getIsNextItem: he,
+    getIsPrevItem: ve,
+    getIsActiveItem: pe
+  };
+  Je(() => {
+    E.current && t && (K.current = !0, Ee());
+  }, [t]), z(() => {
+    _.current !== O && de({
+      id: O,
+      immediate: !Pe
+    });
+  }, [O]), z(() => {
+    if (t) {
+      if (O > e.length - 1)
+        throw new Error(
+          `initialActiveItem (${O}) is greater than the total quantity available items (${e.length}).`
+        );
+      R > e.length && console.warn(
+        `itemsPerSlide (${R}) is greater than the total quantity available items (${e.length}). Fallback to ${e.length})`
+      );
+    }
+  }, [O, e.length, R, t]), z(() => {
+    ae.current = window.innerWidth;
+  }, []), z(() => {
+    t && (K.current = !0, Ee());
+  }, [re, R, l, a, t, s]), z(() => {
+    if (!t)
+      return;
+    function n() {
+      document.hidden ? D.current = !0 : D.current = !1;
+    }
+    return document.addEventListener("visibilitychange", n), () => {
+      document.removeEventListener("visibilitychange", n);
+    };
+  }, [t]), z(() => {
+    if (g.current) {
+      let n;
+      const c = new yt(() => {
+        if (se.current) {
+          se.current = !1;
+          return;
+        }
+        if (!D.current && !K.current) {
+          ae.current = window.innerWidth;
+          const o = U();
+          window.clearTimeout(n), n = setTimeout(() => {
+            ue.current = w(), typeof o == "function" && o();
+          }, 100);
+        }
+      });
+      return c.observe(g.current), () => {
+        c.disconnect();
+      };
+    }
+  }, [U, w]), z(() => {
+    ie && ie({
+      slideToNextItem: F.slideToNextItem,
+      slideToPrevItem: F.slideToPrevItem,
+      slideToItem: F == null ? void 0 : F.slideToItem
+    });
+  }, [ie, F.slideToItem, F.slideToNextItem, F.slideToPrevItem]);
+  const Ye = /* @__PURE__ */ N.jsx(be.Provider, { value: F, children: $e }), Ge = /* @__PURE__ */ N.jsx(be.Provider, { value: F, children: /* @__PURE__ */ N.jsx(
+    "div",
+    {
+      className: "use-spring-carousel-main-wrapper",
+      ref: g,
+      ...Ae(),
+      style: {
+        display: "flex",
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        ...He()
+      },
+      children: /* @__PURE__ */ N.jsxs(
+        "div",
+        {
+          className: "use-spring-carousel-track-wrapper",
+          ref: E,
+          ...Be(),
+          style: {
+            position: "relative",
+            display: "flex",
+            flexDirection: d === "x" ? "row" : "column",
+            touchAction: Le(),
+            ...qe()
+          },
+          children: [
+            (h || !s) && l ? /* @__PURE__ */ N.jsx(
+              "div",
+              {
+                style: {
+                  flexShrink: 0,
+                  width: l
+                }
+              }
+            ) : null,
+            X.map((n, c) => /* @__PURE__ */ N.jsx(
+              "div",
+              {
+                className: "use-spring-carousel-item",
+                "data-testid": "use-spring-carousel-item-wrapper",
+                style: {
+                  display: "flex",
+                  position: "relative",
+                  flex: "1",
+                  ...je(
+                    c === X.findIndex(
+                      (o) => o.id === X[X.length - 1].id
+                    )
+                  )
+                },
+                children: typeof n.renderItem == "function" ? n.renderItem({
+                  getIsActiveItem: pe,
+                  getIsNextItem: he,
+                  getIsPrevItem: ve,
+                  useListenToCustomEvent: Q
+                }) : n.renderItem
+              },
+              `${n.id}-${c}`
+            )),
+            (h || !s) && l ? /* @__PURE__ */ N.jsx(
+              "div",
+              {
+                style: {
+                  flexShrink: 0,
+                  width: l
+                }
+              }
+            ) : null
+          ]
+        }
+      )
+    }
+  ) });
+  return { ...F, carouselFragment: Ge, thumbsFragment: Ye };
+}
+const be = Qe(void 0);
+function Ct() {
+  const e = Ze(be);
+  if (!e)
+    throw new Error("useSpringCarouselContext must be used within the carousel.");
+  return e;
+}
+export {
+  Rt as useSpringCarousel,
+  Ct as useSpringCarouselContext
+};