@spothero/ui 13.10.1-beta.0 → 14.0.0-beta.0

package/v2/index-unbundled-cjs/{ImageCarousel-7ccd8f2f.js → ImageCarousel-a6361ff4.js}

@@ -1,12 +1,9 @@
 'use strict';
 
-var index = require('./index-9d5ea07a.js');
+var index = require('./index-fc04c985.js');
 var React = require('react');
 var PropTypes = require('prop-types');
-var IconChevronLeft = require('@spothero/icons/chevron-left');
-var IconChevronRight = require('@spothero/icons/chevron-right');
 require('lodash/merge');
-require('@spothero/utils/environment');
 require('lodash/template');
 require('react-dom');
 
@@ -14,8 +11,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
-var IconChevronLeft__default = /*#__PURE__*/_interopDefaultLegacy(IconChevronLeft);
-var IconChevronRight__default = /*#__PURE__*/_interopDefaultLegacy(IconChevronRight);
 
 // `Array.isArray` method
 // https://tc39.es/ecma262/#sec-array.isarray
@@ -23,7 +18,9 @@ index._export({ target: 'Array', stat: true }, {
   isArray: index.isArray
 });
 
-var isArray$3 = index.path.Array.isArray;
+var isArray$4 = index.path.Array.isArray;
+
+var isArray$3 = isArray$4;
 
 var isArray$2 = isArray$3;
 
@@ -91,7 +88,302 @@ index.defineWellKnownSymbol('unscopables');
 // https://tc39.es/ecma262/#sec-json-@@tostringtag
 index.setToStringTag(index.global_1.JSON, 'JSON', true);
 
