@stokr/components-library 3.0.66 → 3.0.67

package/dist/node_modules/react-select/dist/react-select.esm.js

@@ -0,0 +1,20 @@
+import { u as useStateManager } from "./useStateManager-7e1e8489.esm.js";
+import _extends from "../../@babel/runtime/helpers/esm/extends.js";
+import * as React from "react";
+import { forwardRef } from "react";
+import { S as Select } from "./Select-ef7c0426.esm.js";
+import { c, d } from "./Select-ef7c0426.esm.js";
+import "react-dom";
+var StateManagedSelect = /* @__PURE__ */ forwardRef(function(props, ref) {
+  var baseSelectProps = useStateManager(props);
+  return /* @__PURE__ */ React.createElement(Select, _extends({
+    ref
+  }, baseSelectProps));
+});
+var StateManagedSelect$1 = StateManagedSelect;
+export {
+  c as createFilter,
+  StateManagedSelect$1 as default,
+  d as defaultTheme,
+  useStateManager
+};

package/dist/node_modules/react-select/dist/useCreatable-09aaeb9a.esm.js

@@ -0,0 +1,75 @@
+import _objectSpread2 from "../../@babel/runtime/helpers/esm/objectSpread2.js";
+import _toConsumableArray from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import _objectWithoutProperties from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
+import { useMemo, useCallback } from "react";
+import { H as cleanValue, D as valueTernary } from "./index-641ee5b8.esm.js";
+import { b as getOptionLabel$1, g as getOptionValue$1 } from "./Select-ef7c0426.esm.js";
+var _excluded = ["allowCreateWhileLoading", "createOptionPosition", "formatCreateLabel", "isValidNewOption", "getNewOptionData", "onCreateOption", "options", "onChange"];
+var compareOption = function compareOption2() {
+  var inputValue = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+  var option = arguments.length > 1 ? arguments[1] : void 0;
+  var accessors = arguments.length > 2 ? arguments[2] : void 0;
+  var candidate = String(inputValue).toLowerCase();
+  var optionValue = String(accessors.getOptionValue(option)).toLowerCase();
+  var optionLabel = String(accessors.getOptionLabel(option)).toLowerCase();
+  return optionValue === candidate || optionLabel === candidate;
+};
+var builtins = {
+  formatCreateLabel: function formatCreateLabel(inputValue) {
+    return 'Create "'.concat(inputValue, '"');
+  },
+  isValidNewOption: function isValidNewOption(inputValue, selectValue, selectOptions, accessors) {
+    return !(!inputValue || selectValue.some(function(option) {
+      return compareOption(inputValue, option, accessors);
+    }) || selectOptions.some(function(option) {
+      return compareOption(inputValue, option, accessors);
+    }));
+  },
+  getNewOptionData: function getNewOptionData(inputValue, optionLabel) {
+    return {
+      label: optionLabel,
+      value: inputValue,
+      __isNew__: true
+    };
+  }
+};
+function useCreatable(_ref) {
+  var _ref$allowCreateWhile = _ref.allowCreateWhileLoading, allowCreateWhileLoading = _ref$allowCreateWhile === void 0 ? false : _ref$allowCreateWhile, _ref$createOptionPosi = _ref.createOptionPosition, createOptionPosition = _ref$createOptionPosi === void 0 ? "last" : _ref$createOptionPosi, _ref$formatCreateLabe = _ref.formatCreateLabel, formatCreateLabel2 = _ref$formatCreateLabe === void 0 ? builtins.formatCreateLabel : _ref$formatCreateLabe, _ref$isValidNewOption = _ref.isValidNewOption, isValidNewOption2 = _ref$isValidNewOption === void 0 ? builtins.isValidNewOption : _ref$isValidNewOption, _ref$getNewOptionData = _ref.getNewOptionData, getNewOptionData2 = _ref$getNewOptionData === void 0 ? builtins.getNewOptionData : _ref$getNewOptionData, onCreateOption = _ref.onCreateOption, _ref$options = _ref.options, propsOptions = _ref$options === void 0 ? [] : _ref$options, propsOnChange = _ref.onChange, restSelectProps = _objectWithoutProperties(_ref, _excluded);
+  var _restSelectProps$getO = restSelectProps.getOptionValue, getOptionValue$1$1 = _restSelectProps$getO === void 0 ? getOptionValue$1 : _restSelectProps$getO, _restSelectProps$getO2 = restSelectProps.getOptionLabel, getOptionLabel$1$1 = _restSelectProps$getO2 === void 0 ? getOptionLabel$1 : _restSelectProps$getO2, inputValue = restSelectProps.inputValue, isLoading = restSelectProps.isLoading, isMulti = restSelectProps.isMulti, value = restSelectProps.value, name = restSelectProps.name;
+  var newOption = useMemo(function() {
+    return isValidNewOption2(inputValue, cleanValue(value), propsOptions, {
+      getOptionValue: getOptionValue$1$1,
+      getOptionLabel: getOptionLabel$1$1
+    }) ? getNewOptionData2(inputValue, formatCreateLabel2(inputValue)) : void 0;
+  }, [formatCreateLabel2, getNewOptionData2, getOptionLabel$1$1, getOptionValue$1$1, inputValue, isValidNewOption2, propsOptions, value]);
+  var options = useMemo(function() {
+    return (allowCreateWhileLoading || !isLoading) && newOption ? createOptionPosition === "first" ? [newOption].concat(_toConsumableArray(propsOptions)) : [].concat(_toConsumableArray(propsOptions), [newOption]) : propsOptions;
+  }, [allowCreateWhileLoading, createOptionPosition, isLoading, newOption, propsOptions]);
+  var onChange = useCallback(function(newValue, actionMeta) {
+    if (actionMeta.action !== "select-option") {
+      return propsOnChange(newValue, actionMeta);
+    }
+    var valueArray = Array.isArray(newValue) ? newValue : [newValue];
+    if (valueArray[valueArray.length - 1] === newOption) {
+      if (onCreateOption) onCreateOption(inputValue);
+      else {
+        var newOptionData = getNewOptionData2(inputValue, inputValue);
+        var newActionMeta = {
+          action: "create-option",
+          name,
+          option: newOptionData
+        };
+        propsOnChange(valueTernary(isMulti, [].concat(_toConsumableArray(cleanValue(value)), [newOptionData]), newOptionData), newActionMeta);
+      }
+      return;
+    }
+    propsOnChange(newValue, actionMeta);
+  }, [getNewOptionData2, inputValue, isMulti, name, newOption, onCreateOption, propsOnChange, value]);
+  return _objectSpread2(_objectSpread2({}, restSelectProps), {}, {
+    options,
+    onChange
+  });
+}
+export {
+  useCreatable as u
+};

