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

package/v2/index-unbundled-esm/{ImageCarousel-fbb24dbe.js → ImageCarousel-3b5e450a.js}

@@ -1,20 +1,19 @@
-import { _ as _export, i as isArray$4, p as path, d as defineWellKnownSymbol, s as setToStringTag, g as global_1, f as functionUncurryThis, t as toString_1, r as requireObjectCoercible, a as toIntegerOrInfinity, b as internalState, c as defineIterator, w as wellKnownSymbol, e as getMethod, h as iterators, j as classof, k as arrayMethodHasSpeciesSupport, l as toIndexedObject, m as lengthOfArrayLike, n as isConstructor, o as isObject, q as arraySlice, u as createProperty, v as toAbsoluteIndex, x as entryVirtual, y as objectIsPrototypeOf, z as anObject, A as functionCall, B as aCallable, C as tryToString, D as toObject, E as functionBindContext, F as _objectWithoutProperties, G as Box, H as _extends$1, I as map$1, J as concat, K as _default$1 } from './index-23e28656.js';
+import { _ as _export, i as isArray$5, p as path, d as defineWellKnownSymbol, s as setToStringTag, g as global_1, h as hasOwnProperty_1, a as descriptors, f as fails, b as sharedKey, t as toObject, c as isCallable, w as wellKnownSymbol, o as objectCreate, r as redefine, e as createPropertyDescriptor, j as functionUncurryThis, k as anObject, l as functionCall, m as internalState, n as toIndexedObject, q as classof, u as createNonEnumerableProperty, v as toString_1, x as requireObjectCoercible, y as toIntegerOrInfinity, z as getMethod, A as arrayMethodHasSpeciesSupport, B as lengthOfArrayLike, C as isConstructor, D as isObject, E as arraySlice, F as createProperty, G as toAbsoluteIndex, H as entryVirtual, I as objectIsPrototypeOf, J as aCallable, K as tryToString, L as functionBindContext, M as wellKnownSymbolWrapped, N as internalMetadata, O as objectDefineProperty, P as arrayIteration, Q as nativeWeakMap, R as objectIsExtensible, S as getOwnPropertyDescriptor$3, T as defineProperty$1, U as createCommonjsModule, V as defineProperty$2, W as _extends$1, X as unwrapExports, Y as _objectWithoutProperties, Z as Box, $ as map$1, a0 as concat, a1 as Button } from './index-0a927912.js';
 import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
 import PropTypes from 'prop-types';
-import IconChevronLeft from '@spothero/icons/chevron-left';
-import IconChevronRight from '@spothero/icons/chevron-right';
 import 'lodash/merge';
-import '@spothero/utils/environment';
 import 'lodash/template';
 import 'react-dom';
 
 // `Array.isArray` method
 // https://tc39.es/ecma262/#sec-array.isarray
 _export({ target: 'Array', stat: true }, {
-  isArray: isArray$4
+  isArray: isArray$5
 });
 
-var isArray$3 = path.Array.isArray;
+var isArray$4 = path.Array.isArray;
+
+var isArray$3 = isArray$4;
 
 var isArray$2 = isArray$3;
 
@@ -82,7 +81,302 @@ defineWellKnownSymbol('unscopables');
 // https://tc39.es/ecma262/#sec-json-@@tostringtag
 setToStringTag(global_1.JSON, 'JSON', true);
 
