@stokr/components-library 3.0.66 → 3.0.67

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

@@ -0,0 +1,333 @@
+import { __exports as slider } from "../../../_virtual/slider.js";
+import React__default from "react";
+import { __require as requireInnerSlider } from "./inner-slider.js";
+import { __require as requireJson2mq } from "../../json2mq/index.js";
+import { __require as requireDefaultProps } from "./default-props.js";
+import { __require as requireInnerSliderUtils } from "./utils/innerSliderUtils.js";
+var hasRequiredSlider;
+function requireSlider() {
+  if (hasRequiredSlider) return slider;
+  hasRequiredSlider = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    exports$1["default"] = void 0;
+    var _react = _interopRequireDefault(React__default);
+    var _innerSlider = requireInnerSlider();
+    var _json2mq = _interopRequireDefault(requireJson2mq());
+    var _defaultProps = _interopRequireDefault(requireDefaultProps());
+    var _innerSliderUtils = requireInnerSliderUtils();
+    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 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);
+    }
+    exports$1["default"] = /* @__PURE__ */ (function(_React$Component) {
+      _inherits(Slider, _React$Component);
+      var _super = _createSuper(Slider);
+      function Slider(props) {
+        var _this;
+        _classCallCheck(this, Slider);
+        _this = _super.call(this, props);
+        _defineProperty(_assertThisInitialized(_this), "innerSliderRefHandler", function(ref) {
+          return _this.innerSlider = ref;
+        });
+        _defineProperty(_assertThisInitialized(_this), "slickPrev", function() {
+          return _this.innerSlider.slickPrev();
+        });
+        _defineProperty(_assertThisInitialized(_this), "slickNext", function() {
+          return _this.innerSlider.slickNext();
+        });
+        _defineProperty(_assertThisInitialized(_this), "slickGoTo", function(slide) {
+          var dontAnimate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+          return _this.innerSlider.slickGoTo(slide, dontAnimate);
+        });
+        _defineProperty(_assertThisInitialized(_this), "slickPause", function() {
+          return _this.innerSlider.pause("paused");
+        });
+        _defineProperty(_assertThisInitialized(_this), "slickPlay", function() {
+          return _this.innerSlider.autoPlay("play");
+        });
+        _this.state = {
+          breakpoint: null
+        };
+        _this._responsiveMediaHandlers = [];
+        return _this;
+      }
+      _createClass(Slider, [{
+        key: "media",
+        value: function media(query, handler) {
+          var mql = window.matchMedia(query);
+          var listener = function listener2(_ref) {
+            var matches = _ref.matches;
+            if (matches) {
+              handler();
+            }
+          };
+          mql.addListener(listener);
+          this._responsiveMediaHandlers.push({
+            mql,
+            query,
+            listener
+          });
+        }
+        // handles responsive breakpoints
+      }, {
+        key: "componentDidMount",
+        value: function componentDidMount() {
+          var _this2 = this;
+          if (this.props.responsive) {
+            var breakpoints = this.props.responsive.map(function(breakpt) {
+              return breakpt.breakpoint;
+            });
+            breakpoints.sort(function(x, y) {
+              return x - y;
+            });
+            breakpoints.forEach(function(breakpoint, index) {
+              var bQuery;
+              if (index === 0) {
+                bQuery = (0, _json2mq["default"])({
+                  minWidth: 0,
+                  maxWidth: breakpoint
+                });
+              } else {
+                bQuery = (0, _json2mq["default"])({
+                  minWidth: breakpoints[index - 1] + 1,
+                  maxWidth: breakpoint
+                });
+              }
+              (0, _innerSliderUtils.canUseDOM)() && _this2.media(bQuery, function() {
+                _this2.setState({
+                  breakpoint
+                });
+              });
+            });
+            var query = (0, _json2mq["default"])({
+              minWidth: breakpoints.slice(-1)[0]
+            });
+            (0, _innerSliderUtils.canUseDOM)() && this.media(query, function() {
+              _this2.setState({
+                breakpoint: null
+              });
+            });
+          }
+        }
+      }, {
+        key: "componentWillUnmount",
+        value: function componentWillUnmount() {
+          this._responsiveMediaHandlers.forEach(function(obj) {
+            obj.mql.removeListener(obj.listener);
+          });
+        }
+      }, {
+        key: "render",
+        value: function render() {
+          var _this3 = this;
+          var settings;
+          var newProps;
+          if (this.state.breakpoint) {
+            newProps = this.props.responsive.filter(function(resp) {
+              return resp.breakpoint === _this3.state.breakpoint;
+            });
+            settings = newProps[0].settings === "unslick" ? "unslick" : _objectSpread(_objectSpread(_objectSpread({}, _defaultProps["default"]), this.props), newProps[0].settings);
+          } else {
+            settings = _objectSpread(_objectSpread({}, _defaultProps["default"]), this.props);
+          }
+          if (settings.centerMode) {
+            if (settings.slidesToScroll > 1 && process.env.NODE_ENV !== "production") {
+              console.warn("slidesToScroll should be equal to 1 in centerMode, you are using ".concat(settings.slidesToScroll));
+            }
+            settings.slidesToScroll = 1;
+          }
+          if (settings.fade) {
+            if (settings.slidesToShow > 1 && process.env.NODE_ENV !== "production") {
+              console.warn("slidesToShow should be equal to 1 when fade is true, you're using ".concat(settings.slidesToShow));
+            }
+            if (settings.slidesToScroll > 1 && process.env.NODE_ENV !== "production") {
+              console.warn("slidesToScroll should be equal to 1 when fade is true, you're using ".concat(settings.slidesToScroll));
+            }
+            settings.slidesToShow = 1;
+            settings.slidesToScroll = 1;
+          }
+          var children = _react["default"].Children.toArray(this.props.children);
+          children = children.filter(function(child) {
+            if (typeof child === "string") {
+              return !!child.trim();
+            }
+            return !!child;
+          });
+          if (settings.variableWidth && (settings.rows > 1 || settings.slidesPerRow > 1)) {
+            console.warn("variableWidth is not supported in case of rows > 1 or slidesPerRow > 1");
+            settings.variableWidth = false;
+          }
+          var newChildren = [];
+          var currentWidth = null;
+          for (var i = 0; i < children.length; i += settings.rows * settings.slidesPerRow) {
+            var newSlide = [];
+            for (var j = i; j < i + settings.rows * settings.slidesPerRow; j += settings.slidesPerRow) {
+              var row = [];
+              for (var k = j; k < j + settings.slidesPerRow; k += 1) {
+                if (settings.variableWidth && children[k].props.style) {
+                  currentWidth = children[k].props.style.width;
+                }
+                if (k >= children.length) break;
+                row.push(/* @__PURE__ */ _react["default"].cloneElement(children[k], {
+                  key: 100 * i + 10 * j + k,
+                  tabIndex: -1,
+                  style: {
+                    width: "".concat(100 / settings.slidesPerRow, "%"),
+                    display: "inline-block"
+                  }
+                }));
+              }
+              newSlide.push(/* @__PURE__ */ _react["default"].createElement("div", {
+                key: 10 * i + j
+              }, row));
+            }
+            if (settings.variableWidth) {
+              newChildren.push(/* @__PURE__ */ _react["default"].createElement("div", {
+                key: i,
+                style: {
+                  width: currentWidth
+                }
+              }, newSlide));
+            } else {
+              newChildren.push(/* @__PURE__ */ _react["default"].createElement("div", {
+                key: i
+              }, newSlide));
+            }
+          }
+          if (settings === "unslick") {
+            var className = "regular slider " + (this.props.className || "");
+            return /* @__PURE__ */ _react["default"].createElement("div", {
+              className
+            }, children);
+          } else if (newChildren.length <= settings.slidesToShow) {
+            settings.unslick = true;
+          }
+          return /* @__PURE__ */ _react["default"].createElement(_innerSlider.InnerSlider, _extends({
+            style: this.props.style,
+            ref: this.innerSliderRefHandler
+          }, (0, _innerSliderUtils.filterSettings)(settings)), newChildren);
+        }
+      }]);
+      return Slider;
+    })(_react["default"].Component);
+  })(slider);
+  return slider;
+}
+export {
+  requireSlider as __require
+};