package/dist/node_modules/react-select/dist/useStateManager-7e1e8489.esm.js

@@ -0,0 +1,51 @@
+import _objectSpread2 from "../../@babel/runtime/helpers/esm/objectSpread2.js";
+import _slicedToArray from "../../@babel/runtime/helpers/esm/slicedToArray.js";
+import _objectWithoutProperties from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
+import { useState, useCallback } from "react";
+var _excluded = ["defaultInputValue", "defaultMenuIsOpen", "defaultValue", "inputValue", "menuIsOpen", "onChange", "onInputChange", "onMenuClose", "onMenuOpen", "value"];
+function useStateManager(_ref) {
+  var _ref$defaultInputValu = _ref.defaultInputValue, defaultInputValue = _ref$defaultInputValu === void 0 ? "" : _ref$defaultInputValu, _ref$defaultMenuIsOpe = _ref.defaultMenuIsOpen, defaultMenuIsOpen = _ref$defaultMenuIsOpe === void 0 ? false : _ref$defaultMenuIsOpe, _ref$defaultValue = _ref.defaultValue, defaultValue = _ref$defaultValue === void 0 ? null : _ref$defaultValue, propsInputValue = _ref.inputValue, propsMenuIsOpen = _ref.menuIsOpen, propsOnChange = _ref.onChange, propsOnInputChange = _ref.onInputChange, propsOnMenuClose = _ref.onMenuClose, propsOnMenuOpen = _ref.onMenuOpen, propsValue = _ref.value, restSelectProps = _objectWithoutProperties(_ref, _excluded);
+  var _useState = useState(propsInputValue !== void 0 ? propsInputValue : defaultInputValue), _useState2 = _slicedToArray(_useState, 2), stateInputValue = _useState2[0], setStateInputValue = _useState2[1];
+  var _useState3 = useState(propsMenuIsOpen !== void 0 ? propsMenuIsOpen : defaultMenuIsOpen), _useState4 = _slicedToArray(_useState3, 2), stateMenuIsOpen = _useState4[0], setStateMenuIsOpen = _useState4[1];
+  var _useState5 = useState(propsValue !== void 0 ? propsValue : defaultValue), _useState6 = _slicedToArray(_useState5, 2), stateValue = _useState6[0], setStateValue = _useState6[1];
+  var onChange = useCallback(function(value2, actionMeta) {
+    if (typeof propsOnChange === "function") {
+      propsOnChange(value2, actionMeta);
+    }
+    setStateValue(value2);
+  }, [propsOnChange]);
+  var onInputChange = useCallback(function(value2, actionMeta) {
+    var newValue;
+    if (typeof propsOnInputChange === "function") {
+      newValue = propsOnInputChange(value2, actionMeta);
+    }
+    setStateInputValue(newValue !== void 0 ? newValue : value2);
+  }, [propsOnInputChange]);
+  var onMenuOpen = useCallback(function() {
+    if (typeof propsOnMenuOpen === "function") {
+      propsOnMenuOpen();
+    }
+    setStateMenuIsOpen(true);
+  }, [propsOnMenuOpen]);
+  var onMenuClose = useCallback(function() {
+    if (typeof propsOnMenuClose === "function") {
+      propsOnMenuClose();
+    }
+    setStateMenuIsOpen(false);
+  }, [propsOnMenuClose]);
+  var inputValue = propsInputValue !== void 0 ? propsInputValue : stateInputValue;
+  var menuIsOpen = propsMenuIsOpen !== void 0 ? propsMenuIsOpen : stateMenuIsOpen;
+  var value = propsValue !== void 0 ? propsValue : stateValue;
+  return _objectSpread2(_objectSpread2({}, restSelectProps), {}, {
+    inputValue,
+    menuIsOpen,
+    onChange,
+    onInputChange,
+    onMenuClose,
+    onMenuOpen,
+    value
+  });
+}
+export {
+  useStateManager as u
+};