-var symbol$3 = path.Symbol;
+var symbol$4 = path.Symbol;
+
+var iterators = {};
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getDescriptor = descriptors && Object.getOwnPropertyDescriptor;
+
+var EXISTS = hasOwnProperty_1(FunctionPrototype, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var CONFIGURABLE = EXISTS && (!descriptors || (descriptors && getDescriptor(FunctionPrototype, 'name').configurable));
+
+var functionName = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+var correctPrototypeGetter = !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 = sharedKey('IE_PROTO');
+var Object$1 = 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 = toObject(O);
+  if (hasOwnProperty_1(object, IE_PROTO)) return object[IE_PROTO];
+  var constructor = object.constructor;
+  if (isCallable(constructor) && object instanceof constructor) {
+    return constructor.prototype;
+  } return object instanceof Object$1 ? ObjectPrototype : null;
+};
+
+var ITERATOR$4 = 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 || 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 = objectCreate(IteratorPrototype$1);
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!isCallable(IteratorPrototype$1[ITERATOR$4])) {
+  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 = objectCreate(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
+  iterators[TO_STRING_TAG] = returnThis$1;
+  return IteratorConstructor;
+};
+
+var String$1 = global_1.String;
+var TypeError$6 = global_1.TypeError;
+
+var aPossiblePrototype = function (argument) {
+  if (typeof argument == 'object' || 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 = functionUncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
+    setter(test, []);
+    CORRECT_SETTER = test instanceof Array;
+  } catch (error) { /* empty */ }
+  return function setPrototypeOf(O, proto) {
+    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 = 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
+      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 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)) {
+        redefine(IterablePrototype, KEY, methods[KEY]);
+      }
+    } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+  }
+
+  // define iterator
+  if ((FORCED) && IterablePrototype[ITERATOR$3] !== defaultIterator) {
+    redefine(IterablePrototype, ITERATOR$3, defaultIterator, { name: DEFAULT });
+  }
+  iterators[NAME] = defaultIterator;
+
+  return methods;
+};
+
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState$3 = internalState.set;
+var getInternalState$1 = 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: 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 = wellKnownSymbol('toStringTag');
+
+for (var COLLECTION_NAME in domIterables) {
+  var Collection = global_1[COLLECTION_NAME];
+  var CollectionPrototype = Collection && Collection.prototype;
+  if (CollectionPrototype && classof(CollectionPrototype) !== TO_STRING_TAG) {
+    createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+  }
+  iterators[COLLECTION_NAME] = iterators.Array;
+}
+
+var symbol$3 = symbol$4;
 
 var symbol$2 = symbol$3;
 
@@ -165,13 +459,13 @@ var charAt = stringMultibyte.charAt;
 
 
 var STRING_ITERATOR = 'String Iterator';