-var symbol$3 = index.path.Symbol;
+var symbol$4 = index.path.Symbol;
+
+var iterators = {};
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getDescriptor = index.descriptors && Object.getOwnPropertyDescriptor;
+
+var EXISTS = index.hasOwnProperty_1(FunctionPrototype, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var CONFIGURABLE = EXISTS && (!index.descriptors || (index.descriptors && getDescriptor(FunctionPrototype, 'name').configurable));
+
+var functionName = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+var correctPrototypeGetter = !index.fails(function () {
+  function F() { /* empty */ }
+  F.prototype.constructor = null;
+  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+  return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+var IE_PROTO = index.sharedKey('IE_PROTO');
+var Object$1 = index.global_1.Object;
+var ObjectPrototype = Object$1.prototype;
+
+// `Object.getPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.getprototypeof
+var objectGetPrototypeOf = correctPrototypeGetter ? Object$1.getPrototypeOf : function (O) {
+  var object = index.toObject(O);
+  if (index.hasOwnProperty_1(object, IE_PROTO)) return object[IE_PROTO];
+  var constructor = object.constructor;
+  if (index.isCallable(constructor) && object instanceof constructor) {
+    return constructor.prototype;
+  } return object instanceof Object$1 ? ObjectPrototype : null;
+};
+
+var ITERATOR$4 = index.wellKnownSymbol('iterator');
+var BUGGY_SAFARI_ITERATORS$1 = false;
+
+// `%IteratorPrototype%` object
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype$1, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+/* eslint-disable es/no-array-prototype-keys -- safe */
+if ([].keys) {
+  arrayIterator = [].keys();
+  // Safari 8 has buggy iterators w/o `next`
+  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;
+  else {
+    PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator));
+    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$1 = PrototypeOfArrayIteratorPrototype;
+  }
+}
+
+var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$1 == undefined || index.fails(function () {
+  var test = {};
+  // FF44- legacy iterators case
+  return IteratorPrototype$1[ITERATOR$4].call(test) !== test;
+});
+
+if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$1 = {};
+else IteratorPrototype$1 = index.objectCreate(IteratorPrototype$1);
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!index.isCallable(IteratorPrototype$1[ITERATOR$4])) {
+  index.redefine(IteratorPrototype$1, ITERATOR$4, function () {
+    return this;
+  });
+}
+
+var iteratorsCore = {
+  IteratorPrototype: IteratorPrototype$1,
+  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
+};
+
+var IteratorPrototype = iteratorsCore.IteratorPrototype;
+
+
+
+
+
+var returnThis$1 = function () { return this; };
+
+var createIteratorConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+  var TO_STRING_TAG = NAME + ' Iterator';
+  IteratorConstructor.prototype = index.objectCreate(IteratorPrototype, { next: index.createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+  index.setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
+  iterators[TO_STRING_TAG] = returnThis$1;
+  return IteratorConstructor;
+};
+
+var String$1 = index.global_1.String;
+var TypeError$6 = index.global_1.TypeError;
+
+var aPossiblePrototype = function (argument) {
+  if (typeof argument == 'object' || index.isCallable(argument)) return argument;
+  throw TypeError$6("Can't set " + String$1(argument) + ' as a prototype');
+};
+
+/* eslint-disable no-proto -- safe */
+
+
+
+
+// `Object.setPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.setprototypeof
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+// eslint-disable-next-line es/no-object-setprototypeof -- safe
+Object.setPrototypeOf || ('__proto__' in {} ? function () {
+  var CORRECT_SETTER = false;
+  var test = {};
+  var setter;
+  try {
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    setter = index.functionUncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
+    setter(test, []);
+    CORRECT_SETTER = test instanceof Array;
+  } catch (error) { /* empty */ }
+  return function setPrototypeOf(O, proto) {
+    index.anObject(O);
+    aPossiblePrototype(proto);
+    if (CORRECT_SETTER) setter(O, proto);
+    else O.__proto__ = proto;
+    return O;
+  };
+}() : undefined);
+
+var PROPER_FUNCTION_NAME = functionName.PROPER;
+var BUGGY_SAFARI_ITERATORS = iteratorsCore.BUGGY_SAFARI_ITERATORS;
+var ITERATOR$3 = index.wellKnownSymbol('iterator');
+var KEYS = 'keys';
+var VALUES = 'values';
+var ENTRIES = 'entries';
+
+var returnThis = function () { return this; };
+
+var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+  createIteratorConstructor(IteratorConstructor, NAME, next);
+
+  var getIterationMethod = function (KIND) {
+    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
+    switch (KIND) {
+      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
+      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
+      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
+    } return function () { return new IteratorConstructor(this); };
+  };
+
+  var TO_STRING_TAG = NAME + ' Iterator';
+  var INCORRECT_VALUES_NAME = false;
+  var IterablePrototype = Iterable.prototype;
+  var nativeIterator = IterablePrototype[ITERATOR$3]
+    || IterablePrototype['@@iterator']
+    || DEFAULT && IterablePrototype[DEFAULT];
+  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+  var CurrentIteratorPrototype, methods, KEY;
+
+  // fix native
+  if (anyNativeIterator) {
+    CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable()));
+    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+      // Set @@toStringTag to native iterators
+      index.setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+      iterators[TO_STRING_TAG] = returnThis;
+    }
+  }
+
+  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
+  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+    {
+      INCORRECT_VALUES_NAME = true;
+      defaultIterator = function values() { return index.functionCall(nativeIterator, this); };
+    }
+  }
+
+  // export additional methods
+  if (DEFAULT) {
+    methods = {
+      values: getIterationMethod(VALUES),
+      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+      entries: getIterationMethod(ENTRIES)
+    };
+    if (FORCED) for (KEY in methods) {
+      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+        index.redefine(IterablePrototype, KEY, methods[KEY]);
+      }
+    } else index._export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+  }
+
+  // define iterator
+  if ((FORCED) && IterablePrototype[ITERATOR$3] !== defaultIterator) {
+    index.redefine(IterablePrototype, ITERATOR$3, defaultIterator, { name: DEFAULT });
+  }
+  iterators[NAME] = defaultIterator;
+
+  return methods;
+};
+
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState$3 = index.internalState.set;
+var getInternalState$1 = index.internalState.getterFor(ARRAY_ITERATOR);
+
+// `Array.prototype.entries` method
+// https://tc39.es/ecma262/#sec-array.prototype.entries
+// `Array.prototype.keys` method
+// https://tc39.es/ecma262/#sec-array.prototype.keys
+// `Array.prototype.values` method
+// https://tc39.es/ecma262/#sec-array.prototype.values
+// `Array.prototype[@@iterator]` method
+// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
+// `CreateArrayIterator` internal method
+// https://tc39.es/ecma262/#sec-createarrayiterator
+defineIterator(Array, 'Array', function (iterated, kind) {
+  setInternalState$3(this, {
+    type: ARRAY_ITERATOR,
+    target: index.toIndexedObject(iterated), // target
+    index: 0,                          // next index
+    kind: kind                         // kind
+  });
+// `%ArrayIteratorPrototype%.next` method
+// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
+}, function () {
+  var state = getInternalState$1(this);
+  var target = state.target;
+  var kind = state.kind;
+  var index = state.index++;
+  if (!target || index >= target.length) {
+    state.target = undefined;
+    return { value: undefined, done: true };
+  }
+  if (kind == 'keys') return { value: index, done: false };
+  if (kind == 'values') return { value: target[index], done: false };
+  return { value: [index, target[index]], done: false };
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values%
+// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
+// https://tc39.es/ecma262/#sec-createmappedargumentsobject
+iterators.Arguments = iterators.Array;
+
+// iterable DOM collections
+// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+var domIterables = {
+  CSSRuleList: 0,
+  CSSStyleDeclaration: 0,
+  CSSValueList: 0,
+  ClientRectList: 0,
+  DOMRectList: 0,
+  DOMStringList: 0,
+  DOMTokenList: 1,
+  DataTransferItemList: 0,
+  FileList: 0,
+  HTMLAllCollection: 0,
+  HTMLCollection: 0,
+  HTMLFormElement: 0,
+  HTMLSelectElement: 0,
+  MediaList: 0,
+  MimeTypeArray: 0,
+  NamedNodeMap: 0,
+  NodeList: 1,
+  PaintRequestList: 0,
+  Plugin: 0,
+  PluginArray: 0,
+  SVGLengthList: 0,
+  SVGNumberList: 0,
+  SVGPathSegList: 0,
+  SVGPointList: 0,
+  SVGStringList: 0,
+  SVGTransformList: 0,
+  SourceBufferList: 0,
+  StyleSheetList: 0,
+  TextTrackCueList: 0,
+  TextTrackList: 0,
+  TouchList: 0
+};
+
+var TO_STRING_TAG = index.wellKnownSymbol('toStringTag');
+
+for (var COLLECTION_NAME in domIterables) {
+  var Collection = index.global_1[COLLECTION_NAME];
+  var CollectionPrototype = Collection && Collection.prototype;
+  if (CollectionPrototype && index.classof(CollectionPrototype) !== TO_STRING_TAG) {
+    index.createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+  }
+  iterators[COLLECTION_NAME] = iterators.Array;
+}
+
+var symbol$3 = symbol$4;
 
 var symbol$2 = symbol$3;
 
@@ -174,13 +466,13 @@ var charAt = stringMultibyte.charAt;
 
 
 var STRING_ITERATOR = 'String Iterator';
-var setInternalState = index.internalState.set;
+var setInternalState$2 = index.internalState.set;
 var getInternalState = index.internalState.getterFor(STRING_ITERATOR);
 
 // `String.prototype[@@iterator]` method
 // https://tc39.es/ecma262/#sec-string.prototype-@@iterator
-index.defineIterator(String, 'String', function (iterated) {
-  setInternalState(this, {
+defineIterator(String, 'String', function (iterated) {
+  setInternalState$2(this, {
     type: STRING_ITERATOR,
     string: index.toString_1(iterated),
     index: 0
@@ -200,15 +492,17 @@ index.defineIterator(String, 'String', function (iterated) {
 
 var ITERATOR$2 = index.wellKnownSymbol('iterator');
 
-var getIteratorMethod$3 = function (it) {
+var getIteratorMethod$4 = function (it) {
   if (it != undefined) return index.getMethod(it, ITERATOR$2)
     || index.getMethod(it, '@@iterator')
-    || index.iterators[index.classof(it)];
+    || iterators[index.classof(it)];
 };
 
-var getIteratorMethod_1 = getIteratorMethod$3;
+var getIteratorMethod_1 = getIteratorMethod$4;
 
-var getIteratorMethod$2 = getIteratorMethod_1;
+var getIteratorMethod$3 = getIteratorMethod_1;
+
+var getIteratorMethod$2 = getIteratorMethod$3;
 
 var getIteratorMethod$1 = getIteratorMethod$2;
 
@@ -281,15 +575,17 @@ index._export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
   }
 });
 
-var slice$4 = index.entryVirtual('Array').slice;
+var slice$5 = index.entryVirtual('Array').slice;
 
 var ArrayPrototype$1 = Array.prototype;
 
-var slice$3 = function (it) {
+var slice$4 = function (it) {
   var own = it.slice;
-  return it === ArrayPrototype$1 || (index.objectIsPrototypeOf(ArrayPrototype$1, it) && own === ArrayPrototype$1.slice) ? slice$4 : own;
+  return it === ArrayPrototype$1 || (index.objectIsPrototypeOf(ArrayPrototype$1, it) && own === ArrayPrototype$1.slice) ? slice$5 : own;
 };
 
+var slice$3 = slice$4;
+
 var slice$2 = slice$3;
 
 var slice$1 = slice$2;
@@ -330,15 +626,15 @@ var ArrayPrototype = Array.prototype;
 
 // check on default Array iterator
 var isArrayIteratorMethod = function (it) {
-  return it !== undefined && (index.iterators.Array === it || ArrayPrototype[ITERATOR$1] === it);
+  return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR$1] === it);
 };
 
-var TypeError$1 = index.global_1.TypeError;
+var TypeError$5 = index.global_1.TypeError;
 
 var getIterator = function (argument, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$3(argument) : usingIterator;
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$4(argument) : usingIterator;
   if (index.aCallable(iteratorMethod)) return index.anObject(index.functionCall(iteratorMethod, argument));
-  throw TypeError$1(index.tryToString(argument) + ' is not iterable');
+  throw TypeError$5(index.tryToString(argument) + ' is not iterable');
 };
 
 var Array$1 = index.global_1.Array;
@@ -352,7 +648,7 @@ var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefi
   var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
   var mapping = mapfn !== undefined;
   if (mapping) mapfn = index.functionBindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
-  var iteratorMethod = getIteratorMethod$3(O);
+  var iteratorMethod = getIteratorMethod$4(O);
   var index$1 = 0;
   var length, result, step, iterator, next, value;
   // if the target is not iterable or it's an array with the default iterator - use a simple case
@@ -424,7 +720,9 @@ index._export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
   from: arrayFrom
 });
 
-var from_1$3 = index.path.Array.from;
+var from_1$4 = index.path.Array.from;
+
+var from_1$3 = from_1$4;
 
 var from_1$2 = from_1$3;
 
@@ -2072,18 +2370,643 @@ function useEmblaCarousel(options) {
   return [setViewport, embla];
 }
 
-var _excluded = ["images", "width", "height"];
+var iterator$4 = index.wellKnownSymbolWrapped.f('iterator');
+
+var iterator$3 = iterator$4;
+
+var iterator$2 = iterator$3;
+
+var iterator$1 = iterator$2;
+
+var iterator = iterator$1;
 
-(function () {
-  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
-  enterModule && enterModule(module);
-})();
+function _typeof(obj) {
+  "@babel/helpers - typeof";
 
-var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
-  return a;
+  if (typeof symbol === "function" && typeof iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof symbol === "function" && obj.constructor === symbol && obj !== symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+var redefineAll = function (target, src, options) {
+  for (var key in src) {
+    if (options && options.unsafe && target[key]) target[key] = src[key];
+    else index.redefine(target, key, src[key], options);
+  } return target;
+};
+
+var TypeError$4 = index.global_1.TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = index.functionBindContext(unboundFunction, that);
+  var iterator, iterFn, index$1, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      index.anObject(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod$4(iterable);
+    if (!iterFn) throw TypeError$4(index.tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index$1 = 0, length = index.lengthOfArrayLike(iterable); length > index$1; index$1++) {
+        result = callFn(iterable[index$1]);
+        if (result && index.objectIsPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = iterator.next;
+  while (!(step = index.functionCall(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && index.objectIsPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var TypeError$3 = index.global_1.TypeError;
+
+var anInstance = function (it, Prototype) {
+  if (index.objectIsPrototypeOf(Prototype, it)) return it;
+  throw TypeError$3('Incorrect invocation');
+};
+
+var defineProperty = index.objectDefineProperty.f;
+var forEach = index.arrayIteration.forEach;
+
+
+
+var setInternalState$1 = index.internalState.set;
+var internalStateGetterFor$1 = index.internalState.getterFor;
+
+var collection = function (CONSTRUCTOR_NAME, wrapper, common) {
+  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;
+  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;
+  var ADDER = IS_MAP ? 'set' : 'add';
+  var NativeConstructor = index.global_1[CONSTRUCTOR_NAME];
+  var NativePrototype = NativeConstructor && NativeConstructor.prototype;
+  var exported = {};
+  var Constructor;
+
+  if (!index.descriptors || !index.isCallable(NativeConstructor)
+    || !(IS_WEAK || NativePrototype.forEach && !index.fails(function () { new NativeConstructor().entries().next(); }))
+  ) {
+    // create collection constructor
+    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
+    index.internalMetadata.enable();
+  } else {
+    Constructor = wrapper(function (target, iterable) {
+      setInternalState$1(anInstance(target, Prototype), {
+        type: CONSTRUCTOR_NAME,
+        collection: new NativeConstructor()
+      });
+      if (iterable != undefined) iterate(iterable, target[ADDER], { that: target, AS_ENTRIES: IS_MAP });
+    });
+
+    var Prototype = Constructor.prototype;
+
+    var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME);
+
+    forEach(['add', 'clear', 'delete', 'forEach', 'get', 'has', 'set', 'keys', 'values', 'entries'], function (KEY) {
+      var IS_ADDER = KEY == 'add' || KEY == 'set';
+      if (KEY in NativePrototype && !(IS_WEAK && KEY == 'clear')) {
+        index.createNonEnumerableProperty(Prototype, KEY, function (a, b) {
+          var collection = getInternalState(this).collection;
+          if (!IS_ADDER && IS_WEAK && !index.isObject(a)) return KEY == 'get' ? undefined : false;
+          var result = collection[KEY](a === 0 ? 0 : a, b);
+          return IS_ADDER ? this : result;
+        });
+      }
+    });
+
+    IS_WEAK || defineProperty(Prototype, 'size', {
+      configurable: true,
+      get: function () {
+        return getInternalState(this).collection.size;
+      }
+    });
+  }
+
+  index.setToStringTag(Constructor, CONSTRUCTOR_NAME, false, true);
+
+  exported[CONSTRUCTOR_NAME] = Constructor;
+  index._export({ global: true, forced: true }, exported);
+
+  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
+
+  return Constructor;
+};
+
+var getWeakData = index.internalMetadata.getWeakData;
+
+
+
+
+
+
+
+
+var setInternalState = index.internalState.set;
+var internalStateGetterFor = index.internalState.getterFor;
+var find = index.arrayIteration.find;
+var findIndex = index.arrayIteration.findIndex;
+var splice = index.functionUncurryThis([].splice);
+var id = 0;
+
+// fallback for uncaught frozen keys
+var uncaughtFrozenStore = function (store) {
+  return store.frozen || (store.frozen = new UncaughtFrozenStore());
+};
+
+var UncaughtFrozenStore = function () {
+  this.entries = [];
+};
+
+var findUncaughtFrozen = function (store, key) {
+  return find(store.entries, function (it) {
+    return it[0] === key;
+  });
 };
 
+UncaughtFrozenStore.prototype = {
+  get: function (key) {
+    var entry = findUncaughtFrozen(this, key);
+    if (entry) return entry[1];
+  },
+  has: function (key) {
+    return !!findUncaughtFrozen(this, key);
+  },
+  set: function (key, value) {
+    var entry = findUncaughtFrozen(this, key);
+    if (entry) entry[1] = value;
+    else this.entries.push([key, value]);
+  },
+  'delete': function (key) {
+    var index = findIndex(this.entries, function (it) {
+      return it[0] === key;
+    });
+    if (~index) splice(this.entries, index, 1);
+    return !!~index;
+  }
+};
+
+var collectionWeak = {
+  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
+    var Constructor = wrapper(function (that, iterable) {
+      anInstance(that, Prototype);
+      setInternalState(that, {
+        type: CONSTRUCTOR_NAME,
+        id: id++,
+        frozen: undefined
+      });
+      if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
+    });
+
+    var Prototype = Constructor.prototype;
+
+    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
+
+    var define = function (that, key, value) {
+      var state = getInternalState(that);
+      var data = getWeakData(index.anObject(key), true);
+      if (data === true) uncaughtFrozenStore(state).set(key, value);
+      else data[state.id] = value;
+      return that;
+    };
+
+    redefineAll(Prototype, {
+      // `{ WeakMap, WeakSet }.prototype.delete(key)` methods
+      // https://tc39.es/ecma262/#sec-weakmap.prototype.delete
+      // https://tc39.es/ecma262/#sec-weakset.prototype.delete
+      'delete': function (key) {
+        var state = getInternalState(this);
+        if (!index.isObject(key)) return false;
+        var data = getWeakData(key);
+        if (data === true) return uncaughtFrozenStore(state)['delete'](key);
+        return data && index.hasOwnProperty_1(data, state.id) && delete data[state.id];
+      },
+      // `{ WeakMap, WeakSet }.prototype.has(key)` methods
+      // https://tc39.es/ecma262/#sec-weakmap.prototype.has
+      // https://tc39.es/ecma262/#sec-weakset.prototype.has
+      has: function has(key) {
+        var state = getInternalState(this);
+        if (!index.isObject(key)) return false;
+        var data = getWeakData(key);
+        if (data === true) return uncaughtFrozenStore(state).has(key);
+        return data && index.hasOwnProperty_1(data, state.id);
+      }
+    });
+
+    redefineAll(Prototype, IS_MAP ? {
+      // `WeakMap.prototype.get(key)` method
+      // https://tc39.es/ecma262/#sec-weakmap.prototype.get
+      get: function get(key) {
+        var state = getInternalState(this);
+        if (index.isObject(key)) {
+          var data = getWeakData(key);
+          if (data === true) return uncaughtFrozenStore(state).get(key);
+          return data ? data[state.id] : undefined;
+        }
+      },
+      // `WeakMap.prototype.set(key, value)` method
+      // https://tc39.es/ecma262/#sec-weakmap.prototype.set
+      set: function set(key, value) {
+        return define(this, key, value);
+      }
+    } : {
+      // `WeakSet.prototype.add(value)` method
+      // https://tc39.es/ecma262/#sec-weakset.prototype.add
+      add: function add(value) {
+        return define(this, value, true);
+      }
+    });
+
+    return Constructor;
+  }
+};
+
+var enforceInternalState = index.internalState.enforce;
+
+
+var IS_IE11 = !index.global_1.ActiveXObject && 'ActiveXObject' in index.global_1;
+var InternalWeakMap;
+
+var wrapper = function (init) {
+  return function WeakMap() {
+    return init(this, arguments.length ? arguments[0] : undefined);
+  };
+};
+
+// `WeakMap` constructor
+// https://tc39.es/ecma262/#sec-weakmap-constructor
+var $WeakMap = collection('WeakMap', wrapper, collectionWeak);
+
+// IE11 WeakMap frozen keys fix
+// We can't use feature detection because it crash some old IE builds
+// https://github.com/zloirock/core-js/issues/485
+if (index.nativeWeakMap && IS_IE11) {
+  InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);
+  index.internalMetadata.enable();
+  var WeakMapPrototype = $WeakMap.prototype;
+  var nativeDelete = index.functionUncurryThis(WeakMapPrototype['delete']);
+  var nativeHas = index.functionUncurryThis(WeakMapPrototype.has);
+  var nativeGet = index.functionUncurryThis(WeakMapPrototype.get);
+  var nativeSet = index.functionUncurryThis(WeakMapPrototype.set);
+  redefineAll(WeakMapPrototype, {
+    'delete': function (key) {
+      if (index.isObject(key) && !index.objectIsExtensible(key)) {
+        var state = enforceInternalState(this);
+        if (!state.frozen) state.frozen = new InternalWeakMap();
+        return nativeDelete(this, key) || state.frozen['delete'](key);
+      } return nativeDelete(this, key);
+    },
+    has: function has(key) {
+      if (index.isObject(key) && !index.objectIsExtensible(key)) {
+        var state = enforceInternalState(this);
+        if (!state.frozen) state.frozen = new InternalWeakMap();
+        return nativeHas(this, key) || state.frozen.has(key);
+      } return nativeHas(this, key);
+    },
+    get: function get(key) {
+      if (index.isObject(key) && !index.objectIsExtensible(key)) {
+        var state = enforceInternalState(this);
+        if (!state.frozen) state.frozen = new InternalWeakMap();
+        return nativeHas(this, key) ? nativeGet(this, key) : state.frozen.get(key);
+      } return nativeGet(this, key);
+    },
+    set: function set(key, value) {
+      if (index.isObject(key) && !index.objectIsExtensible(key)) {
+        var state = enforceInternalState(this);
+        if (!state.frozen) state.frozen = new InternalWeakMap();
+        nativeHas(this, key) ? nativeSet(this, key, value) : state.frozen.set(key, value);
+      } else nativeSet(this, key, value);
+      return this;
+    }
+  });
+}
+
+var weakMap$4 = index.path.WeakMap;
+
+var weakMap$3 = weakMap$4;
+
+var weakMap$2 = weakMap$3;
+
+// `Map.prototype.emplace` method
+// https://github.com/thumbsupep/proposal-upsert
+var mapEmplace = function emplace(key, handler) {
+  var map = index.anObject(this);
+  var get = index.aCallable(map.get);
+  var has = index.aCallable(map.has);
+  var set = index.aCallable(map.set);
+  var value = (index.functionCall(has, map, key) && 'update' in handler)
+    ? handler.update(index.functionCall(get, map, key), key, map)
+    : handler.insert(key, map);
+  index.functionCall(set, map, key, value);
+  return value;
+};
+
+// `WeakMap.prototype.emplace` method
+// https://github.com/tc39/proposal-upsert
+index._export({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+  emplace: mapEmplace
+});
+
+var TypeError$2 = index.global_1.TypeError;
+
+// `Assert: IsConstructor(argument) is true`
+var aConstructor = function (argument) {
+  if (index.isConstructor(argument)) return argument;
+  throw TypeError$2(index.tryToString(argument) + ' is not a constructor');
+};
+
+// https://tc39.github.io/proposal-setmap-offrom/
+
+
+
+
+
+
+var push = [].push;
+
+var collectionFrom = function from(source /* , mapFn, thisArg */) {
+  var length = arguments.length;
+  var mapFn = length > 1 ? arguments[1] : undefined;
+  var mapping, array, n, boundFunction;
+  aConstructor(this);
+  mapping = mapFn !== undefined;
+  if (mapping) index.aCallable(mapFn);
+  if (source == undefined) return new this();
+  array = [];
+  if (mapping) {
+    n = 0;
+    boundFunction = index.functionBindContext(mapFn, length > 2 ? arguments[2] : undefined);
+    iterate(source, function (nextItem) {
+      index.functionCall(push, array, boundFunction(nextItem, n++));
+    });
+  } else {
+    iterate(source, push, { that: array });
+  }
+  return new this(array);
+};
+
+// `WeakMap.from` method
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
+index._export({ target: 'WeakMap', stat: true, forced: true }, {
+  from: collectionFrom
+});
+
+// https://tc39.github.io/proposal-setmap-offrom/
+var collectionOf = function of() {
+  return new this(index.arraySlice(arguments));
+};
+
+// `WeakMap.of` method
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
+index._export({ target: 'WeakMap', stat: true, forced: true }, {
+  of: collectionOf
+});
+
+// https://github.com/tc39/collection-methods
+var collectionDeleteAll = function deleteAll(/* ...elements */) {
+  var collection = index.anObject(this);
+  var remover = index.aCallable(collection['delete']);
+  var allDeleted = true;
+  var wasDeleted;
+  for (var k = 0, len = arguments.length; k < len; k++) {
+    wasDeleted = index.functionCall(remover, collection, arguments[k]);
+    allDeleted = allDeleted && wasDeleted;
+  }
+  return !!allDeleted;
+};
+
+// `WeakMap.prototype.deleteAll` method
+// https://github.com/tc39/proposal-collection-methods
+index._export({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+  deleteAll: collectionDeleteAll
+});
+
+var TypeError$1 = index.global_1.TypeError;
+
+// `Map.prototype.upsert` method
+// https://github.com/thumbsupep/proposal-upsert
+var mapUpsert = function upsert(key, updateFn /* , insertFn */) {
+  var map = index.anObject(this);
+  var get = index.aCallable(map.get);
+  var has = index.aCallable(map.has);
+  var set = index.aCallable(map.set);
+  var insertFn = arguments.length > 2 ? arguments[2] : undefined;
+  var value;
+  if (!index.isCallable(updateFn) && !index.isCallable(insertFn)) {
+    throw TypeError$1('At least one callback required');
+  }
+  if (index.functionCall(has, map, key)) {
+    value = index.functionCall(get, map, key);
+    if (index.isCallable(updateFn)) {
+      value = updateFn(value);
+      index.functionCall(set, map, key, value);
+    }
+  } else if (index.isCallable(insertFn)) {
+    value = insertFn();
+    index.functionCall(set, map, key, value);
+  } return value;
+};
+
+// TODO: remove from `core-js@4`
+
+
+
+// `WeakMap.prototype.upsert` method (replaced by `WeakMap.prototype.emplace`)
+// https://github.com/tc39/proposal-upsert
+index._export({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+  upsert: mapUpsert
+});
+
+// TODO: remove from `core-js@4`
+
+
+var weakMap$1 = weakMap$2;
+
+var weakMap = weakMap$1;
+
+var getOwnPropertyDescriptor$2 = index.getOwnPropertyDescriptor;
+
+var getOwnPropertyDescriptor$1 = getOwnPropertyDescriptor$2;
+
+var getOwnPropertyDescriptor = getOwnPropertyDescriptor$1;
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof weakMap !== "function") return null;
+  var cacheBabelInterop = new weakMap();
+  var cacheNodeInterop = new weakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+    return {
+      "default": obj
+    };
+  }
+
+  var cache = _getRequireWildcardCache(nodeInterop);
+
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+
+  var newObj = {};
+  var hasPropertyDescriptor = index.defineProperty && getOwnPropertyDescriptor;
+
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? getOwnPropertyDescriptor(obj, key) : null;
+
+      if (desc && (desc.get || desc.set)) {
+        index.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+
+  newObj["default"] = obj;
+
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+
+  return newObj;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+
+var ChevronLeft = index.createCommonjsModule(function (module, exports) {
+
+
+
+
+
+
+
+index.defineProperty$1(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(index._extends);
+
+var React = _interopRequireWildcard(React__default['default']);
+
+function SvgChevronLeft(props, svgRef) {
+  return /*#__PURE__*/React.createElement("svg", (0, _extends2.default)({}, props, {
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "Icon ".concat(props.className ? props.className : ''),
+    ref: svgRef
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M199.5 480L762.8 10.5c21.3-17.1 51.2-12.8 64 8.5 17.1 25.6 12.8 55.5-8.5 68.3L306.1 514.1l516.4 426.8c21.3 17.1 25.6 42.7 8.5 64-17.1 21.3-42.7 25.6-64 8.5L199.5 556.8c-12.8-8.5-17.1-21.3-17.1-38.4 0-17.1 4.2-29.9 17.1-38.4z"
+  }));
+}
+
+var ForwardRef = React.forwardRef(SvgChevronLeft);
+var _default = ForwardRef;
+exports.default = _default;
+});
+
+index.unwrapExports(ChevronLeft);
+
+var chevronLeft = ChevronLeft;
+
+var ChevronRight = index.createCommonjsModule(function (module, exports) {
+
+
+
+
+
+
+
+index.defineProperty$1(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(index._extends);
+
+var React = _interopRequireWildcard(React__default['default']);
+
+function SvgChevronRight(props, svgRef) {
+  return /*#__PURE__*/React.createElement("svg", (0, _extends2.default)({}, props, {
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "Icon ".concat(props.className ? props.className : ''),
+    ref: svgRef
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M841.6 518.4c0 17.1-4.3 29.9-17.1 38.4L257 1013.4c-21.3 17.1-46.9 12.8-64-8.5s-12.8-46.9 8.5-64l516.4-426.8L205.7 87.4c-21.3-12.8-25.6-42.7-8.5-68.3 12.8-21.3 42.7-25.6 64-8.5l563.3 469.5c12.9 8.5 17.1 21.3 17.1 38.3z"
+  }));
+}
+
+var ForwardRef = React.forwardRef(SvgChevronRight);
+var _default = ForwardRef;
+exports.default = _default;
+});
+
+index.unwrapExports(ChevronRight);
+
+var chevronRight = ChevronRight;
+
+var _s = $RefreshSig$();
+
+var _excluded = ["images", "width", "height"];
+
 var ImageCarousel = function ImageCarousel(_ref) {
+  _s();
+
   var images = _ref.images,
       width = _ref.width,
       height = _ref.height,
@@ -2167,7 +3090,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
       src: image.src,
       alt: image.alt
     })));
-  }))), /*#__PURE__*/React__default['default'].createElement(index._default, {
+  }))), /*#__PURE__*/React__default['default'].createElement(index.Button, {
     onClick: scrollPrev,
     width: "16",
     height: "100%",
@@ -2191,7 +3114,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
     borderRadius: "50%",
     bgColor: "black",
     opacity: "0.6"
-  }, /*#__PURE__*/React__default['default'].createElement(IconChevronLeft__default['default'], null))), /*#__PURE__*/React__default['default'].createElement(index._default, {
+  }, /*#__PURE__*/React__default['default'].createElement(chevronLeft, null))), /*#__PURE__*/React__default['default'].createElement(index.Button, {
     onClick: scrollNext,
     width: "16",
     height: "100%",
@@ -2215,7 +3138,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
     borderRadius: "50%",
     bgColor: "black",
     opacity: "0.6"
-  }, /*#__PURE__*/React__default['default'].createElement(IconChevronRight__default['default'], null))), /*#__PURE__*/React__default['default'].createElement(index.Box, {
+  }, /*#__PURE__*/React__default['default'].createElement(chevronRight, null))), /*#__PURE__*/React__default['default'].createElement(index.Box, {
     color: "white",
     borderRadius: "1rem",
     bgColor: "black",
@@ -2230,10 +3153,11 @@ var ImageCarousel = function ImageCarousel(_ref) {
   }, selectedIndex + 1, "/", images.length));
 };
 