package/dist/node_modules/react-side-effect/lib/index.js

@@ -0,0 +1,105 @@
+import React__default from "react";
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  function _interopDefault(ex) {
+    return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex;
+  }
+  var React = React__default;
+  var React__default$1 = _interopDefault(React);
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    subClass.__proto__ = superClass;
+  }
+  var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+  function withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {
+    if (typeof reducePropsToState !== "function") {
+      throw new Error("Expected reducePropsToState to be a function.");
+    }
+    if (typeof handleStateChangeOnClient !== "function") {
+      throw new Error("Expected handleStateChangeOnClient to be a function.");
+    }
+    if (typeof mapStateOnServer !== "undefined" && typeof mapStateOnServer !== "function") {
+      throw new Error("Expected mapStateOnServer to either be undefined or a function.");
+    }
+    function getDisplayName(WrappedComponent) {
+      return WrappedComponent.displayName || WrappedComponent.name || "Component";
+    }
+    return function wrap(WrappedComponent) {
+      if (typeof WrappedComponent !== "function") {
+        throw new Error("Expected WrappedComponent to be a React component.");
+      }
+      var mountedInstances = [];
+      var state;
+      function emitChange() {
+        state = reducePropsToState(mountedInstances.map(function(instance) {
+          return instance.props;
+        }));
+        if (SideEffect.canUseDOM) {
+          handleStateChangeOnClient(state);
+        } else if (mapStateOnServer) {
+          state = mapStateOnServer(state);
+        }
+      }
+      var SideEffect = /* @__PURE__ */ (function(_PureComponent) {
+        _inheritsLoose(SideEffect2, _PureComponent);
+        function SideEffect2() {
+          return _PureComponent.apply(this, arguments) || this;
+        }
+        SideEffect2.peek = function peek() {
+          return state;
+        };
+        SideEffect2.rewind = function rewind() {
+          if (SideEffect2.canUseDOM) {
+            throw new Error("You may only call rewind() on the server. Call peek() to read the current state.");
+          }
+          var recordedState = state;
+          state = void 0;
+          mountedInstances = [];
+          return recordedState;
+        };
+        var _proto = SideEffect2.prototype;
+        _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {
+          mountedInstances.push(this);
+          emitChange();
+        };
+        _proto.componentDidUpdate = function componentDidUpdate() {
+          emitChange();
+        };
+        _proto.componentWillUnmount = function componentWillUnmount() {
+          var index = mountedInstances.indexOf(this);
+          mountedInstances.splice(index, 1);
+          emitChange();
+        };
+        _proto.render = function render() {
+          return React__default$1.createElement(WrappedComponent, this.props);
+        };
+        return SideEffect2;
+      })(React.PureComponent);
+      _defineProperty(SideEffect, "displayName", "SideEffect(" + getDisplayName(WrappedComponent) + ")");
+      _defineProperty(SideEffect, "canUseDOM", canUseDOM);
+      return SideEffect;
+    };
+  }
+  lib = withSideEffect;
+  return lib;
+}
+export {
+  requireLib as __require
+};

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

