@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/react-slick/lib/inner-slider.js

@@ -0,0 +1,810 @@
+import { __exports as innerSlider } from "../../../_virtual/inner-slider.js";
+import React__default from "react";
+import { __require as requireInitialState } from "./initial-state.js";
+import { __require as requireLodash_debounce } from "../../lodash.debounce/index.js";
+import { __require as requireClassnames } from "../../classnames/index.js";
+import { __require as requireInnerSliderUtils } from "./utils/innerSliderUtils.js";
+import { __require as requireTrack } from "./track.js";
+import { __require as requireDots } from "./dots.js";
+import { __require as requireArrows } from "./arrows.js";
+import require$$8 from "../../../_virtual/ResizeObserver.es.js";
+var hasRequiredInnerSlider;
+function requireInnerSlider() {
+  if (hasRequiredInnerSlider) return innerSlider;
+  hasRequiredInnerSlider = 1;
+  Object.defineProperty(innerSlider, "__esModule", {
+    value: true
+  });
+  innerSlider.InnerSlider = void 0;
+  var _react = _interopRequireDefault(React__default);
+  var _initialState = _interopRequireDefault(requireInitialState());
+  var _lodash = _interopRequireDefault(requireLodash_debounce());
+  var _classnames = _interopRequireDefault(requireClassnames());
+  var _innerSliderUtils = requireInnerSliderUtils();
+  var _track = requireTrack();
+  var _dots = requireDots();
+  var _arrows = requireArrows();
+  var _resizeObserverPolyfill = _interopRequireDefault(require$$8);
+  function _interopRequireDefault(e) {
+    return e && e.__esModule ? e : { "default": e };
+  }
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+      return typeof o2;
+    } : function(o2) {
+      return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+    }, _typeof(o);
+  }
+  function _extends() {
+    return _extends = Object.assign ? Object.assign.bind() : function(n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r in t) {
+          ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+        }
+      }
+      return n;
+    }, _extends.apply(null, arguments);
+  }
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o, r, i = _objectWithoutPropertiesLoose(e, t);
+    if (Object.getOwnPropertySymbols) {
+      var s = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < s.length; r++) {
+        o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+      }
+    }
+    return i;
+  }
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) {
+      if ({}.hasOwnProperty.call(r, n)) {
+        if (e.includes(n)) continue;
+        t[n] = r[n];
+      }
+    }
+    return t;
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r2) {
+        return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+        _defineProperty(e, r2, t[r2]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+        Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+      });
+    }
+    return e;
+  }
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", { writable: false }), e;
+  }
+  function _inherits(t, e) {
+    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+    t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: true, configurable: true } }), Object.defineProperty(t, "prototype", { writable: false }), e && _setPrototypeOf(t, e);
+  }
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+      return t2.__proto__ = e2, t2;
+    }, _setPrototypeOf(t, e);
+  }
+  function _createSuper(t) {
+    var r = _isNativeReflectConstruct();
+    return function() {
+      var e, o = _getPrototypeOf(t);
+      if (r) {
+        var s = _getPrototypeOf(this).constructor;
+        e = Reflect.construct(o, arguments, s);
+      } else e = o.apply(this, arguments);
+      return _possibleConstructorReturn(this, e);
+    };
+  }
+  function _possibleConstructorReturn(t, e) {
+    if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
+    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+    return _assertThisInitialized(t);
+  }
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+    } catch (t2) {
+    }
+    return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+      return !!t;
+    })();
+  }
+  function _getPrototypeOf(t) {
+    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
+      return t2.__proto__ || Object.getPrototypeOf(t2);
+    }, _getPrototypeOf(t);
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != _typeof(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != _typeof(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  innerSlider.InnerSlider = /* @__PURE__ */ (function(_React$Component) {
+    _inherits(InnerSlider, _React$Component);
+    var _super = _createSuper(InnerSlider);
+    function InnerSlider(props) {
+      var _this;
+      _classCallCheck(this, InnerSlider);
+      _this = _super.call(this, props);
+      _defineProperty(_assertThisInitialized(_this), "listRefHandler", function(ref) {
+        return _this.list = ref;
+      });
+      _defineProperty(_assertThisInitialized(_this), "trackRefHandler", function(ref) {
+        return _this.track = ref;
+      });
+      _defineProperty(_assertThisInitialized(_this), "adaptHeight", function() {
+        if (_this.props.adaptiveHeight && _this.list) {
+          var elem = _this.list.querySelector('[data-index="'.concat(_this.state.currentSlide, '"]'));
+          _this.list.style.height = (0, _innerSliderUtils.getHeight)(elem) + "px";
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "componentDidMount", function() {
+        _this.props.onInit && _this.props.onInit();
+        if (_this.props.lazyLoad) {
+          var slidesToLoad = (0, _innerSliderUtils.getOnDemandLazySlides)(_objectSpread(_objectSpread({}, _this.props), _this.state));
+          if (slidesToLoad.length > 0) {
+            _this.setState(function(prevState) {
+              return {
+                lazyLoadedList: prevState.lazyLoadedList.concat(slidesToLoad)
+              };
+            });
+            if (_this.props.onLazyLoad) {
+              _this.props.onLazyLoad(slidesToLoad);
+            }
+          }
+        }
+        var spec = _objectSpread({
+          listRef: _this.list,
+          trackRef: _this.track
+        }, _this.props);
+        _this.updateState(spec, true, function() {
+          _this.adaptHeight();
+          _this.props.autoplay && _this.autoPlay("update");
+        });
+        if (_this.props.lazyLoad === "progressive") {
+          _this.lazyLoadTimer = setInterval(_this.progressiveLazyLoad, 1e3);
+        }
+        _this.ro = new _resizeObserverPolyfill["default"](function() {
+          if (_this.state.animating) {
+            _this.onWindowResized(false);
+            _this.callbackTimers.push(setTimeout(function() {
+              return _this.onWindowResized();
+            }, _this.props.speed));
+          } else {
+            _this.onWindowResized();
+          }
+        });
+        _this.ro.observe(_this.list);
+        document.querySelectorAll && Array.prototype.forEach.call(document.querySelectorAll(".slick-slide"), function(slide) {
+          slide.onfocus = _this.props.pauseOnFocus ? _this.onSlideFocus : null;
+          slide.onblur = _this.props.pauseOnFocus ? _this.onSlideBlur : null;
+        });
+        if (window.addEventListener) {
+          window.addEventListener("resize", _this.onWindowResized);
+        } else {
+          window.attachEvent("onresize", _this.onWindowResized);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "componentWillUnmount", function() {
+        if (_this.animationEndCallback) {
+          clearTimeout(_this.animationEndCallback);
+        }
+        if (_this.lazyLoadTimer) {
+          clearInterval(_this.lazyLoadTimer);
+        }
+        if (_this.callbackTimers.length) {
+          _this.callbackTimers.forEach(function(timer) {
+            return clearTimeout(timer);
+          });
+          _this.callbackTimers = [];
+        }
+        if (window.addEventListener) {
+          window.removeEventListener("resize", _this.onWindowResized);
+        } else {
+          window.detachEvent("onresize", _this.onWindowResized);
+        }
+        if (_this.autoplayTimer) {
+          clearInterval(_this.autoplayTimer);
+        }
+        _this.ro.disconnect();
+      });
+      _defineProperty(_assertThisInitialized(_this), "componentDidUpdate", function(prevProps) {
+        _this.checkImagesLoad();
+        _this.props.onReInit && _this.props.onReInit();
+        if (_this.props.lazyLoad) {
+          var slidesToLoad = (0, _innerSliderUtils.getOnDemandLazySlides)(_objectSpread(_objectSpread({}, _this.props), _this.state));
+          if (slidesToLoad.length > 0) {
+            _this.setState(function(prevState) {
+              return {
+                lazyLoadedList: prevState.lazyLoadedList.concat(slidesToLoad)
+              };
+            });
+            if (_this.props.onLazyLoad) {
+              _this.props.onLazyLoad(slidesToLoad);
+            }
+          }
+        }
+        _this.adaptHeight();
+        var spec = _objectSpread(_objectSpread({
+          listRef: _this.list,
+          trackRef: _this.track
+        }, _this.props), _this.state);
+        var setTrackStyle = _this.didPropsChange(prevProps);
+        setTrackStyle && _this.updateState(spec, setTrackStyle, function() {
+          if (_this.state.currentSlide >= _react["default"].Children.count(_this.props.children)) {
+            _this.changeSlide({
+              message: "index",
+              index: _react["default"].Children.count(_this.props.children) - _this.props.slidesToShow,
+              currentSlide: _this.state.currentSlide
+            });
+          }
+          if (_this.props.autoplay) {
+            _this.autoPlay("update");
+          } else {
+            _this.pause("paused");
+          }
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "onWindowResized", function(setTrackStyle) {
+        if (_this.debouncedResize) _this.debouncedResize.cancel();
+        _this.debouncedResize = (0, _lodash["default"])(function() {
+          return _this.resizeWindow(setTrackStyle);
+        }, 50);
+        _this.debouncedResize();
+      });
+      _defineProperty(_assertThisInitialized(_this), "resizeWindow", function() {
+        var setTrackStyle = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+        var isTrackMounted = Boolean(_this.track && _this.track.node);
+        if (!isTrackMounted) return;
+        var spec = _objectSpread(_objectSpread({
+          listRef: _this.list,
+          trackRef: _this.track
+        }, _this.props), _this.state);
+        _this.updateState(spec, setTrackStyle, function() {
+          if (_this.props.autoplay) _this.autoPlay("update");
+          else _this.pause("paused");
+        });
+        _this.setState({
+          animating: false
+        });
+        clearTimeout(_this.animationEndCallback);
+        delete _this.animationEndCallback;
+      });
+      _defineProperty(_assertThisInitialized(_this), "updateState", function(spec, setTrackStyle, callback) {
+        var updatedState = (0, _innerSliderUtils.initializedState)(spec);
+        spec = _objectSpread(_objectSpread(_objectSpread({}, spec), updatedState), {}, {
+          slideIndex: updatedState.currentSlide
+        });
+        var targetLeft = (0, _innerSliderUtils.getTrackLeft)(spec);
+        spec = _objectSpread(_objectSpread({}, spec), {}, {
+          left: targetLeft
+        });
+        var trackStyle = (0, _innerSliderUtils.getTrackCSS)(spec);
+        if (setTrackStyle || _react["default"].Children.count(_this.props.children) !== _react["default"].Children.count(spec.children)) {
+          updatedState["trackStyle"] = trackStyle;
+        }
+        _this.setState(updatedState, callback);
+      });
+      _defineProperty(_assertThisInitialized(_this), "ssrInit", function() {
+        if (_this.props.variableWidth) {
+          var _trackWidth = 0, _trackLeft = 0;
+          var childrenWidths = [];
+          var preClones = (0, _innerSliderUtils.getPreClones)(_objectSpread(_objectSpread(_objectSpread({}, _this.props), _this.state), {}, {
+            slideCount: _this.props.children.length
+          }));
+          var postClones = (0, _innerSliderUtils.getPostClones)(_objectSpread(_objectSpread(_objectSpread({}, _this.props), _this.state), {}, {
+            slideCount: _this.props.children.length
+          }));
+          _this.props.children.forEach(function(child) {
+            childrenWidths.push(child.props.style.width);
+            _trackWidth += child.props.style.width;
+          });
+          for (var i = 0; i < preClones; i++) {
+            _trackLeft += childrenWidths[childrenWidths.length - 1 - i];
+            _trackWidth += childrenWidths[childrenWidths.length - 1 - i];
+          }
+          for (var _i = 0; _i < postClones; _i++) {
+            _trackWidth += childrenWidths[_i];
+          }
+          for (var _i2 = 0; _i2 < _this.state.currentSlide; _i2++) {
+            _trackLeft += childrenWidths[_i2];
+          }
+          var _trackStyle = {
+            width: _trackWidth + "px",
+            left: -_trackLeft + "px"
+          };
+          if (_this.props.centerMode) {
+            var currentWidth = "".concat(childrenWidths[_this.state.currentSlide], "px");
+            _trackStyle.left = "calc(".concat(_trackStyle.left, " + (100% - ").concat(currentWidth, ") / 2 ) ");
+          }
+          return {
+            trackStyle: _trackStyle
+          };
+        }
+        var childrenCount = _react["default"].Children.count(_this.props.children);
+        var spec = _objectSpread(_objectSpread(_objectSpread({}, _this.props), _this.state), {}, {
+          slideCount: childrenCount
+        });
+        var slideCount = (0, _innerSliderUtils.getPreClones)(spec) + (0, _innerSliderUtils.getPostClones)(spec) + childrenCount;
+        var trackWidth = 100 / _this.props.slidesToShow * slideCount;
+        var slideWidth = 100 / slideCount;
+        var trackLeft = -slideWidth * ((0, _innerSliderUtils.getPreClones)(spec) + _this.state.currentSlide) * trackWidth / 100;
+        if (_this.props.centerMode) {
+          trackLeft += (100 - slideWidth * trackWidth / 100) / 2;
+        }
+        var trackStyle = {
+          width: trackWidth + "%",
+          left: trackLeft + "%"
+        };
+        return {
+          slideWidth: slideWidth + "%",
+          trackStyle
+        };
+      });
+      _defineProperty(_assertThisInitialized(_this), "checkImagesLoad", function() {
+        var images = _this.list && _this.list.querySelectorAll && _this.list.querySelectorAll(".slick-slide img") || [];
+        var imagesCount = images.length, loadedCount = 0;
+        Array.prototype.forEach.call(images, function(image) {
+          var handler = function handler2() {
+            return ++loadedCount && loadedCount >= imagesCount && _this.onWindowResized();
+          };
+          if (!image.onclick) {
+            image.onclick = function() {
+              return image.parentNode.focus();
+            };
+          } else {
+            var prevClickHandler = image.onclick;
+            image.onclick = function(e) {
+              prevClickHandler(e);
+              image.parentNode.focus();
+            };
+          }
+          if (!image.onload) {
+            if (_this.props.lazyLoad) {
+              image.onload = function() {
+                _this.adaptHeight();
+                _this.callbackTimers.push(setTimeout(_this.onWindowResized, _this.props.speed));
+              };
+            } else {
+              image.onload = handler;
+              image.onerror = function() {
+                handler();
+                _this.props.onLazyLoadError && _this.props.onLazyLoadError();
+              };
+            }
+          }
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "progressiveLazyLoad", function() {
+        var slidesToLoad = [];
+        var spec = _objectSpread(_objectSpread({}, _this.props), _this.state);
+        for (var index = _this.state.currentSlide; index < _this.state.slideCount + (0, _innerSliderUtils.getPostClones)(spec); index++) {
+          if (_this.state.lazyLoadedList.indexOf(index) < 0) {
+            slidesToLoad.push(index);
+            break;
+          }
+        }
+        for (var _index = _this.state.currentSlide - 1; _index >= -(0, _innerSliderUtils.getPreClones)(spec); _index--) {
+          if (_this.state.lazyLoadedList.indexOf(_index) < 0) {
+            slidesToLoad.push(_index);
+            break;
+          }
+        }
+        if (slidesToLoad.length > 0) {
+          _this.setState(function(state) {
+            return {
+              lazyLoadedList: state.lazyLoadedList.concat(slidesToLoad)
+            };
+          });
+          if (_this.props.onLazyLoad) {
+            _this.props.onLazyLoad(slidesToLoad);
+          }
+        } else {
+          if (_this.lazyLoadTimer) {
+            clearInterval(_this.lazyLoadTimer);
+            delete _this.lazyLoadTimer;
+          }
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "slideHandler", function(index) {
+        var dontAnimate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+        var _this$props = _this.props, asNavFor = _this$props.asNavFor, beforeChange = _this$props.beforeChange, onLazyLoad = _this$props.onLazyLoad, speed = _this$props.speed, afterChange = _this$props.afterChange;
+        var currentSlide = _this.state.currentSlide;
+        var _slideHandler = (0, _innerSliderUtils.slideHandler)(_objectSpread(_objectSpread(_objectSpread({
+          index
+        }, _this.props), _this.state), {}, {
+          trackRef: _this.track,
+          useCSS: _this.props.useCSS && !dontAnimate
+        })), state = _slideHandler.state, nextState = _slideHandler.nextState;
+        if (!state) return;
+        beforeChange && beforeChange(currentSlide, state.currentSlide);
+        var slidesToLoad = state.lazyLoadedList.filter(function(value) {
+          return _this.state.lazyLoadedList.indexOf(value) < 0;
+        });
+        onLazyLoad && slidesToLoad.length > 0 && onLazyLoad(slidesToLoad);
+        if (!_this.props.waitForAnimate && _this.animationEndCallback) {
+          clearTimeout(_this.animationEndCallback);
+          afterChange && afterChange(currentSlide);
+          delete _this.animationEndCallback;
+        }
+        _this.setState(state, function() {
+          if (asNavFor && _this.asNavForIndex !== index) {
+            _this.asNavForIndex = index;
+            asNavFor.innerSlider.slideHandler(index);
+          }
+          if (!nextState) return;
+          _this.animationEndCallback = setTimeout(function() {
+            var animating = nextState.animating, firstBatch = _objectWithoutProperties(nextState, ["animating"]);
+            _this.setState(firstBatch, function() {
+              _this.callbackTimers.push(setTimeout(function() {
+                return _this.setState({
+                  animating
+                });
+              }, 10));
+              afterChange && afterChange(state.currentSlide);
+              delete _this.animationEndCallback;
+            });
+          }, speed);
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "changeSlide", function(options) {
+        var dontAnimate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+        var spec = _objectSpread(_objectSpread({}, _this.props), _this.state);
+        var targetSlide = (0, _innerSliderUtils.changeSlide)(spec, options);
+        if (targetSlide !== 0 && !targetSlide) return;
+        if (dontAnimate === true) {
+          _this.slideHandler(targetSlide, dontAnimate);
+        } else {
+          _this.slideHandler(targetSlide);
+        }
+        _this.props.autoplay && _this.autoPlay("update");
+        if (_this.props.focusOnSelect) {
+          var nodes = _this.list.querySelectorAll(".slick-current");
+          nodes[0] && nodes[0].focus();
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "clickHandler", function(e) {
+        if (_this.clickable === false) {
+          e.stopPropagation();
+          e.preventDefault();
+        }
+        _this.clickable = true;
+      });
+      _defineProperty(_assertThisInitialized(_this), "keyHandler", function(e) {
+        var dir = (0, _innerSliderUtils.keyHandler)(e, _this.props.accessibility, _this.props.rtl);
+        dir !== "" && _this.changeSlide({
+          message: dir
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "selectHandler", function(options) {
+        _this.changeSlide(options);
+      });
+      _defineProperty(_assertThisInitialized(_this), "disableBodyScroll", function() {
+        var preventDefault = function preventDefault2(e) {
+          e = e || window.event;
+          if (e.preventDefault) e.preventDefault();
+          e.returnValue = false;
+        };
+        window.ontouchmove = preventDefault;
+      });
+      _defineProperty(_assertThisInitialized(_this), "enableBodyScroll", function() {
+        window.ontouchmove = null;
+      });
+      _defineProperty(_assertThisInitialized(_this), "swipeStart", function(e) {
+        if (_this.props.verticalSwiping) {
+          _this.disableBodyScroll();
+        }
+        var state = (0, _innerSliderUtils.swipeStart)(e, _this.props.swipe, _this.props.draggable);
+        state !== "" && _this.setState(state);
+      });
+      _defineProperty(_assertThisInitialized(_this), "swipeMove", function(e) {
+        var state = (0, _innerSliderUtils.swipeMove)(e, _objectSpread(_objectSpread(_objectSpread({}, _this.props), _this.state), {}, {
+          trackRef: _this.track,
+          listRef: _this.list,
+          slideIndex: _this.state.currentSlide
+        }));
+        if (!state) return;
+        if (state["swiping"]) {
+          _this.clickable = false;
+        }
+        _this.setState(state);
+      });
+      _defineProperty(_assertThisInitialized(_this), "swipeEnd", function(e) {
+        var state = (0, _innerSliderUtils.swipeEnd)(e, _objectSpread(_objectSpread(_objectSpread({}, _this.props), _this.state), {}, {
+          trackRef: _this.track,
+          listRef: _this.list,
+          slideIndex: _this.state.currentSlide
+        }));
+        if (!state) return;
+        var triggerSlideHandler = state["triggerSlideHandler"];
+        delete state["triggerSlideHandler"];
+        _this.setState(state);
+        if (triggerSlideHandler === void 0) return;
+        _this.slideHandler(triggerSlideHandler);
+        if (_this.props.verticalSwiping) {
+          _this.enableBodyScroll();
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "touchEnd", function(e) {
+        _this.swipeEnd(e);
+        _this.clickable = true;
+      });
+      _defineProperty(_assertThisInitialized(_this), "slickPrev", function() {
+        _this.callbackTimers.push(setTimeout(function() {
+          return _this.changeSlide({
+            message: "previous"
+          });
+        }, 0));
+      });
+      _defineProperty(_assertThisInitialized(_this), "slickNext", function() {
+        _this.callbackTimers.push(setTimeout(function() {
+          return _this.changeSlide({
+            message: "next"
+          });
+        }, 0));
+      });
+      _defineProperty(_assertThisInitialized(_this), "slickGoTo", function(slide) {
+        var dontAnimate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+        slide = Number(slide);
+        if (isNaN(slide)) return "";
+        _this.callbackTimers.push(setTimeout(function() {
+          return _this.changeSlide({
+            message: "index",
+            index: slide,
+            currentSlide: _this.state.currentSlide
+          }, dontAnimate);
+        }, 0));
+      });
+      _defineProperty(_assertThisInitialized(_this), "play", function() {
+        var nextIndex;
+        if (_this.props.rtl) {
+          nextIndex = _this.state.currentSlide - _this.props.slidesToScroll;
+        } else {
+          if ((0, _innerSliderUtils.canGoNext)(_objectSpread(_objectSpread({}, _this.props), _this.state))) {
+            nextIndex = _this.state.currentSlide + _this.props.slidesToScroll;
+          } else {
+            return false;
+          }
+        }
+        _this.slideHandler(nextIndex);
+      });
+      _defineProperty(_assertThisInitialized(_this), "autoPlay", function(playType) {
+        if (_this.autoplayTimer) {
+          clearInterval(_this.autoplayTimer);
+        }
+        var autoplaying = _this.state.autoplaying;
+        if (playType === "update") {
+          if (autoplaying === "hovered" || autoplaying === "focused" || autoplaying === "paused") {
+            return;
+          }
+        } else if (playType === "leave") {
+          if (autoplaying === "paused" || autoplaying === "focused") {
+            return;
+          }
+        } else if (playType === "blur") {
+          if (autoplaying === "paused" || autoplaying === "hovered") {
+            return;
+          }
+        }
+        _this.autoplayTimer = setInterval(_this.play, _this.props.autoplaySpeed + 50);
+        _this.setState({
+          autoplaying: "playing"
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "pause", function(pauseType) {
+        if (_this.autoplayTimer) {
+          clearInterval(_this.autoplayTimer);
+          _this.autoplayTimer = null;
+        }
+        var autoplaying = _this.state.autoplaying;
+        if (pauseType === "paused") {
+          _this.setState({
+            autoplaying: "paused"
+          });
+        } else if (pauseType === "focused") {
+          if (autoplaying === "hovered" || autoplaying === "playing") {
+            _this.setState({
+              autoplaying: "focused"
+            });
+          }
+        } else {
+          if (autoplaying === "playing") {
+            _this.setState({
+              autoplaying: "hovered"
+            });
+          }
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onDotsOver", function() {
+        return _this.props.autoplay && _this.pause("hovered");
+      });
+      _defineProperty(_assertThisInitialized(_this), "onDotsLeave", function() {
+        return _this.props.autoplay && _this.state.autoplaying === "hovered" && _this.autoPlay("leave");
+      });
+      _defineProperty(_assertThisInitialized(_this), "onTrackOver", function() {
+        return _this.props.autoplay && _this.pause("hovered");
+      });
+      _defineProperty(_assertThisInitialized(_this), "onTrackLeave", function() {
+        return _this.props.autoplay && _this.state.autoplaying === "hovered" && _this.autoPlay("leave");
+      });
+      _defineProperty(_assertThisInitialized(_this), "onSlideFocus", function() {
+        return _this.props.autoplay && _this.pause("focused");
+      });
+      _defineProperty(_assertThisInitialized(_this), "onSlideBlur", function() {
+        return _this.props.autoplay && _this.state.autoplaying === "focused" && _this.autoPlay("blur");
+      });
+      _defineProperty(_assertThisInitialized(_this), "render", function() {
+        var className = (0, _classnames["default"])("slick-slider", _this.props.className, {
+          "slick-vertical": _this.props.vertical,
+          "slick-initialized": true
+        });
+        var spec = _objectSpread(_objectSpread({}, _this.props), _this.state);
+        var trackProps = (0, _innerSliderUtils.extractObject)(spec, ["fade", "cssEase", "speed", "infinite", "centerMode", "focusOnSelect", "currentSlide", "lazyLoad", "lazyLoadedList", "rtl", "slideWidth", "slideHeight", "listHeight", "vertical", "slidesToShow", "slidesToScroll", "slideCount", "trackStyle", "variableWidth", "unslick", "centerPadding", "targetSlide", "useCSS"]);
+        var pauseOnHover = _this.props.pauseOnHover;
+        trackProps = _objectSpread(_objectSpread({}, trackProps), {}, {
+          onMouseEnter: pauseOnHover ? _this.onTrackOver : null,
+          onMouseLeave: pauseOnHover ? _this.onTrackLeave : null,
+          onMouseOver: pauseOnHover ? _this.onTrackOver : null,
+          focusOnSelect: _this.props.focusOnSelect && _this.clickable ? _this.selectHandler : null
+        });
+        var dots;
+        if (_this.props.dots === true && _this.state.slideCount >= _this.props.slidesToShow) {
+          var dotProps = (0, _innerSliderUtils.extractObject)(spec, ["dotsClass", "slideCount", "slidesToShow", "currentSlide", "slidesToScroll", "clickHandler", "children", "customPaging", "infinite", "appendDots"]);
+          var pauseOnDotsHover = _this.props.pauseOnDotsHover;
+          dotProps = _objectSpread(_objectSpread({}, dotProps), {}, {
+            clickHandler: _this.changeSlide,
+            onMouseEnter: pauseOnDotsHover ? _this.onDotsLeave : null,
+            onMouseOver: pauseOnDotsHover ? _this.onDotsOver : null,
+            onMouseLeave: pauseOnDotsHover ? _this.onDotsLeave : null
+          });
+          dots = /* @__PURE__ */ _react["default"].createElement(_dots.Dots, dotProps);
+        }
+        var prevArrow, nextArrow;
+        var arrowProps = (0, _innerSliderUtils.extractObject)(spec, ["infinite", "centerMode", "currentSlide", "slideCount", "slidesToShow", "prevArrow", "nextArrow"]);
+        arrowProps.clickHandler = _this.changeSlide;
+        if (_this.props.arrows) {
+          prevArrow = /* @__PURE__ */ _react["default"].createElement(_arrows.PrevArrow, arrowProps);
+          nextArrow = /* @__PURE__ */ _react["default"].createElement(_arrows.NextArrow, arrowProps);
+        }
+        var verticalHeightStyle = null;
+        if (_this.props.vertical) {
+          verticalHeightStyle = {
+            height: _this.state.listHeight
+          };
+        }
+        var centerPaddingStyle = null;
+        if (_this.props.vertical === false) {
+          if (_this.props.centerMode === true) {
+            centerPaddingStyle = {
+              padding: "0px " + _this.props.centerPadding
+            };
+          }
+        } else {
+          if (_this.props.centerMode === true) {
+            centerPaddingStyle = {
+              padding: _this.props.centerPadding + " 0px"
+            };
+          }
+        }
+        var listStyle = _objectSpread(_objectSpread({}, verticalHeightStyle), centerPaddingStyle);
+        var touchMove = _this.props.touchMove;
+        var listProps = {
+          className: "slick-list",
+          style: listStyle,
+          onClick: _this.clickHandler,
+          onMouseDown: touchMove ? _this.swipeStart : null,
+          onMouseMove: _this.state.dragging && touchMove ? _this.swipeMove : null,
+          onMouseUp: touchMove ? _this.swipeEnd : null,
+          onMouseLeave: _this.state.dragging && touchMove ? _this.swipeEnd : null,
+          onTouchStart: touchMove ? _this.swipeStart : null,
+          onTouchMove: _this.state.dragging && touchMove ? _this.swipeMove : null,
+          onTouchEnd: touchMove ? _this.touchEnd : null,
+          onTouchCancel: _this.state.dragging && touchMove ? _this.swipeEnd : null,
+          onKeyDown: _this.props.accessibility ? _this.keyHandler : null
+        };
+        var innerSliderProps = {
+          className,
+          dir: "ltr",
+          style: _this.props.style
+        };
+        if (_this.props.unslick) {
+          listProps = {
+            className: "slick-list"
+          };
+          innerSliderProps = {
+            className,
+            style: _this.props.style
+          };
+        }
+        return /* @__PURE__ */ _react["default"].createElement("div", innerSliderProps, !_this.props.unslick ? prevArrow : "", /* @__PURE__ */ _react["default"].createElement("div", _extends({
+          ref: _this.listRefHandler
+        }, listProps), /* @__PURE__ */ _react["default"].createElement(_track.Track, _extends({
+          ref: _this.trackRefHandler
+        }, trackProps), _this.props.children)), !_this.props.unslick ? nextArrow : "", !_this.props.unslick ? dots : "");
+      });
+      _this.list = null;
+      _this.track = null;
+      _this.state = _objectSpread(_objectSpread({}, _initialState["default"]), {}, {
+        currentSlide: _this.props.initialSlide,
+        targetSlide: _this.props.initialSlide ? _this.props.initialSlide : 0,
+        slideCount: _react["default"].Children.count(_this.props.children)
+      });
+      _this.callbackTimers = [];
+      _this.clickable = true;
+      _this.debouncedResize = null;
+      var ssrState = _this.ssrInit();
+      _this.state = _objectSpread(_objectSpread({}, _this.state), ssrState);
+      return _this;
+    }
+    _createClass(InnerSlider, [{
+      key: "didPropsChange",
+      value: function didPropsChange(prevProps) {
+        var setTrackStyle = false;
+        for (var _i3 = 0, _Object$keys = Object.keys(this.props); _i3 < _Object$keys.length; _i3++) {
+          var key = _Object$keys[_i3];
+          if (!prevProps.hasOwnProperty(key)) {
+            setTrackStyle = true;
+            break;
+          }
+          if (_typeof(prevProps[key]) === "object" || typeof prevProps[key] === "function" || isNaN(prevProps[key])) {
+            continue;
+          }
+          if (prevProps[key] !== this.props[key]) {
+            setTrackStyle = true;
+            break;
+          }
+        }
+        return setTrackStyle || _react["default"].Children.count(this.props.children) !== _react["default"].Children.count(prevProps.children);
+      }
+    }]);
+    return InnerSlider;
+  })(_react["default"].Component);
+  return innerSlider;
+}
+export {
+  requireInnerSlider as __require
+};