-var setInternalState = internalState.set;
+var setInternalState$2 = internalState.set;
 var getInternalState = internalState.getterFor(STRING_ITERATOR);
 
 // `String.prototype[@@iterator]` method
 // https://tc39.es/ecma262/#sec-string.prototype-@@iterator
 defineIterator(String, 'String', function (iterated) {
-  setInternalState(this, {
+  setInternalState$2(this, {
     type: STRING_ITERATOR,
     string: toString_1(iterated),
     index: 0
@@ -191,15 +485,17 @@ defineIterator(String, 'String', function (iterated) {
 
 var ITERATOR$2 = wellKnownSymbol('iterator');
 
-var getIteratorMethod$3 = function (it) {
+var getIteratorMethod$4 = function (it) {
   if (it != undefined) return getMethod(it, ITERATOR$2)
     || getMethod(it, '@@iterator')
     || iterators[classof(it)];
 };
 
-var getIteratorMethod_1 = getIteratorMethod$3;
+var getIteratorMethod_1 = getIteratorMethod$4;
+
+var getIteratorMethod$3 = getIteratorMethod_1;
 
-var getIteratorMethod$2 = getIteratorMethod_1;
+var getIteratorMethod$2 = getIteratorMethod$3;
 
 var getIteratorMethod$1 = getIteratorMethod$2;
 
@@ -252,10 +548,10 @@ _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
     var fin = toAbsoluteIndex(end === undefined ? length : end, length);
     // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
     var Constructor, result, n;
-    if (isArray$4(O)) {
+    if (isArray$5(O)) {
       Constructor = O.constructor;
       // cross-realm fallback
-      if (isConstructor(Constructor) && (Constructor === Array$2 || isArray$4(Constructor.prototype))) {
+      if (isConstructor(Constructor) && (Constructor === Array$2 || isArray$5(Constructor.prototype))) {
         Constructor = undefined;
       } else if (isObject(Constructor)) {
         Constructor = Constructor[SPECIES];
@@ -272,15 +568,17 @@ _export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
   }
 });
 
-var slice$4 = entryVirtual('Array').slice;
+var slice$5 = 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 || (objectIsPrototypeOf(ArrayPrototype$1, it) && own === ArrayPrototype$1.slice) ? slice$4 : own;
+  return it === ArrayPrototype$1 || (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;
@@ -324,12 +622,12 @@ var isArrayIteratorMethod = function (it) {
   return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR$1] === it);
 };
 
-var TypeError$1 = global_1.TypeError;
+var TypeError$5 = 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 (aCallable(iteratorMethod)) return anObject(functionCall(iteratorMethod, argument));
-  throw TypeError$1(tryToString(argument) + ' is not iterable');
+  throw TypeError$5(tryToString(argument) + ' is not iterable');
 };
 
 var Array$1 = global_1.Array;
@@ -343,7 +641,7 @@ var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefi
   var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
   var mapping = mapfn !== undefined;
   if (mapping) mapfn = functionBindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
-  var iteratorMethod = getIteratorMethod$3(O);
+  var iteratorMethod = getIteratorMethod$4(O);
   var index = 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
@@ -415,7 +713,9 @@ _export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
   from: arrayFrom
 });
 
-var from_1$3 = path.Array.from;
+var from_1$4 = path.Array.from;
+
+var from_1$3 = from_1$4;
 
 var from_1$2 = from_1$3;
 
@@ -2063,18 +2363,643 @@ function useEmblaCarousel(options) {
   return [setViewport, embla];
 }
 
-var _excluded = ["images", "width", "height"];
+var iterator$4 = wellKnownSymbolWrapped.f('iterator');
+
+var iterator$3 = iterator$4;
+
+var iterator$2 = iterator$3;
+
+var iterator$1 = iterator$2;
+
+var iterator = iterator$1;
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  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 redefine(target, key, src[key], options);
+  } return target;
+};
+
+var TypeError$4 = 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 = functionBindContext(unboundFunction, that);
+  var iterator, iterFn, index, 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) {
+      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(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && objectIsPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = iterator.next;
+  while (!(step = functionCall(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && objectIsPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var TypeError$3 = global_1.TypeError;
+
+var anInstance = function (it, Prototype) {
+  if (objectIsPrototypeOf(Prototype, it)) return it;
+  throw TypeError$3('Incorrect invocation');
+};
+
+var defineProperty = objectDefineProperty.f;
+var forEach = arrayIteration.forEach;
+
+
+
+var setInternalState$1 = internalState.set;
+var internalStateGetterFor$1 = 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 = global_1[CONSTRUCTOR_NAME];
+  var NativePrototype = NativeConstructor && NativeConstructor.prototype;
+  var exported = {};
+  var Constructor;
+
+  if (!descriptors || !isCallable(NativeConstructor)
+    || !(IS_WEAK || NativePrototype.forEach && !fails(function () { new NativeConstructor().entries().next(); }))
+  ) {
+    // create collection constructor
+    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
+    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')) {
+        createNonEnumerableProperty(Prototype, KEY, function (a, b) {
+          var collection = getInternalState(this).collection;
+          if (!IS_ADDER && IS_WEAK && !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;
+      }
+    });
+  }
+
+  setToStringTag(Constructor, CONSTRUCTOR_NAME, false, true);
+
+  exported[CONSTRUCTOR_NAME] = Constructor;
+  _export({ global: true, forced: true }, exported);
+
+  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
+
+  return Constructor;
+};
+
+var getWeakData = internalMetadata.getWeakData;
+
+
+
+
+
+
+
+
+var setInternalState = internalState.set;
+var internalStateGetterFor = internalState.getterFor;
+var find = arrayIteration.find;
+var findIndex = arrayIteration.findIndex;
+var splice = 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;
+  }
+};
 
-(function () {
-  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
-  enterModule && enterModule(module);
-})();
+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(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 (!isObject(key)) return false;
+        var data = getWeakData(key);
+        if (data === true) return uncaughtFrozenStore(state)['delete'](key);
+        return data && 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 (!isObject(key)) return false;
+        var data = getWeakData(key);
+        if (data === true) return uncaughtFrozenStore(state).has(key);
+        return data && 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 (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 __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
-  return a;
+var enforceInternalState = internalState.enforce;
+
+
+var IS_IE11 = !global_1.ActiveXObject && 'ActiveXObject' in 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 (nativeWeakMap && IS_IE11) {
+  InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);
+  internalMetadata.enable();
+  var WeakMapPrototype = $WeakMap.prototype;
+  var nativeDelete = functionUncurryThis(WeakMapPrototype['delete']);
+  var nativeHas = functionUncurryThis(WeakMapPrototype.has);
+  var nativeGet = functionUncurryThis(WeakMapPrototype.get);
+  var nativeSet = functionUncurryThis(WeakMapPrototype.set);
+  redefineAll(WeakMapPrototype, {
+    'delete': function (key) {
+      if (isObject(key) && !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 (isObject(key) && !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 (isObject(key) && !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 (isObject(key) && !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 = 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 = anObject(this);
+  var get = aCallable(map.get);
+  var has = aCallable(map.has);
+  var set = aCallable(map.set);
+  var value = (functionCall(has, map, key) && 'update' in handler)
+    ? handler.update(functionCall(get, map, key), key, map)
+    : handler.insert(key, map);
+  functionCall(set, map, key, value);
+  return value;
+};
+
+// `WeakMap.prototype.emplace` method
+// https://github.com/tc39/proposal-upsert
+_export({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+  emplace: mapEmplace
+});
+
+var TypeError$2 = global_1.TypeError;
+
+// `Assert: IsConstructor(argument) is true`
+var aConstructor = function (argument) {
+  if (isConstructor(argument)) return argument;
+  throw TypeError$2(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) aCallable(mapFn);
+  if (source == undefined) return new this();
+  array = [];
+  if (mapping) {
+    n = 0;
+    boundFunction = functionBindContext(mapFn, length > 2 ? arguments[2] : undefined);
+    iterate(source, function (nextItem) {
+      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
+_export({ target: 'WeakMap', stat: true, forced: true }, {
+  from: collectionFrom
+});
+
+// https://tc39.github.io/proposal-setmap-offrom/
+var collectionOf = function of() {
+  return new this(arraySlice(arguments));
+};
+
+// `WeakMap.of` method
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
+_export({ target: 'WeakMap', stat: true, forced: true }, {
+  of: collectionOf
+});
+
+// https://github.com/tc39/collection-methods
+var collectionDeleteAll = function deleteAll(/* ...elements */) {
+  var collection = anObject(this);
+  var remover = aCallable(collection['delete']);
+  var allDeleted = true;
+  var wasDeleted;
+  for (var k = 0, len = arguments.length; k < len; k++) {
+    wasDeleted = functionCall(remover, collection, arguments[k]);
+    allDeleted = allDeleted && wasDeleted;
+  }
+  return !!allDeleted;
+};
+
+// `WeakMap.prototype.deleteAll` method
+// https://github.com/tc39/proposal-collection-methods
+_export({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+  deleteAll: collectionDeleteAll
+});
+
+var TypeError$1 = global_1.TypeError;
+
+// `Map.prototype.upsert` method
+// https://github.com/thumbsupep/proposal-upsert
+var mapUpsert = function upsert(key, updateFn /* , insertFn */) {
+  var map = anObject(this);
+  var get = aCallable(map.get);
+  var has = aCallable(map.has);
+  var set = aCallable(map.set);
+  var insertFn = arguments.length > 2 ? arguments[2] : undefined;
+  var value;
+  if (!isCallable(updateFn) && !isCallable(insertFn)) {
+    throw TypeError$1('At least one callback required');
+  }
+  if (functionCall(has, map, key)) {
+    value = functionCall(get, map, key);
+    if (isCallable(updateFn)) {
+      value = updateFn(value);
+      functionCall(set, map, key, value);
+    }
+  } else if (isCallable(insertFn)) {
+    value = insertFn();
+    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
+_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 = getOwnPropertyDescriptor$3;
+
+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 = defineProperty$1 && 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)) {
+        defineProperty$1(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 = createCommonjsModule(function (module, exports) {
+
+
+
+
+
+
+
+defineProperty$2(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(_extends$1);
+
+var React$1 = _interopRequireWildcard(React);
+
+function SvgChevronLeft(props, svgRef) {
+  return /*#__PURE__*/React$1.createElement("svg", (0, _extends2.default)({}, props, {
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "Icon ".concat(props.className ? props.className : ''),
+    ref: svgRef
+  }), /*#__PURE__*/React$1.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$1.forwardRef(SvgChevronLeft);
+var _default = ForwardRef;
+exports.default = _default;
+});
+
+unwrapExports(ChevronLeft);
+
+var chevronLeft = ChevronLeft;
+
+var ChevronRight = createCommonjsModule(function (module, exports) {
+
+
+
+
+
+
+
+defineProperty$2(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(_extends$1);
+
+var React$1 = _interopRequireWildcard(React);
+
+function SvgChevronRight(props, svgRef) {
+  return /*#__PURE__*/React$1.createElement("svg", (0, _extends2.default)({}, props, {
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "Icon ".concat(props.className ? props.className : ''),
+    ref: svgRef
+  }), /*#__PURE__*/React$1.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$1.forwardRef(SvgChevronRight);
+var _default = ForwardRef;
+exports.default = _default;
+});
+
+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,
@@ -2158,7 +3083,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
       src: image.src,
       alt: image.alt
     })));
-  }))), /*#__PURE__*/React.createElement(_default$1, {
+  }))), /*#__PURE__*/React.createElement(Button, {
     onClick: scrollPrev,
     width: "16",
     height: "100%",
@@ -2182,7 +3107,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
     borderRadius: "50%",
     bgColor: "black",
     opacity: "0.6"
-  }, /*#__PURE__*/React.createElement(IconChevronLeft, null))), /*#__PURE__*/React.createElement(_default$1, {
+  }, /*#__PURE__*/React.createElement(chevronLeft, null))), /*#__PURE__*/React.createElement(Button, {
     onClick: scrollNext,
     width: "16",
     height: "100%",
@@ -2206,7 +3131,7 @@ var ImageCarousel = function ImageCarousel(_ref) {
     borderRadius: "50%",
     bgColor: "black",
     opacity: "0.6"
-  }, /*#__PURE__*/React.createElement(IconChevronRight, null))), /*#__PURE__*/React.createElement(Box, {
+  }, /*#__PURE__*/React.createElement(chevronRight, null))), /*#__PURE__*/React.createElement(Box, {
     color: "white",
     borderRadius: "1rem",
     bgColor: "black",
@@ -2221,10 +3146,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.arrayOf(PropTypes.shape({
@@ -2238,23 +3164,10 @@ ImageCarousel.propTypes = {
   /** Width of the carousel in rem */
   width: PropTypes.number
 };
-var _default = ImageCarousel;
-
-(function () {
-  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
-
-  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");
-})();
+var _c;
 
-(function () {
-  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
-  leaveModule && leaveModule(module);
-})();
+$RefreshReg$(_c, "ImageCarousel");
 
-export default _default;
-//# sourceMappingURL=ImageCarousel-fbb24dbe.js.map
+export default ImageCarousel;
+//# sourceMappingURL=ImageCarousel-3b5e450a.js.map