@@ -0,0 +1,248 @@
+import { __exports as arrows } from "../../../_virtual/arrows.js";
+import React__default from "react";
+import { __require as requireClassnames } from "../../classnames/index.js";
+import { __require as requireInnerSliderUtils } from "./utils/innerSliderUtils.js";
+var hasRequiredArrows;
+function requireArrows() {
+  if (hasRequiredArrows) return arrows;
+  hasRequiredArrows = 1;
+  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);
+  }
+  Object.defineProperty(arrows, "__esModule", {
+    value: true
+  });
+  arrows.PrevArrow = arrows.NextArrow = 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 _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 _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 _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 _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(t);
+  }
+  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);
+  }
+  arrows.PrevArrow = /* @__PURE__ */ (function(_React$PureComponent) {
+    _inherits(PrevArrow, _React$PureComponent);
+    var _super = _createSuper(PrevArrow);
+    function PrevArrow() {
+      _classCallCheck(this, PrevArrow);
+      return _super.apply(this, arguments);
+    }
+    _createClass(PrevArrow, [{
+      key: "clickHandler",
+      value: function clickHandler(options, e) {
+        if (e) {
+          e.preventDefault();
+        }
+        this.props.clickHandler(options, e);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var prevClasses = {
+          "slick-arrow": true,
+          "slick-prev": true
+        };
+        var prevHandler = this.clickHandler.bind(this, {
+          message: "previous"
+        });
+        if (!this.props.infinite && (this.props.currentSlide === 0 || this.props.slideCount <= this.props.slidesToShow)) {
+          prevClasses["slick-disabled"] = true;
+          prevHandler = null;
+        }
+        var prevArrowProps = {
+          key: "0",
+          "data-role": "none",
+          className: (0, _classnames["default"])(prevClasses),
+          style: {
+            display: "block"
+          },
+          onClick: prevHandler
+        };
+        var customProps = {
+          currentSlide: this.props.currentSlide,
+          slideCount: this.props.slideCount
+        };
+        var prevArrow;
+        if (this.props.prevArrow) {
+          prevArrow = /* @__PURE__ */ _react["default"].cloneElement(this.props.prevArrow, _objectSpread(_objectSpread({}, prevArrowProps), customProps));
+        } else {
+          prevArrow = /* @__PURE__ */ _react["default"].createElement("button", _extends({
+            key: "0",
+            type: "button"
+          }, prevArrowProps), " ", "Previous");
+        }
+        return prevArrow;
+      }
+    }]);
+    return PrevArrow;
+  })(_react["default"].PureComponent);
+  arrows.NextArrow = /* @__PURE__ */ (function(_React$PureComponent2) {
+    _inherits(NextArrow, _React$PureComponent2);
+    var _super2 = _createSuper(NextArrow);
+    function NextArrow() {
+      _classCallCheck(this, NextArrow);
+      return _super2.apply(this, arguments);
+    }
+    _createClass(NextArrow, [{
+      key: "clickHandler",
+      value: function clickHandler(options, e) {
+        if (e) {
+          e.preventDefault();
+        }
+        this.props.clickHandler(options, e);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var nextClasses = {
+          "slick-arrow": true,
+          "slick-next": true
+        };
+        var nextHandler = this.clickHandler.bind(this, {
+          message: "next"
+        });
+        if (!(0, _innerSliderUtils.canGoNext)(this.props)) {
+          nextClasses["slick-disabled"] = true;
+          nextHandler = null;
+        }
+        var nextArrowProps = {
+          key: "1",
+          "data-role": "none",
+          className: (0, _classnames["default"])(nextClasses),
+          style: {
+            display: "block"
+          },
+          onClick: nextHandler
+        };
+        var customProps = {
+          currentSlide: this.props.currentSlide,
+          slideCount: this.props.slideCount
+        };
+        var nextArrow;
+        if (this.props.nextArrow) {
+          nextArrow = /* @__PURE__ */ _react["default"].cloneElement(this.props.nextArrow, _objectSpread(_objectSpread({}, nextArrowProps), customProps));
+        } else {
+          nextArrow = /* @__PURE__ */ _react["default"].createElement("button", _extends({
+            key: "1",
+            type: "button"
+          }, nextArrowProps), " ", "Next");
+        }
+        return nextArrow;
+      }
+    }]);
+    return NextArrow;
+  })(_react["default"].PureComponent);
+  return arrows;
+}
+export {
+  requireArrows as __require
+};

