@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/react-slick/lib/utils/innerSliderUtils.js

@@ -0,0 +1,730 @@
+import { __exports as innerSliderUtils } from "../../../../_virtual/innerSliderUtils.js";
+import React__default from "react";
+import { __require as requireDefaultProps } from "../default-props.js";
+var hasRequiredInnerSliderUtils;
+function requireInnerSliderUtils() {
+  if (hasRequiredInnerSliderUtils) return innerSliderUtils;
+  hasRequiredInnerSliderUtils = 1;
+  Object.defineProperty(innerSliderUtils, "__esModule", {
+    value: true
+  });
+  innerSliderUtils.checkSpecKeys = innerSliderUtils.checkNavigable = innerSliderUtils.changeSlide = innerSliderUtils.canUseDOM = innerSliderUtils.canGoNext = void 0;
+  innerSliderUtils.clamp = clamp;
+  innerSliderUtils.extractObject = void 0;
+  innerSliderUtils.filterSettings = filterSettings;
+  innerSliderUtils.validSettings = innerSliderUtils.swipeStart = innerSliderUtils.swipeMove = innerSliderUtils.swipeEnd = innerSliderUtils.slidesOnRight = innerSliderUtils.slidesOnLeft = innerSliderUtils.slideHandler = innerSliderUtils.siblingDirection = innerSliderUtils.safePreventDefault = innerSliderUtils.lazyStartIndex = innerSliderUtils.lazySlidesOnRight = innerSliderUtils.lazySlidesOnLeft = innerSliderUtils.lazyEndIndex = innerSliderUtils.keyHandler = innerSliderUtils.initializedState = innerSliderUtils.getWidth = innerSliderUtils.getTrackLeft = innerSliderUtils.getTrackCSS = innerSliderUtils.getTrackAnimateCSS = innerSliderUtils.getTotalSlides = innerSliderUtils.getSwipeDirection = innerSliderUtils.getSlideCount = innerSliderUtils.getRequiredLazySlides = innerSliderUtils.getPreClones = innerSliderUtils.getPostClones = innerSliderUtils.getOnDemandLazySlides = innerSliderUtils.getNavigableIndexes = innerSliderUtils.getHeight = void 0;
+  var _react = _interopRequireDefault(React__default);
+  var _defaultProps = _interopRequireDefault(requireDefaultProps());
+  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 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);
+  }
+  function clamp(number, lowerBound, upperBound) {
+    return Math.max(lowerBound, Math.min(number, upperBound));
+  }
+  var safePreventDefault = innerSliderUtils.safePreventDefault = function safePreventDefault2(event) {
+    var passiveEvents = ["onTouchStart", "onTouchMove", "onWheel"];
+    if (!passiveEvents.includes(event._reactName)) {
+      event.preventDefault();
+    }
+  };
+  var getOnDemandLazySlides = innerSliderUtils.getOnDemandLazySlides = function getOnDemandLazySlides2(spec) {
+    var onDemandSlides = [];
+    var startIndex = lazyStartIndex(spec);
+    var endIndex = lazyEndIndex(spec);
+    for (var slideIndex = startIndex; slideIndex < endIndex; slideIndex++) {
+      if (spec.lazyLoadedList.indexOf(slideIndex) < 0) {
+        onDemandSlides.push(slideIndex);
+      }
+    }
+    return onDemandSlides;
+  };
+  innerSliderUtils.getRequiredLazySlides = function getRequiredLazySlides(spec) {
+    var requiredSlides = [];
+    var startIndex = lazyStartIndex(spec);
+    var endIndex = lazyEndIndex(spec);
+    for (var slideIndex = startIndex; slideIndex < endIndex; slideIndex++) {
+      requiredSlides.push(slideIndex);
+    }
+    return requiredSlides;
+  };
+  var lazyStartIndex = innerSliderUtils.lazyStartIndex = function lazyStartIndex2(spec) {
+    return spec.currentSlide - lazySlidesOnLeft(spec);
+  };
+  var lazyEndIndex = innerSliderUtils.lazyEndIndex = function lazyEndIndex2(spec) {
+    return spec.currentSlide + lazySlidesOnRight(spec);
+  };
+  var lazySlidesOnLeft = innerSliderUtils.lazySlidesOnLeft = function lazySlidesOnLeft2(spec) {
+    return spec.centerMode ? Math.floor(spec.slidesToShow / 2) + (parseInt(spec.centerPadding) > 0 ? 1 : 0) : 0;
+  };
+  var lazySlidesOnRight = innerSliderUtils.lazySlidesOnRight = function lazySlidesOnRight2(spec) {
+    return spec.centerMode ? Math.floor((spec.slidesToShow - 1) / 2) + 1 + (parseInt(spec.centerPadding) > 0 ? 1 : 0) : spec.slidesToShow;
+  };
+  var getWidth = innerSliderUtils.getWidth = function getWidth2(elem) {
+    return elem && elem.offsetWidth || 0;
+  };
+  var getHeight = innerSliderUtils.getHeight = function getHeight2(elem) {
+    return elem && elem.offsetHeight || 0;
+  };
+  var getSwipeDirection = innerSliderUtils.getSwipeDirection = function getSwipeDirection2(touchObject) {
+    var verticalSwiping = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    var xDist, yDist, r, swipeAngle;
+    xDist = touchObject.startX - touchObject.curX;
+    yDist = touchObject.startY - touchObject.curY;
+    r = Math.atan2(yDist, xDist);
+    swipeAngle = Math.round(r * 180 / Math.PI);
+    if (swipeAngle < 0) {
+      swipeAngle = 360 - Math.abs(swipeAngle);
+    }
+    if (swipeAngle <= 45 && swipeAngle >= 0 || swipeAngle <= 360 && swipeAngle >= 315) {
+      return "left";
+    }
+    if (swipeAngle >= 135 && swipeAngle <= 225) {
+      return "right";
+    }
+    if (verticalSwiping === true) {
+      if (swipeAngle >= 35 && swipeAngle <= 135) {
+        return "up";
+      } else {
+        return "down";
+      }
+    }
+    return "vertical";
+  };
+  var canGoNext = innerSliderUtils.canGoNext = function canGoNext2(spec) {
+    var canGo = true;
+    if (!spec.infinite) {
+      if (spec.centerMode && spec.currentSlide >= spec.slideCount - 1) {
+        canGo = false;
+      } else if (spec.slideCount <= spec.slidesToShow || spec.currentSlide >= spec.slideCount - spec.slidesToShow) {
+        canGo = false;
+      }
+    }
+    return canGo;
+  };
+  innerSliderUtils.extractObject = function extractObject(spec, keys) {
+    var newObject = {};
+    keys.forEach(function(key) {
+      return newObject[key] = spec[key];
+    });
+    return newObject;
+  };
+  innerSliderUtils.initializedState = function initializedState(spec) {
+    var slideCount = _react["default"].Children.count(spec.children);
+    var listNode = spec.listRef;
+    var listWidth = Math.ceil(getWidth(listNode));
+    var trackNode = spec.trackRef && spec.trackRef.node;
+    var trackWidth = Math.ceil(getWidth(trackNode));
+    var slideWidth;
+    if (!spec.vertical) {
+      var centerPaddingAdj = spec.centerMode && parseInt(spec.centerPadding) * 2;
+      if (typeof spec.centerPadding === "string" && spec.centerPadding.slice(-1) === "%") {
+        centerPaddingAdj *= listWidth / 100;
+      }
+      slideWidth = Math.ceil((listWidth - centerPaddingAdj) / spec.slidesToShow);
+    } else {
+      slideWidth = listWidth;
+    }
+    var slideHeight = listNode && getHeight(listNode.querySelector('[data-index="0"]'));
+    var listHeight = slideHeight * spec.slidesToShow;
+    var currentSlide = spec.currentSlide === void 0 ? spec.initialSlide : spec.currentSlide;
+    if (spec.rtl && spec.currentSlide === void 0) {
+      currentSlide = slideCount - 1 - spec.initialSlide;
+    }
+    var lazyLoadedList = spec.lazyLoadedList || [];
+    var slidesToLoad = getOnDemandLazySlides(_objectSpread(_objectSpread({}, spec), {}, {
+      currentSlide,
+      lazyLoadedList
+    }));
+    lazyLoadedList = lazyLoadedList.concat(slidesToLoad);
+    var state = {
+      slideCount,
+      slideWidth,
+      listWidth,
+      trackWidth,
+      currentSlide,
+      slideHeight,
+      listHeight,
+      lazyLoadedList
+    };
+    if (spec.autoplaying === null && spec.autoplay) {
+      state["autoplaying"] = "playing";
+    }
+    return state;
+  };
+  innerSliderUtils.slideHandler = function slideHandler(spec) {
+    var waitForAnimate = spec.waitForAnimate, animating = spec.animating, fade = spec.fade, infinite = spec.infinite, index = spec.index, slideCount = spec.slideCount, lazyLoad = spec.lazyLoad, currentSlide = spec.currentSlide, centerMode = spec.centerMode, slidesToScroll = spec.slidesToScroll, slidesToShow = spec.slidesToShow, useCSS = spec.useCSS;
+    var lazyLoadedList = spec.lazyLoadedList;
+    if (waitForAnimate && animating) return {};
+    var animationSlide = index, finalSlide, animationLeft, finalLeft;
+    var state = {}, nextState = {};
+    var targetSlide = infinite ? index : clamp(index, 0, slideCount - 1);
+    if (fade) {
+      if (!infinite && (index < 0 || index >= slideCount)) return {};
+      if (index < 0) {
+        animationSlide = index + slideCount;
+      } else if (index >= slideCount) {
+        animationSlide = index - slideCount;
+      }
+      if (lazyLoad && lazyLoadedList.indexOf(animationSlide) < 0) {
+        lazyLoadedList = lazyLoadedList.concat(animationSlide);
+      }
+      state = {
+        animating: true,
+        currentSlide: animationSlide,
+        lazyLoadedList,
+        targetSlide: animationSlide
+      };
+      nextState = {
+        animating: false,
+        targetSlide: animationSlide
+      };
+    } else {
+      finalSlide = animationSlide;
+      if (animationSlide < 0) {
+        finalSlide = animationSlide + slideCount;
+        if (!infinite) finalSlide = 0;
+        else if (slideCount % slidesToScroll !== 0) finalSlide = slideCount - slideCount % slidesToScroll;
+      } else if (!canGoNext(spec) && animationSlide > currentSlide) {
+        animationSlide = finalSlide = currentSlide;
+      } else if (centerMode && animationSlide >= slideCount) {
+        animationSlide = infinite ? slideCount : slideCount - 1;
+        finalSlide = infinite ? 0 : slideCount - 1;
+      } else if (animationSlide >= slideCount) {
+        finalSlide = animationSlide - slideCount;
+        if (!infinite) finalSlide = slideCount - slidesToShow;
+        else if (slideCount % slidesToScroll !== 0) finalSlide = 0;
+      }
+      if (!infinite && animationSlide + slidesToShow >= slideCount) {
+        finalSlide = slideCount - slidesToShow;
+      }
+      animationLeft = getTrackLeft(_objectSpread(_objectSpread({}, spec), {}, {
+        slideIndex: animationSlide
+      }));
+      finalLeft = getTrackLeft(_objectSpread(_objectSpread({}, spec), {}, {
+        slideIndex: finalSlide
+      }));
+      if (!infinite) {
+        if (animationLeft === finalLeft) animationSlide = finalSlide;
+        animationLeft = finalLeft;
+      }
+      if (lazyLoad) {
+        lazyLoadedList = lazyLoadedList.concat(getOnDemandLazySlides(_objectSpread(_objectSpread({}, spec), {}, {
+          currentSlide: animationSlide
+        })));
+      }
+      if (!useCSS) {
+        state = {
+          currentSlide: finalSlide,
+          trackStyle: getTrackCSS(_objectSpread(_objectSpread({}, spec), {}, {
+            left: finalLeft
+          })),
+          lazyLoadedList,
+          targetSlide
+        };
+      } else {
+        state = {
+          animating: true,
+          currentSlide: finalSlide,
+          trackStyle: getTrackAnimateCSS(_objectSpread(_objectSpread({}, spec), {}, {
+            left: animationLeft
+          })),
+          lazyLoadedList,
+          targetSlide
+        };
+        nextState = {
+          animating: false,
+          currentSlide: finalSlide,
+          trackStyle: getTrackCSS(_objectSpread(_objectSpread({}, spec), {}, {
+            left: finalLeft
+          })),
+          swipeLeft: null,
+          targetSlide
+        };
+      }
+    }
+    return {
+      state,
+      nextState
+    };
+  };
+  innerSliderUtils.changeSlide = function changeSlide(spec, options) {
+    var indexOffset, previousInt, slideOffset, unevenOffset, targetSlide;
+    var slidesToScroll = spec.slidesToScroll, slidesToShow = spec.slidesToShow, slideCount = spec.slideCount, currentSlide = spec.currentSlide, previousTargetSlide = spec.targetSlide, lazyLoad = spec.lazyLoad, infinite = spec.infinite;
+    unevenOffset = slideCount % slidesToScroll !== 0;
+    indexOffset = unevenOffset ? 0 : (slideCount - currentSlide) % slidesToScroll;
+    if (options.message === "previous") {
+      slideOffset = indexOffset === 0 ? slidesToScroll : slidesToShow - indexOffset;
+      targetSlide = currentSlide - slideOffset;
+      if (lazyLoad && !infinite) {
+        previousInt = currentSlide - slideOffset;
+        targetSlide = previousInt === -1 ? slideCount - 1 : previousInt;
+      }
+      if (!infinite) {
+        targetSlide = previousTargetSlide - slidesToScroll;
+      }
+    } else if (options.message === "next") {
+      slideOffset = indexOffset === 0 ? slidesToScroll : indexOffset;
+      targetSlide = currentSlide + slideOffset;
+      if (lazyLoad && !infinite) {
+        targetSlide = (currentSlide + slidesToScroll) % slideCount + indexOffset;
+      }
+      if (!infinite) {
+        targetSlide = previousTargetSlide + slidesToScroll;
+      }
+    } else if (options.message === "dots") {
+      targetSlide = options.index * options.slidesToScroll;
+    } else if (options.message === "children") {
+      targetSlide = options.index;
+      if (infinite) {
+        var direction = siblingDirection(_objectSpread(_objectSpread({}, spec), {}, {
+          targetSlide
+        }));
+        if (targetSlide > options.currentSlide && direction === "left") {
+          targetSlide = targetSlide - slideCount;
+        } else if (targetSlide < options.currentSlide && direction === "right") {
+          targetSlide = targetSlide + slideCount;
+        }
+      }
+    } else if (options.message === "index") {
+      targetSlide = Number(options.index);
+    }
+    return targetSlide;
+  };
+  innerSliderUtils.keyHandler = function keyHandler(e, accessibility, rtl) {
+    if (e.target.tagName.match("TEXTAREA|INPUT|SELECT") || !accessibility) return "";
+    if (e.keyCode === 37) return rtl ? "next" : "previous";
+    if (e.keyCode === 39) return rtl ? "previous" : "next";
+    return "";
+  };
+  innerSliderUtils.swipeStart = function swipeStart(e, swipe, draggable) {
+    e.target.tagName === "IMG" && safePreventDefault(e);
+    if (!swipe || !draggable && e.type.indexOf("mouse") !== -1) return "";
+    return {
+      dragging: true,
+      touchObject: {
+        startX: e.touches ? e.touches[0].pageX : e.clientX,
+        startY: e.touches ? e.touches[0].pageY : e.clientY,
+        curX: e.touches ? e.touches[0].pageX : e.clientX,
+        curY: e.touches ? e.touches[0].pageY : e.clientY
+      }
+    };
+  };
+  innerSliderUtils.swipeMove = function swipeMove(e, spec) {
+    var scrolling = spec.scrolling, animating = spec.animating, vertical = spec.vertical, swipeToSlide = spec.swipeToSlide, verticalSwiping = spec.verticalSwiping, rtl = spec.rtl, currentSlide = spec.currentSlide, edgeFriction = spec.edgeFriction, edgeDragged = spec.edgeDragged, onEdge = spec.onEdge, swiped = spec.swiped, swiping = spec.swiping, slideCount = spec.slideCount, slidesToScroll = spec.slidesToScroll, infinite = spec.infinite, touchObject = spec.touchObject, swipeEvent = spec.swipeEvent, listHeight = spec.listHeight, listWidth = spec.listWidth;
+    if (scrolling) return;
+    if (animating) return safePreventDefault(e);
+    if (vertical && swipeToSlide && verticalSwiping) safePreventDefault(e);
+    var swipeLeft, state = {};
+    var curLeft = getTrackLeft(spec);
+    touchObject.curX = e.touches ? e.touches[0].pageX : e.clientX;
+    touchObject.curY = e.touches ? e.touches[0].pageY : e.clientY;
+    touchObject.swipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curX - touchObject.startX, 2)));
+    var verticalSwipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curY - touchObject.startY, 2)));
+    if (!verticalSwiping && !swiping && verticalSwipeLength > 10) {
+      return {
+        scrolling: true
+      };
+    }
+    if (verticalSwiping) touchObject.swipeLength = verticalSwipeLength;
+    var positionOffset = (!rtl ? 1 : -1) * (touchObject.curX > touchObject.startX ? 1 : -1);
+    if (verticalSwiping) positionOffset = touchObject.curY > touchObject.startY ? 1 : -1;
+    var dotCount = Math.ceil(slideCount / slidesToScroll);
+    var swipeDirection = getSwipeDirection(spec.touchObject, verticalSwiping);
+    var touchSwipeLength = touchObject.swipeLength;
+    if (!infinite) {
+      if (currentSlide === 0 && (swipeDirection === "right" || swipeDirection === "down") || currentSlide + 1 >= dotCount && (swipeDirection === "left" || swipeDirection === "up") || !canGoNext(spec) && (swipeDirection === "left" || swipeDirection === "up")) {
+        touchSwipeLength = touchObject.swipeLength * edgeFriction;
+        if (edgeDragged === false && onEdge) {
+          onEdge(swipeDirection);
+          state["edgeDragged"] = true;
+        }
+      }
+    }
+    if (!swiped && swipeEvent) {
+      swipeEvent(swipeDirection);
+      state["swiped"] = true;
+    }
+    if (!vertical) {
+      if (!rtl) {
+        swipeLeft = curLeft + touchSwipeLength * positionOffset;
+      } else {
+        swipeLeft = curLeft - touchSwipeLength * positionOffset;
+      }
+    } else {
+      swipeLeft = curLeft + touchSwipeLength * (listHeight / listWidth) * positionOffset;
+    }
+    if (verticalSwiping) {
+      swipeLeft = curLeft + touchSwipeLength * positionOffset;
+    }
+    state = _objectSpread(_objectSpread({}, state), {}, {
+      touchObject,
+      swipeLeft,
+      trackStyle: getTrackCSS(_objectSpread(_objectSpread({}, spec), {}, {
+        left: swipeLeft
+      }))
+    });
+    if (Math.abs(touchObject.curX - touchObject.startX) < Math.abs(touchObject.curY - touchObject.startY) * 0.8) {
+      return state;
+    }
+    if (touchObject.swipeLength > 10) {
+      state["swiping"] = true;
+      safePreventDefault(e);
+    }
+    return state;
+  };
+  innerSliderUtils.swipeEnd = function swipeEnd(e, spec) {
+    var dragging = spec.dragging, swipe = spec.swipe, touchObject = spec.touchObject, listWidth = spec.listWidth, touchThreshold = spec.touchThreshold, verticalSwiping = spec.verticalSwiping, listHeight = spec.listHeight, swipeToSlide = spec.swipeToSlide, scrolling = spec.scrolling, onSwipe = spec.onSwipe, targetSlide = spec.targetSlide, currentSlide = spec.currentSlide, infinite = spec.infinite;
+    if (!dragging) {
+      if (swipe) safePreventDefault(e);
+      return {};
+    }
+    var minSwipe = verticalSwiping ? listHeight / touchThreshold : listWidth / touchThreshold;
+    var swipeDirection = getSwipeDirection(touchObject, verticalSwiping);
+    var state = {
+      dragging: false,
+      edgeDragged: false,
+      scrolling: false,
+      swiping: false,
+      swiped: false,
+      swipeLeft: null,
+      touchObject: {}
+    };
+    if (scrolling) {
+      return state;
+    }
+    if (!touchObject.swipeLength) {
+      return state;
+    }
+    if (touchObject.swipeLength > minSwipe) {
+      safePreventDefault(e);
+      if (onSwipe) {
+        onSwipe(swipeDirection);
+      }
+      var slideCount, newSlide;
+      var activeSlide = infinite ? currentSlide : targetSlide;
+      switch (swipeDirection) {
+        case "left":
+        case "up":
+          newSlide = activeSlide + getSlideCount(spec);
+          slideCount = swipeToSlide ? checkNavigable(spec, newSlide) : newSlide;
+          state["currentDirection"] = 0;
+          break;
+        case "right":
+        case "down":
+          newSlide = activeSlide - getSlideCount(spec);
+          slideCount = swipeToSlide ? checkNavigable(spec, newSlide) : newSlide;
+          state["currentDirection"] = 1;
+          break;
+        default:
+          slideCount = activeSlide;
+      }
+      state["triggerSlideHandler"] = slideCount;
+    } else {
+      var currentLeft = getTrackLeft(spec);
+      state["trackStyle"] = getTrackAnimateCSS(_objectSpread(_objectSpread({}, spec), {}, {
+        left: currentLeft
+      }));
+    }
+    return state;
+  };
+  var getNavigableIndexes = innerSliderUtils.getNavigableIndexes = function getNavigableIndexes2(spec) {
+    var max = spec.infinite ? spec.slideCount * 2 : spec.slideCount;
+    var breakpoint = spec.infinite ? spec.slidesToShow * -1 : 0;
+    var counter = spec.infinite ? spec.slidesToShow * -1 : 0;
+    var indexes = [];
+    while (breakpoint < max) {
+      indexes.push(breakpoint);
+      breakpoint = counter + spec.slidesToScroll;
+      counter += Math.min(spec.slidesToScroll, spec.slidesToShow);
+    }
+    return indexes;
+  };
+  var checkNavigable = innerSliderUtils.checkNavigable = function checkNavigable2(spec, index) {
+    var navigables = getNavigableIndexes(spec);
+    var prevNavigable = 0;
+    if (index > navigables[navigables.length - 1]) {
+      index = navigables[navigables.length - 1];
+    } else {
+      for (var n in navigables) {
+        if (index < navigables[n]) {
+          index = prevNavigable;
+          break;
+        }
+        prevNavigable = navigables[n];
+      }
+    }
+    return index;
+  };
+  var getSlideCount = innerSliderUtils.getSlideCount = function getSlideCount2(spec) {
+    var centerOffset = spec.centerMode ? spec.slideWidth * Math.floor(spec.slidesToShow / 2) : 0;
+    if (spec.swipeToSlide) {
+      var swipedSlide;
+      var slickList = spec.listRef;
+      var slides = slickList.querySelectorAll && slickList.querySelectorAll(".slick-slide") || [];
+      Array.from(slides).every(function(slide) {
+        if (!spec.vertical) {
+          if (slide.offsetLeft - centerOffset + getWidth(slide) / 2 > spec.swipeLeft * -1) {
+            swipedSlide = slide;
+            return false;
+          }
+        } else {
+          if (slide.offsetTop + getHeight(slide) / 2 > spec.swipeLeft * -1) {
+            swipedSlide = slide;
+            return false;
+          }
+        }
+        return true;
+      });
+      if (!swipedSlide) {
+        return 0;
+      }
+      var currentIndex = spec.rtl === true ? spec.slideCount - spec.currentSlide : spec.currentSlide;
+      var slidesTraversed = Math.abs(swipedSlide.dataset.index - currentIndex) || 1;
+      return slidesTraversed;
+    } else {
+      return spec.slidesToScroll;
+    }
+  };
+  var checkSpecKeys = innerSliderUtils.checkSpecKeys = function checkSpecKeys2(spec, keysArray) {
+    return keysArray.reduce(function(value, key) {
+      return value && spec.hasOwnProperty(key);
+    }, true) ? null : console.error("Keys Missing:", spec);
+  };
+  var getTrackCSS = innerSliderUtils.getTrackCSS = function getTrackCSS2(spec) {
+    checkSpecKeys(spec, ["left", "variableWidth", "slideCount", "slidesToShow", "slideWidth"]);
+    var trackWidth, trackHeight;
+    if (!spec.vertical) {
+      trackWidth = getTotalSlides(spec) * spec.slideWidth;
+    } else {
+      var trackChildren = spec.unslick ? spec.slideCount : spec.slideCount + 2 * spec.slidesToShow;
+      trackHeight = trackChildren * spec.slideHeight;
+    }
+    var style = {
+      opacity: 1,
+      transition: "",
+      WebkitTransition: ""
+    };
+    if (spec.useTransform) {
+      var WebkitTransform = !spec.vertical ? "translate3d(" + spec.left + "px, 0px, 0px)" : "translate3d(0px, " + spec.left + "px, 0px)";
+      var transform = !spec.vertical ? "translate3d(" + spec.left + "px, 0px, 0px)" : "translate3d(0px, " + spec.left + "px, 0px)";
+      var msTransform = !spec.vertical ? "translateX(" + spec.left + "px)" : "translateY(" + spec.left + "px)";
+      style = _objectSpread(_objectSpread({}, style), {}, {
+        WebkitTransform,
+        transform,
+        msTransform
+      });
+    } else {
+      if (spec.vertical) {
+        style["top"] = spec.left;
+      } else {
+        style["left"] = spec.left;
+      }
+    }
+    if (spec.fade) style = {
+      opacity: 1
+    };
+    if (trackWidth) style.width = trackWidth;
+    if (trackHeight) style.height = trackHeight;
+    if (window && !window.addEventListener && window.attachEvent) {
+      if (!spec.vertical) {
+        style.marginLeft = spec.left + "px";
+      } else {
+        style.marginTop = spec.left + "px";
+      }
+    }
+    return style;
+  };
+  var getTrackAnimateCSS = innerSliderUtils.getTrackAnimateCSS = function getTrackAnimateCSS2(spec) {
+    checkSpecKeys(spec, ["left", "variableWidth", "slideCount", "slidesToShow", "slideWidth", "speed", "cssEase"]);
+    var style = getTrackCSS(spec);
+    if (spec.useTransform) {
+      style.WebkitTransition = "-webkit-transform " + spec.speed + "ms " + spec.cssEase;
+      style.transition = "transform " + spec.speed + "ms " + spec.cssEase;
+    } else {
+      if (spec.vertical) {
+        style.transition = "top " + spec.speed + "ms " + spec.cssEase;
+      } else {
+        style.transition = "left " + spec.speed + "ms " + spec.cssEase;
+      }
+    }
+    return style;
+  };
+  var getTrackLeft = innerSliderUtils.getTrackLeft = function getTrackLeft2(spec) {
+    if (spec.unslick) {
+      return 0;
+    }
+    checkSpecKeys(spec, ["slideIndex", "trackRef", "infinite", "centerMode", "slideCount", "slidesToShow", "slidesToScroll", "slideWidth", "listWidth", "variableWidth", "slideHeight"]);
+    var slideIndex = spec.slideIndex, trackRef = spec.trackRef, infinite = spec.infinite, centerMode = spec.centerMode, slideCount = spec.slideCount, slidesToShow = spec.slidesToShow, slidesToScroll = spec.slidesToScroll, slideWidth = spec.slideWidth, listWidth = spec.listWidth, variableWidth = spec.variableWidth, slideHeight = spec.slideHeight, fade = spec.fade, vertical = spec.vertical;
+    var slideOffset = 0;
+    var targetLeft;
+    var targetSlide;
+    var verticalOffset = 0;
+    if (fade || spec.slideCount === 1) {
+      return 0;
+    }
+    var slidesToOffset = 0;
+    if (infinite) {
+      slidesToOffset = -getPreClones(spec);
+      if (slideCount % slidesToScroll !== 0 && slideIndex + slidesToScroll > slideCount) {
+        slidesToOffset = -(slideIndex > slideCount ? slidesToShow - (slideIndex - slideCount) : slideCount % slidesToScroll);
+      }
+      if (centerMode) {
+        slidesToOffset += parseInt(slidesToShow / 2);
+      }
+    } else {
+      if (slideCount % slidesToScroll !== 0 && slideIndex + slidesToScroll > slideCount) {
+        slidesToOffset = slidesToShow - slideCount % slidesToScroll;
+      }
+      if (centerMode) {
+        slidesToOffset = parseInt(slidesToShow / 2);
+      }
+    }
+    slideOffset = slidesToOffset * slideWidth;
+    verticalOffset = slidesToOffset * slideHeight;
+    if (!vertical) {
+      targetLeft = slideIndex * slideWidth * -1 + slideOffset;
+    } else {
+      targetLeft = slideIndex * slideHeight * -1 + verticalOffset;
+    }
+    if (variableWidth === true) {
+      var targetSlideIndex;
+      var trackElem = trackRef && trackRef.node;
+      targetSlideIndex = slideIndex + getPreClones(spec);
+      targetSlide = trackElem && trackElem.childNodes[targetSlideIndex];
+      targetLeft = targetSlide ? targetSlide.offsetLeft * -1 : 0;
+      if (centerMode === true) {
+        targetSlideIndex = infinite ? slideIndex + getPreClones(spec) : slideIndex;
+        targetSlide = trackElem && trackElem.children[targetSlideIndex];
+        targetLeft = 0;
+        for (var slide = 0; slide < targetSlideIndex; slide++) {
+          targetLeft -= trackElem && trackElem.children[slide] && trackElem.children[slide].offsetWidth;
+        }
+        targetLeft -= parseInt(spec.centerPadding);
+        targetLeft += targetSlide && (listWidth - targetSlide.offsetWidth) / 2;
+      }
+    }
+    return targetLeft;
+  };
+  var getPreClones = innerSliderUtils.getPreClones = function getPreClones2(spec) {
+    if (spec.unslick || !spec.infinite) {
+      return 0;
+    }
+    if (spec.variableWidth) {
+      return spec.slideCount;
+    }
+    return spec.slidesToShow + (spec.centerMode ? 1 : 0);
+  };
+  var getPostClones = innerSliderUtils.getPostClones = function getPostClones2(spec) {
+    if (spec.unslick || !spec.infinite) {
+      return 0;
+    }
+    if (spec.variableWidth) {
+      return spec.slideCount;
+    }
+    return spec.slidesToShow + (spec.centerMode ? 1 : 0);
+  };
+  var getTotalSlides = innerSliderUtils.getTotalSlides = function getTotalSlides2(spec) {
+    return spec.slideCount === 1 ? 1 : getPreClones(spec) + spec.slideCount + getPostClones(spec);
+  };
+  var siblingDirection = innerSliderUtils.siblingDirection = function siblingDirection2(spec) {
+    if (spec.targetSlide > spec.currentSlide) {
+      if (spec.targetSlide > spec.currentSlide + slidesOnRight(spec)) {
+        return "left";
+      }
+      return "right";
+    } else {
+      if (spec.targetSlide < spec.currentSlide - slidesOnLeft(spec)) {
+        return "right";
+      }
+      return "left";
+    }
+  };
+  var slidesOnRight = innerSliderUtils.slidesOnRight = function slidesOnRight2(_ref) {
+    var slidesToShow = _ref.slidesToShow, centerMode = _ref.centerMode, rtl = _ref.rtl, centerPadding = _ref.centerPadding;
+    if (centerMode) {
+      var right = (slidesToShow - 1) / 2 + 1;
+      if (parseInt(centerPadding) > 0) right += 1;
+      if (rtl && slidesToShow % 2 === 0) right += 1;
+      return right;
+    }
+    if (rtl) {
+      return 0;
+    }
+    return slidesToShow - 1;
+  };
+  var slidesOnLeft = innerSliderUtils.slidesOnLeft = function slidesOnLeft2(_ref2) {
+    var slidesToShow = _ref2.slidesToShow, centerMode = _ref2.centerMode, rtl = _ref2.rtl, centerPadding = _ref2.centerPadding;
+    if (centerMode) {
+      var left = (slidesToShow - 1) / 2 + 1;
+      if (parseInt(centerPadding) > 0) left += 1;
+      if (!rtl && slidesToShow % 2 === 0) left += 1;
+      return left;
+    }
+    if (rtl) {
+      return slidesToShow - 1;
+    }
+    return 0;
+  };
+  innerSliderUtils.canUseDOM = function canUseDOM() {
+    return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+  };
+  var validSettings = innerSliderUtils.validSettings = Object.keys(_defaultProps["default"]);
+  function filterSettings(settings) {
+    return validSettings.reduce(function(acc, settingName) {
+      if (settings.hasOwnProperty(settingName)) {
+        acc[settingName] = settings[settingName];
+      }
+      return acc;
+    }, {});
+  }
+  return innerSliderUtils;
+}
+export {
+  requireInnerSliderUtils as __require
+};