package/dist/node_modules/react-slick/lib/track.js

@@ -0,0 +1,330 @@
+import { __exports as track } from "../../../_virtual/track.js";
+import React__default from "react";
+import { __require as requireClassnames } from "../../classnames/index.js";
+import { __require as requireInnerSliderUtils } from "./utils/innerSliderUtils.js";
+var hasRequiredTrack;
+function requireTrack() {
+  if (hasRequiredTrack) return track;
+  hasRequiredTrack = 1;
+  Object.defineProperty(track, "__esModule", {
+    value: true
+  });
+  track.Track = void 0;
+  var _react = _interopRequireDefault(React__default);
+  var _classnames = _interopRequireDefault(requireClassnames());
+  var _innerSliderUtils = requireInnerSliderUtils();
+  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 _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 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 _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);
+  }
+  var getSlideClasses = function getSlideClasses2(spec) {
+    var slickActive, slickCenter, slickCloned;
+    var centerOffset, index;
+    if (spec.rtl) {
+      index = spec.slideCount - 1 - spec.index;
+    } else {
+      index = spec.index;
+    }
+    slickCloned = index < 0 || index >= spec.slideCount;
+    if (spec.centerMode) {
+      centerOffset = Math.floor(spec.slidesToShow / 2);
+      slickCenter = (index - spec.currentSlide) % spec.slideCount === 0;
+      if (index > spec.currentSlide - centerOffset - 1 && index <= spec.currentSlide + centerOffset) {
+        slickActive = true;
+      }
+    } else {
+      slickActive = spec.currentSlide <= index && index < spec.currentSlide + spec.slidesToShow;
+    }
+    var focusedSlide;
+    if (spec.targetSlide < 0) {
+      focusedSlide = spec.targetSlide + spec.slideCount;
+    } else if (spec.targetSlide >= spec.slideCount) {
+      focusedSlide = spec.targetSlide - spec.slideCount;
+    } else {
+      focusedSlide = spec.targetSlide;
+    }
+    var slickCurrent = index === focusedSlide;
+    return {
+      "slick-slide": true,
+      "slick-active": slickActive,
+      "slick-center": slickCenter,
+      "slick-cloned": slickCloned,
+      "slick-current": slickCurrent
+      // dubious in case of RTL
+    };
+  };
+  var getSlideStyle = function getSlideStyle2(spec) {
+    var style = {};
+    if (spec.variableWidth === void 0 || spec.variableWidth === false) {
+      style.width = spec.slideWidth;
+    }
+    if (spec.fade) {
+      style.position = "relative";
+      if (spec.vertical) {
+        style.top = -spec.index * parseInt(spec.slideHeight);
+      } else {
+        style.left = -spec.index * parseInt(spec.slideWidth);
+      }
+      style.opacity = spec.currentSlide === spec.index ? 1 : 0;
+      style.zIndex = spec.currentSlide === spec.index ? 999 : 998;
+      if (spec.useCSS) {
+        style.transition = "opacity " + spec.speed + "ms " + spec.cssEase + ", visibility " + spec.speed + "ms " + spec.cssEase;
+      }
+    }
+    return style;
+  };
+  var getKey = function getKey2(child, fallbackKey) {
+    return child.key || fallbackKey;
+  };
+  var renderSlides = function renderSlides2(spec) {
+    var key;
+    var slides = [];
+    var preCloneSlides = [];
+    var postCloneSlides = [];
+    var childrenCount = _react["default"].Children.count(spec.children);
+    var startIndex = (0, _innerSliderUtils.lazyStartIndex)(spec);
+    var endIndex = (0, _innerSliderUtils.lazyEndIndex)(spec);
+    _react["default"].Children.forEach(spec.children, function(elem, index) {
+      var child;
+      var childOnClickOptions = {
+        message: "children",
+        index,
+        slidesToScroll: spec.slidesToScroll,
+        currentSlide: spec.currentSlide
+      };
+      if (!spec.lazyLoad || spec.lazyLoad && spec.lazyLoadedList.indexOf(index) >= 0) {
+        child = elem;
+      } else {
+        child = /* @__PURE__ */ _react["default"].createElement("div", null);
+      }
+      var childStyle = getSlideStyle(_objectSpread(_objectSpread({}, spec), {}, {
+        index
+      }));
+      var slideClass = child.props.className || "";
+      var slideClasses = getSlideClasses(_objectSpread(_objectSpread({}, spec), {}, {
+        index
+      }));
+      slides.push(/* @__PURE__ */ _react["default"].cloneElement(child, {
+        key: "original" + getKey(child, index),
+        "data-index": index,
+        className: (0, _classnames["default"])(slideClasses, slideClass),
+        tabIndex: "-1",
+        "aria-hidden": !slideClasses["slick-active"],
+        style: _objectSpread(_objectSpread({
+          outline: "none"
+        }, child.props.style || {}), childStyle),
+        onClick: function onClick(e) {
+          child.props && child.props.onClick && child.props.onClick(e);
+          if (spec.focusOnSelect) {
+            spec.focusOnSelect(childOnClickOptions);
+          }
+        }
+      }));
+      if (spec.infinite && childrenCount > 1 && spec.fade === false && !spec.unslick) {
+        var preCloneNo = childrenCount - index;
+        if (preCloneNo <= (0, _innerSliderUtils.getPreClones)(spec)) {
+          key = -preCloneNo;
+          if (key >= startIndex) {
+            child = elem;
+          }
+          slideClasses = getSlideClasses(_objectSpread(_objectSpread({}, spec), {}, {
+            index: key
+          }));
+          preCloneSlides.push(/* @__PURE__ */ _react["default"].cloneElement(child, {
+            key: "precloned" + getKey(child, key),
+            "data-index": key,
+            tabIndex: "-1",
+            className: (0, _classnames["default"])(slideClasses, slideClass),
+            "aria-hidden": !slideClasses["slick-active"],
+            style: _objectSpread(_objectSpread({}, child.props.style || {}), childStyle),
+            onClick: function onClick(e) {
+              child.props && child.props.onClick && child.props.onClick(e);
+              if (spec.focusOnSelect) {
+                spec.focusOnSelect(childOnClickOptions);
+              }
+            }
+          }));
+        }
+        if (index < (0, _innerSliderUtils.getPostClones)(spec)) {
+          key = childrenCount + index;
+          if (key < endIndex) {
+            child = elem;
+          }
+          slideClasses = getSlideClasses(_objectSpread(_objectSpread({}, spec), {}, {
+            index: key
+          }));
+          postCloneSlides.push(/* @__PURE__ */ _react["default"].cloneElement(child, {
+            key: "postcloned" + getKey(child, key),
+            "data-index": key,
+            tabIndex: "-1",
+            className: (0, _classnames["default"])(slideClasses, slideClass),
+            "aria-hidden": !slideClasses["slick-active"],
+            style: _objectSpread(_objectSpread({}, child.props.style || {}), childStyle),
+            onClick: function onClick(e) {
+              child.props && child.props.onClick && child.props.onClick(e);
+              if (spec.focusOnSelect) {
+                spec.focusOnSelect(childOnClickOptions);
+              }
+            }
+          }));
+        }
+      }
+    });
+    if (spec.rtl) {
+      return preCloneSlides.concat(slides, postCloneSlides).reverse();
+    } else {
+      return preCloneSlides.concat(slides, postCloneSlides);
+    }
+  };
+  track.Track = /* @__PURE__ */ (function(_React$PureComponent) {
+    _inherits(Track, _React$PureComponent);
+    var _super = _createSuper(Track);
+    function Track() {
+      var _this;
+      _classCallCheck(this, Track);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "node", null);
+      _defineProperty(_assertThisInitialized(_this), "handleRef", function(ref) {
+        _this.node = ref;
+      });
+      return _this;
+    }
+    _createClass(Track, [{
+      key: "render",
+      value: function render() {
+        var slides = renderSlides(this.props);
+        var _this$props = this.props, onMouseEnter = _this$props.onMouseEnter, onMouseOver = _this$props.onMouseOver, onMouseLeave = _this$props.onMouseLeave;
+        var mouseEvents = {
+          onMouseEnter,
+          onMouseOver,
+          onMouseLeave
+        };
+        return /* @__PURE__ */ _react["default"].createElement("div", _extends({
+          ref: this.handleRef,
+          className: "slick-track",
+          style: this.props.trackStyle
+        }, mouseEvents), slides);
+      }
+    }]);
+    return Track;
+  })(_react["default"].PureComponent);
+  return track;
+}
+export {
+  requireTrack as __require
+};