package/dist/node_modules/react-slick/lib/default-props.js

@@ -0,0 +1,85 @@
+import { __exports as defaultProps } from "../../../_virtual/default-props.js";
+import React__default from "react";
+var hasRequiredDefaultProps;
+function requireDefaultProps() {
+  if (hasRequiredDefaultProps) return defaultProps;
+  hasRequiredDefaultProps = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    exports$1["default"] = void 0;
+    var _react = _interopRequireDefault(React__default);
+    function _interopRequireDefault(e) {
+      return e && e.__esModule ? e : { "default": e };
+    }
+    var defaultProps2 = {
+      accessibility: true,
+      adaptiveHeight: false,
+      afterChange: null,
+      appendDots: function appendDots(dots) {
+        return /* @__PURE__ */ _react["default"].createElement("ul", {
+          style: {
+            display: "block"
+          }
+        }, dots);
+      },
+      arrows: true,
+      autoplay: false,
+      autoplaySpeed: 3e3,
+      beforeChange: null,
+      centerMode: false,
+      centerPadding: "50px",
+      className: "",
+      cssEase: "ease",
+      customPaging: function customPaging(i) {
+        return /* @__PURE__ */ _react["default"].createElement("button", null, i + 1);
+      },
+      dots: false,
+      dotsClass: "slick-dots",
+      draggable: true,
+      easing: "linear",
+      edgeFriction: 0.35,
+      fade: false,
+      focusOnSelect: false,
+      infinite: true,
+      initialSlide: 0,
+      lazyLoad: null,
+      nextArrow: null,
+      onEdge: null,
+      onInit: null,
+      onLazyLoadError: null,
+      onReInit: null,
+      pauseOnDotsHover: false,
+      pauseOnFocus: false,
+      pauseOnHover: true,
+      prevArrow: null,
+      responsive: null,
+      rows: 1,
+      rtl: false,
+      slide: "div",
+      slidesPerRow: 1,
+      slidesToScroll: 1,
+      slidesToShow: 1,
+      speed: 500,
+      swipe: true,
+      swipeEvent: null,
+      swipeToSlide: false,
+      touchMove: true,
+      touchThreshold: 5,
+      useCSS: true,
+      useTransform: true,
+      variableWidth: false,
+      vertical: false,
+      verticalSwiping: false,
+      waitForAnimate: true,
+      asNavFor: null,
+      unslick: false
+    };
+    exports$1["default"] = defaultProps2;
+  })(defaultProps);
+  return defaultProps;
+}
+export {
+  requireDefaultProps as __require
+};