-__signature__(ImageCarousel, "useEmblaCarousel{[viewportRef, embla]}\nuseState{[selectedIndex, setSelectedIndex](0)}\nuseCallback{scrollPrev}\nuseCallback{scrollNext}\nuseCallback{onSelect}\nuseEffect{}", function () {
+_s(ImageCarousel, "jxp7tUf1mQMbqWwZGJWfZ+Ibdl8=", false, function () {
   return [useEmblaCarousel];
 });
 
+_c = ImageCarousel;
 ImageCarousel.propTypes = {
   /** Array of images with src and alt */
   images: PropTypes__default['default'].arrayOf(PropTypes__default['default'].shape({
@@ -2247,23 +3171,10 @@ ImageCarousel.propTypes = {
   /** Width of the carousel in rem */
   width: PropTypes__default['default'].number
 };
-var _default = ImageCarousel;
 
-(function () {
-  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+var _c;
 
-  if (!reactHotLoader) {
-    return;
-  }
-
-  reactHotLoader.register(ImageCarousel, "ImageCarousel", "/tmp/build/d4767a07/beta-pr/src/v2/components/ImageCarousel/ImageCarousel.jsx");
-  reactHotLoader.register(_default, "default", "/tmp/build/d4767a07/beta-pr/src/v2/components/ImageCarousel/ImageCarousel.jsx");
-})();
+$RefreshReg$(_c, "ImageCarousel");
 
-(function () {
-  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
-  leaveModule && leaveModule(module);
-})();
-
-exports.default = _default;
-//# sourceMappingURL=ImageCarousel-7ccd8f2f.js.map
+exports.default = ImageCarousel;
+//# sourceMappingURL=ImageCarousel-a6361ff4.js.map