@cleartrip/ct-design-carousal 1.2.0-SNAPSHOT-carouselTest.0 → 1.2.0-SNAPSHOT-CompIntegrationTest.0

package/dist/ct-design-carousal.umd.js

@@ -1,12 +1,30 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react/jsx-runtime'), require('react'), require('react-swipeable'), require('@cleartrip/ct-design-container'), require('@cleartrip/ct-design-icons'), require('@cleartrip/ct-design-use-isomorphic-effect'), require('@cleartrip/ct-design-style-manager'), require('@emotion/styled'), require('@emotion/react')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'react/jsx-runtime', 'react', 'react-swipeable', '@cleartrip/ct-design-container', '@cleartrip/ct-design-icons', '@cleartrip/ct-design-use-isomorphic-effect', '@cleartrip/ct-design-style-manager', '@emotion/styled', '@emotion/react'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CTDesignSystemCarousal = {}, global.jsxRuntime, global.React, global.reactSwipeable, global.ctDesignContainer, global.ctDesignIcons, global.useIsomorphicEffect, global.ctDesignStyleManager, global.styled, global.react));
-})(this, (function (exports, jsxRuntime, React, reactSwipeable, ctDesignContainer, ctDesignIcons, useIsomorphicEffect, ctDesignStyleManager, styled, react) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react/jsx-runtime'), require('react'), require('react-swipeable'), require('@cleartrip/ct-design-container'), require('@cleartrip/ct-design-icons'), require('@cleartrip/ct-design-use-isomorphic-effect'), require('@cleartrip/ct-design-style-manager'), require('@emotion/styled'), require('@emotion/css')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'react/jsx-runtime', 'react', 'react-swipeable', '@cleartrip/ct-design-container', '@cleartrip/ct-design-icons', '@cleartrip/ct-design-use-isomorphic-effect', '@cleartrip/ct-design-style-manager', '@emotion/styled', '@emotion/css'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CTDesignSystemCarousal = {}, global.jsxRuntime, global.React, global.reactSwipeable, global.ctDesignContainer, global.ctDesignIcons, global.useIsomorphicEffect, global.ctDesignStyleManager, global.styled, global.css$1));
+})(this, (function (exports, jsxRuntime, React, reactSwipeable, ctDesignContainer, ctDesignIcons, useIsomorphicEffect, ctDesignStyleManager, styled, css$1) { 'use strict';
 
     function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-    var React__default = /*#__PURE__*/_interopDefault(React);
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var React__namespace = /*#__PURE__*/_interopNamespace(React);
     var useIsomorphicEffect__default = /*#__PURE__*/_interopDefault(useIsomorphicEffect);
     var styled__default = /*#__PURE__*/_interopDefault(styled);
 
@@ -60,6 +78,1862 @@
       return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    var isDevelopment$2 = false;
+
+    /*
+
+    Based off glamor's StyleSheet, thanks Sunil ❤️
+
+    high performance StyleSheet for css-in-js systems
+
+    - uses multiple style tags behind the scenes for millions of rules
+    - uses `insertRule` for appending in production for *much* faster performance
+
+    // usage
+
+    import { StyleSheet } from '@emotion/sheet'
+
+    let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+    styleSheet.insert('#box { border: 1px solid red; }')
+    - appends a css rule into the stylesheet
+
+    styleSheet.flush()
+    - empties the stylesheet of all its contents
+
+    */
+
+    function sheetForTag(tag) {
+      if (tag.sheet) {
+        return tag.sheet;
+      } // this weirdness brought to you by firefox
+
+      /* istanbul ignore next */
+
+      for (var i = 0; i < document.styleSheets.length; i++) {
+        if (document.styleSheets[i].ownerNode === tag) {
+          return document.styleSheets[i];
+        }
+      } // this function should always return with a value
+      // TS can't understand it though so we make it stop complaining here
+
+      return undefined;
+    }
+    function createStyleElement(options) {
+      var tag = document.createElement('style');
+      tag.setAttribute('data-emotion', options.key);
+      if (options.nonce !== undefined) {
+        tag.setAttribute('nonce', options.nonce);
+      }
+      tag.appendChild(document.createTextNode(''));
+      tag.setAttribute('data-s', '');
+      return tag;
+    }
+    var StyleSheet = /*#__PURE__*/function () {
+      // Using Node instead of HTMLElement since container may be a ShadowRoot
+      function StyleSheet(options) {
+        var _this = this;
+        this._insertTag = function (tag) {
+          var before;
+          if (_this.tags.length === 0) {
+            if (_this.insertionPoint) {
+              before = _this.insertionPoint.nextSibling;
+            } else if (_this.prepend) {
+              before = _this.container.firstChild;
+            } else {
+              before = _this.before;
+            }
+          } else {
+            before = _this.tags[_this.tags.length - 1].nextSibling;
+          }
+          _this.container.insertBefore(tag, before);
+          _this.tags.push(tag);
+        };
+        this.isSpeedy = options.speedy === undefined ? !isDevelopment$2 : options.speedy;
+        this.tags = [];
+        this.ctr = 0;
+        this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+        this.key = options.key;
+        this.container = options.container;
+        this.prepend = options.prepend;
+        this.insertionPoint = options.insertionPoint;
+        this.before = null;
+      }
+      var _proto = StyleSheet.prototype;
+      _proto.hydrate = function hydrate(nodes) {
+        nodes.forEach(this._insertTag);
+      };
+      _proto.insert = function insert(rule) {
+        // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+        // it's 1 in dev because we insert source maps that map a single rule to a location
+        // and you can only have one source map per style tag
+        if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+          this._insertTag(createStyleElement(this));
+        }
+        var tag = this.tags[this.tags.length - 1];
+        if (this.isSpeedy) {
+          var sheet = sheetForTag(tag);
+          try {
+            // this is the ultrafast version, works across browsers
+            // the big drawback is that the css won't be editable in devtools
+            sheet.insertRule(rule, sheet.cssRules.length);
+          } catch (e) {}
+        } else {
+          tag.appendChild(document.createTextNode(rule));
+        }
+        this.ctr++;
+      };
+      _proto.flush = function flush() {
+        this.tags.forEach(function (tag) {
+          var _tag$parentNode;
+          return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
+        });
+        this.tags = [];
+        this.ctr = 0;
+      };
+      return StyleSheet;
+    }();
+
+    var stylisExports = {};
+    var stylis = {
+      get exports(){ return stylisExports; },
+      set exports(v){ stylisExports = v; },
+    };
+
+    (function (module, exports) {
+      (function (e, r) {
+        r(exports) ;
+      })(this, function (e) {
+
+        var r = "-ms-";
+        var a = "-moz-";
+        var c = "-webkit-";
+        var n = "comm";
+        var t = "rule";
+        var s = "decl";
+        var i = "@page";
+        var u = "@media";
+        var o = "@import";
+        var f = "@charset";
+        var l = "@viewport";
+        var p = "@supports";
+        var h = "@document";
+        var v = "@namespace";
+        var d = "@keyframes";
+        var b = "@font-face";
+        var w = "@counter-style";
+        var m = "@font-feature-values";
+        var g = "@layer";
+        var k = Math.abs;
+        var $ = String.fromCharCode;
+        var x = Object.assign;
+        function E(e, r) {
+          return M(e, 0) ^ 45 ? (((r << 2 ^ M(e, 0)) << 2 ^ M(e, 1)) << 2 ^ M(e, 2)) << 2 ^ M(e, 3) : 0;
+        }
+        function y(e) {
+          return e.trim();
+        }
+        function T(e, r) {
+          return (e = r.exec(e)) ? e[0] : e;
+        }
+        function A(e, r, a) {
+          return e.replace(r, a);
+        }
+        function O(e, r) {
+          return e.indexOf(r);
+        }
+        function M(e, r) {
+          return e.charCodeAt(r) | 0;
+        }
+        function C(e, r, a) {
+          return e.slice(r, a);
+        }
+        function R(e) {
+          return e.length;
+        }
+        function S(e) {
+          return e.length;
+        }
+        function z(e, r) {
+          return r.push(e), e;
+        }
+        function N(e, r) {
+          return e.map(r).join("");
+        }
+        e.line = 1;
+        e.column = 1;
+        e.length = 0;
+        e.position = 0;
+        e.character = 0;
+        e.characters = "";
+        function P(r, a, c, n, t, s, i) {
+          return {
+            value: r,
+            root: a,
+            parent: c,
+            type: n,
+            props: t,
+            children: s,
+            line: e.line,
+            column: e.column,
+            length: i,
+            return: ""
+          };
+        }
+        function j(e, r) {
+          return x(P("", null, null, "", null, null, 0), e, {
+            length: -e.length
+          }, r);
+        }
+        function U() {
+          return e.character;
+        }
+        function _() {
+          e.character = e.position > 0 ? M(e.characters, --e.position) : 0;
+          if (e.column--, e.character === 10) e.column = 1, e.line--;
+          return e.character;
+        }
+        function F() {
+          e.character = e.position < e.length ? M(e.characters, e.position++) : 0;
+          if (e.column++, e.character === 10) e.column = 1, e.line++;
+          return e.character;
+        }
+        function I() {
+          return M(e.characters, e.position);
+        }
+        function L() {
+          return e.position;
+        }
+        function D(r, a) {
+          return C(e.characters, r, a);
+        }
+        function Y(e) {
+          switch (e) {
+            case 0:
+            case 9:
+            case 10:
+            case 13:
+            case 32:
+              return 5;
+            case 33:
+            case 43:
+            case 44:
+            case 47:
+            case 62:
+            case 64:
+            case 126:
+            case 59:
+            case 123:
+            case 125:
+              return 4;
+            case 58:
+              return 3;
+            case 34:
+            case 39:
+            case 40:
+            case 91:
+              return 2;
+            case 41:
+            case 93:
+              return 1;
+          }
+          return 0;
+        }
+        function K(r) {
+          return e.line = e.column = 1, e.length = R(e.characters = r), e.position = 0, [];
+        }
+        function V(r) {
+          return e.characters = "", r;
+        }
+        function W(r) {
+          return y(D(e.position - 1, q(r === 91 ? r + 2 : r === 40 ? r + 1 : r)));
+        }
+        function B(e) {
+          return V(H(K(e)));
+        }
+        function G(r) {
+          while (e.character = I()) if (e.character < 33) F();else break;
+          return Y(r) > 2 || Y(e.character) > 3 ? "" : " ";
+        }
+        function H(r) {
+          while (F()) switch (Y(e.character)) {
+            case 0:
+              z(Q(e.position - 1), r);
+              break;
+            case 2:
+              z(W(e.character), r);
+              break;
+            default:
+              z($(e.character), r);
+          }
+          return r;
+        }
+        function Z(r, a) {
+          while (--a && F()) if (e.character < 48 || e.character > 102 || e.character > 57 && e.character < 65 || e.character > 70 && e.character < 97) break;
+          return D(r, L() + (a < 6 && I() == 32 && F() == 32));
+        }
+        function q(r) {
+          while (F()) switch (e.character) {
+            case r:
+              return e.position;
+            case 34:
+            case 39:
+              if (r !== 34 && r !== 39) q(e.character);
+              break;
+            case 40:
+              if (r === 41) q(r);
+              break;
+            case 92:
+              F();
+              break;
+          }
+          return e.position;
+        }
+        function J(r, a) {
+          while (F()) if (r + e.character === 47 + 10) break;else if (r + e.character === 42 + 42 && I() === 47) break;
+          return "/*" + D(a, e.position - 1) + "*" + $(r === 47 ? r : F());
+        }
+        function Q(r) {
+          while (!Y(I())) F();
+          return D(r, e.position);
+        }
+        function X(e) {
+          return V(ee("", null, null, null, [""], e = K(e), 0, [0], e));
+        }
+        function ee(e, r, a, c, n, t, s, i, u) {
+          var o = 0;
+          var f = 0;
+          var l = s;
+          var p = 0;
+          var h = 0;
+          var v = 0;
+          var d = 1;
+          var b = 1;
+          var w = 1;
+          var m = 0;
+          var g = "";
+          var k = n;
+          var x = t;
+          var E = c;
+          var y = g;
+          while (b) switch (v = m, m = F()) {
+            case 40:
+              if (v != 108 && M(y, l - 1) == 58) {
+                if (O(y += A(W(m), "&", "&\f"), "&\f") != -1) w = -1;
+                break;
+              }
+            case 34:
+            case 39:
+            case 91:
+              y += W(m);
+              break;
+            case 9:
+            case 10:
+            case 13:
+            case 32:
+              y += G(v);
+              break;
+            case 92:
+              y += Z(L() - 1, 7);
+              continue;
+            case 47:
+              switch (I()) {
+                case 42:
+                case 47:
+                  z(ae(J(F(), L()), r, a), u);
+                  break;
+                default:
+                  y += "/";
+              }
+              break;
+            case 123 * d:
+              i[o++] = R(y) * w;
+            case 125 * d:
+            case 59:
+            case 0:
+              switch (m) {
+                case 0:
+                case 125:
+                  b = 0;
+                case 59 + f:
+                  if (w == -1) y = A(y, /\f/g, "");
+                  if (h > 0 && R(y) - l) z(h > 32 ? ce(y + ";", c, a, l - 1) : ce(A(y, " ", "") + ";", c, a, l - 2), u);
+                  break;
+                case 59:
+                  y += ";";
+                default:
+                  z(E = re(y, r, a, o, f, n, i, g, k = [], x = [], l), t);
+                  if (m === 123) if (f === 0) ee(y, r, E, E, k, t, l, i, x);else switch (p === 99 && M(y, 3) === 110 ? 100 : p) {
+                    case 100:
+                    case 108:
+                    case 109:
+                    case 115:
+                      ee(e, E, E, c && z(re(e, E, E, 0, 0, n, i, g, n, k = [], l), x), n, x, l, i, c ? k : x);
+                      break;
+                    default:
+                      ee(y, E, E, E, [""], x, 0, i, x);
+                  }
+              }
+              o = f = h = 0, d = w = 1, g = y = "", l = s;
+              break;
+            case 58:
+              l = 1 + R(y), h = v;
+            default:
+              if (d < 1) if (m == 123) --d;else if (m == 125 && d++ == 0 && _() == 125) continue;
+              switch (y += $(m), m * d) {
+                case 38:
+                  w = f > 0 ? 1 : (y += "\f", -1);
+                  break;
+                case 44:
+                  i[o++] = (R(y) - 1) * w, w = 1;
+                  break;
+                case 64:
+                  if (I() === 45) y += W(F());
+                  p = I(), f = l = R(g = y += Q(L())), m++;
+                  break;
+                case 45:
+                  if (v === 45 && R(y) == 2) d = 0;
+              }
+          }
+          return t;
+        }
+        function re(e, r, a, c, n, s, i, u, o, f, l) {
+          var p = n - 1;
+          var h = n === 0 ? s : [""];
+          var v = S(h);
+          for (var d = 0, b = 0, w = 0; d < c; ++d) for (var m = 0, g = C(e, p + 1, p = k(b = i[d])), $ = e; m < v; ++m) if ($ = y(b > 0 ? h[m] + " " + g : A(g, /&\f/g, h[m]))) o[w++] = $;
+          return P(e, r, a, n === 0 ? t : u, o, f, l);
+        }
+        function ae(e, r, a) {
+          return P(e, r, a, n, $(U()), C(e, 2, -2), 0);
+        }
+        function ce(e, r, a, c) {
+          return P(e, r, a, s, C(e, 0, c), C(e, c + 1, -1), c);
+        }
+        function ne(e, n, t) {
+          switch (E(e, n)) {
+            case 5103:
+              return c + "print-" + e + e;
+            case 5737:
+            case 4201:
+            case 3177:
+            case 3433:
+            case 1641:
+            case 4457:
+            case 2921:
+            case 5572:
+            case 6356:
+            case 5844:
+            case 3191:
+            case 6645:
+            case 3005:
+            case 6391:
+            case 5879:
+            case 5623:
+            case 6135:
+            case 4599:
+            case 4855:
+            case 4215:
+            case 6389:
+            case 5109:
+            case 5365:
+            case 5621:
+            case 3829:
+              return c + e + e;
+            case 4789:
+              return a + e + e;
+            case 5349:
+            case 4246:
+            case 4810:
+            case 6968:
+            case 2756:
+              return c + e + a + e + r + e + e;
+            case 5936:
+              switch (M(e, n + 11)) {
+                case 114:
+                  return c + e + r + A(e, /[svh]\w+-[tblr]{2}/, "tb") + e;
+                case 108:
+                  return c + e + r + A(e, /[svh]\w+-[tblr]{2}/, "tb-rl") + e;
+                case 45:
+                  return c + e + r + A(e, /[svh]\w+-[tblr]{2}/, "lr") + e;
+              }
+            case 6828:
+            case 4268:
+            case 2903:
+              return c + e + r + e + e;
+            case 6165:
+              return c + e + r + "flex-" + e + e;
+            case 5187:
+              return c + e + A(e, /(\w+).+(:[^]+)/, c + "box-$1$2" + r + "flex-$1$2") + e;
+            case 5443:
+              return c + e + r + "flex-item-" + A(e, /flex-|-self/g, "") + (!T(e, /flex-|baseline/) ? r + "grid-row-" + A(e, /flex-|-self/g, "") : "") + e;
+            case 4675:
+              return c + e + r + "flex-line-pack" + A(e, /align-content|flex-|-self/g, "") + e;
+            case 5548:
+              return c + e + r + A(e, "shrink", "negative") + e;
+            case 5292:
+              return c + e + r + A(e, "basis", "preferred-size") + e;
+            case 6060:
+              return c + "box-" + A(e, "-grow", "") + c + e + r + A(e, "grow", "positive") + e;
+            case 4554:
+              return c + A(e, /([^-])(transform)/g, "$1" + c + "$2") + e;
+            case 6187:
+              return A(A(A(e, /(zoom-|grab)/, c + "$1"), /(image-set)/, c + "$1"), e, "") + e;
+            case 5495:
+            case 3959:
+              return A(e, /(image-set\([^]*)/, c + "$1" + "$`$1");
+            case 4968:
+              return A(A(e, /(.+:)(flex-)?(.*)/, c + "box-pack:$3" + r + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + c + e + e;
+            case 4200:
+              if (!T(e, /flex-|baseline/)) return r + "grid-column-align" + C(e, n) + e;
+              break;
+            case 2592:
+            case 3360:
+              return r + A(e, "template-", "") + e;
+            case 4384:
+            case 3616:
+              if (t && t.some(function (e, r) {
+                return n = r, T(e.props, /grid-\w+-end/);
+              })) {
+                return ~O(e + (t = t[n].value), "span") ? e : r + A(e, "-start", "") + e + r + "grid-row-span:" + (~O(t, "span") ? T(t, /\d+/) : +T(t, /\d+/) - +T(e, /\d+/)) + ";";
+              }
+              return r + A(e, "-start", "") + e;
+            case 4896:
+            case 4128:
+              return t && t.some(function (e) {
+                return T(e.props, /grid-\w+-start/);
+              }) ? e : r + A(A(e, "-end", "-span"), "span ", "") + e;
+            case 4095:
+            case 3583:
+            case 4068:
+            case 2532:
+              return A(e, /(.+)-inline(.+)/, c + "$1$2") + e;
+            case 8116:
+            case 7059:
+            case 5753:
+            case 5535:
+            case 5445:
+            case 5701:
+            case 4933:
+            case 4677:
+            case 5533:
+            case 5789:
+            case 5021:
+            case 4765:
+              if (R(e) - 1 - n > 6) switch (M(e, n + 1)) {
+                case 109:
+                  if (M(e, n + 4) !== 45) break;
+                case 102:
+                  return A(e, /(.+:)(.+)-([^]+)/, "$1" + c + "$2-$3" + "$1" + a + (M(e, n + 3) == 108 ? "$3" : "$2-$3")) + e;
+                case 115:
+                  return ~O(e, "stretch") ? ne(A(e, "stretch", "fill-available"), n, t) + e : e;
+              }
+              break;
+            case 5152:
+            case 5920:
+              return A(e, /(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/, function (a, c, n, t, s, i, u) {
+                return r + c + ":" + n + u + (t ? r + c + "-span:" + (s ? i : +i - +n) + u : "") + e;
+              });
+            case 4949:
+              if (M(e, n + 6) === 121) return A(e, ":", ":" + c) + e;
+              break;
+            case 6444:
+              switch (M(e, M(e, 14) === 45 ? 18 : 11)) {
+                case 120:
+                  return A(e, /(.+:)([^;\s!]+)(;|(\s+)?!.+)?/, "$1" + c + (M(e, 14) === 45 ? "inline-" : "") + "box$3" + "$1" + c + "$2$3" + "$1" + r + "$2box$3") + e;
+                case 100:
+                  return A(e, ":", ":" + r) + e;
+              }
+              break;
+            case 5719:
+            case 2647:
+            case 2135:
+            case 3927:
+            case 2391:
+              return A(e, "scroll-", "scroll-snap-") + e;
+          }
+          return e;
+        }
+        function te(e, r) {
+          var a = "";
+          var c = S(e);
+          for (var n = 0; n < c; n++) a += r(e[n], n, e, r) || "";
+          return a;
+        }
+        function se(e, r, a, c) {
+          switch (e.type) {
+            case g:
+              if (e.children.length) break;
+            case o:
+            case s:
+              return e.return = e.return || e.value;
+            case n:
+              return "";
+            case d:
+              return e.return = e.value + "{" + te(e.children, c) + "}";
+            case t:
+              e.value = e.props.join(",");
+          }
+          return R(a = te(e.children, c)) ? e.return = e.value + "{" + a + "}" : "";
+        }
+        function ie(e) {
+          var r = S(e);
+          return function (a, c, n, t) {
+            var s = "";
+            for (var i = 0; i < r; i++) s += e[i](a, c, n, t) || "";
+            return s;
+          };
+        }
+        function ue(e) {
+          return function (r) {
+            if (!r.root) if (r = r.return) e(r);
+          };
+        }
+        function oe(e, n, i, u) {
+          if (e.length > -1) if (!e.return) switch (e.type) {
+            case s:
+              e.return = ne(e.value, e.length, i);
+              return;
+            case d:
+              return te([j(e, {
+                value: A(e.value, "@", "@" + c)
+              })], u);
+            case t:
+              if (e.length) return N(e.props, function (n) {
+                switch (T(n, /(::plac\w+|:read-\w+)/)) {
+                  case ":read-only":
+                  case ":read-write":
+                    return te([j(e, {
+                      props: [A(n, /:(read-\w+)/, ":" + a + "$1")]
+                    })], u);
+                  case "::placeholder":
+                    return te([j(e, {
+                      props: [A(n, /:(plac\w+)/, ":" + c + "input-$1")]
+                    }), j(e, {
+                      props: [A(n, /:(plac\w+)/, ":" + a + "$1")]
+                    }), j(e, {
+                      props: [A(n, /:(plac\w+)/, r + "input-$1")]
+                    })], u);
+                }
+                return "";
+              });
+          }
+        }
+        function fe(e) {
+          switch (e.type) {
+            case t:
+              e.props = e.props.map(function (r) {
+                return N(B(r), function (r, a, c) {
+                  switch (M(r, 0)) {
+                    case 12:
+                      return C(r, 1, R(r));
+                    case 0:
+                    case 40:
+                    case 43:
+                    case 62:
+                    case 126:
+                      return r;
+                    case 58:
+                      if (c[++a] === "global") c[a] = "", c[++a] = "\f" + C(c[a], a = 1, -1);
+                    case 32:
+                      return a === 1 ? "" : r;
+                    default:
+                      switch (a) {
+                        case 0:
+                          e = r;
+                          return S(c) > 1 ? "" : r;
+                        case a = S(c) - 1:
+                        case 2:
+                          return a === 2 ? r + e + e : r + e;
+                        default:
+                          return r;
+                      }
+                  }
+                });
+              });
+          }
+        }
+        e.CHARSET = f;
+        e.COMMENT = n;
+        e.COUNTER_STYLE = w;
+        e.DECLARATION = s;
+        e.DOCUMENT = h;
+        e.FONT_FACE = b;
+        e.FONT_FEATURE_VALUES = m;
+        e.IMPORT = o;
+        e.KEYFRAMES = d;
+        e.LAYER = g;
+        e.MEDIA = u;
+        e.MOZ = a;
+        e.MS = r;
+        e.NAMESPACE = v;
+        e.PAGE = i;
+        e.RULESET = t;
+        e.SUPPORTS = p;
+        e.VIEWPORT = l;
+        e.WEBKIT = c;
+        e.abs = k;
+        e.alloc = K;
+        e.append = z;
+        e.assign = x;
+        e.caret = L;
+        e.char = U;
+        e.charat = M;
+        e.combine = N;
+        e.comment = ae;
+        e.commenter = J;
+        e.compile = X;
+        e.copy = j;
+        e.dealloc = V;
+        e.declaration = ce;
+        e.delimit = W;
+        e.delimiter = q;
+        e.escaping = Z;
+        e.from = $;
+        e.hash = E;
+        e.identifier = Q;
+        e.indexof = O;
+        e.match = T;
+        e.middleware = ie;
+        e.namespace = fe;
+        e.next = F;
+        e.node = P;
+        e.parse = ee;
+        e.peek = I;
+        e.prefix = ne;
+        e.prefixer = oe;
+        e.prev = _;
+        e.replace = A;
+        e.ruleset = re;
+        e.rulesheet = ue;
+        e.serialize = te;
+        e.sizeof = S;
+        e.slice = D;
+        e.stringify = se;
+        e.strlen = R;
+        e.substr = C;
+        e.token = Y;
+        e.tokenize = B;
+        e.tokenizer = H;
+        e.trim = y;
+        e.whitespace = G;
+        Object.defineProperty(e, "__esModule", {
+          value: true
+        });
+      });
+    })(stylis, stylisExports);
+
+    var weakMemoize = function weakMemoize(func) {
+      var cache = new WeakMap();
+      return function (arg) {
+        if (cache.has(arg)) {
+          // Use non-null assertion because we just checked that the cache `has` it
+          // This allows us to remove `undefined` from the return value
+          return cache.get(arg);
+        }
+        var ret = func(arg);
+        cache.set(arg, ret);
+        return ret;
+      };
+    };
+
+    function memoize(fn) {
+      var cache = Object.create(null);
+      return function (arg) {
+        if (cache[arg] === undefined) cache[arg] = fn(arg);
+        return cache[arg];
+      };
+    }
+
+    var isBrowser$3 = typeof document !== 'undefined';
+    var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
+      var previous = 0;
+      var character = 0;
+      while (true) {
+        previous = character;
+        character = stylisExports.peek(); // &\f
+
+        if (previous === 38 && character === 12) {
+          points[index] = 1;
+        }
+        if (stylisExports.token(character)) {
+          break;
+        }
+        stylisExports.next();
+      }
+      return stylisExports.slice(begin, stylisExports.position);
+    };
+    var toRules = function toRules(parsed, points) {
+      // pretend we've started with a comma
+      var index = -1;
+      var character = 44;
+      do {
+        switch (stylisExports.token(character)) {
+          case 0:
+            // &\f
+            if (character === 38 && stylisExports.peek() === 12) {
+              // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
+              // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
+              // and when it should just concatenate the outer and inner selectors
+              // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
+              points[index] = 1;
+            }
+            parsed[index] += identifierWithPointTracking(stylisExports.position - 1, points, index);
+            break;
+          case 2:
+            parsed[index] += stylisExports.delimit(character);
+            break;
+          case 4:
+            // comma
+            if (character === 44) {
+              // colon
+              parsed[++index] = stylisExports.peek() === 58 ? '&\f' : '';
+              points[index] = parsed[index].length;
+              break;
+            }
+
+          // fallthrough
+
+          default:
+            parsed[index] += stylisExports.from(character);
+        }
+      } while (character = stylisExports.next());
+      return parsed;
+    };
+    var getRules = function getRules(value, points) {
+      return stylisExports.dealloc(toRules(stylisExports.alloc(value), points));
+    }; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
+
+    var fixedElements = /* #__PURE__ */new WeakMap();
+    var compat = function compat(element) {
+      if (element.type !== 'rule' || !element.parent ||
+      // positive .length indicates that this rule contains pseudo
+      // negative .length indicates that this rule has been already prefixed
+      element.length < 1) {
+        return;
+      }
+      var value = element.value;
+      var parent = element.parent;
+      var isImplicitRule = element.column === parent.column && element.line === parent.line;
+      while (parent.type !== 'rule') {
+        parent = parent.parent;
+        if (!parent) return;
+      } // short-circuit for the simplest case
+
+      if (element.props.length === 1 && value.charCodeAt(0) !== 58
+      /* colon */ && !fixedElements.get(parent)) {
+        return;
+      } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
+      // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
+
+      if (isImplicitRule) {
+        return;
+      }
+      fixedElements.set(element, true);
+      var points = [];
+      var rules = getRules(value, points);
+      var parentRules = parent.props;
+      for (var i = 0, k = 0; i < rules.length; i++) {
+        for (var j = 0; j < parentRules.length; j++, k++) {
+          element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
+        }
+      }
+    };
+    var removeLabel = function removeLabel(element) {
+      if (element.type === 'decl') {
+        var value = element.value;
+        if (
+        // charcode for l
+        value.charCodeAt(0) === 108 &&
+        // charcode for b
+        value.charCodeAt(2) === 98) {
+          // this ignores label
+          element["return"] = '';
+          element.value = '';
+        }
+      }
+    };
+
+    /* eslint-disable no-fallthrough */
+
+    function prefix(value, length) {
+      switch (stylisExports.hash(value, length)) {
+        // color-adjust
+        case 5103:
+          return stylisExports.WEBKIT + 'print-' + value + value;
+        // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
+
+        case 5737:
+        case 4201:
+        case 3177:
+        case 3433:
+        case 1641:
+        case 4457:
+        case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
+
+        case 5572:
+        case 6356:
+        case 5844:
+        case 3191:
+        case 6645:
+        case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
+
+        case 6391:
+        case 5879:
+        case 5623:
+        case 6135:
+        case 4599:
+        case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
+
+        case 4215:
+        case 6389:
+        case 5109:
+        case 5365:
+        case 5621:
+        case 3829:
+          return stylisExports.WEBKIT + value + value;
+        // appearance, user-select, transform, hyphens, text-size-adjust
+
+        case 5349:
+        case 4246:
+        case 4810:
+        case 6968:
+        case 2756:
+          return stylisExports.WEBKIT + value + stylisExports.MOZ + value + stylisExports.MS + value + value;
+        // flex, flex-direction
+
+        case 6828:
+        case 4268:
+          return stylisExports.WEBKIT + value + stylisExports.MS + value + value;
+        // order
+
+        case 6165:
+          return stylisExports.WEBKIT + value + stylisExports.MS + 'flex-' + value + value;
+        // align-items
+
+        case 5187:
+          return stylisExports.WEBKIT + value + stylisExports.replace(value, /(\w+).+(:[^]+)/, stylisExports.WEBKIT + 'box-$1$2' + stylisExports.MS + 'flex-$1$2') + value;
+        // align-self
+
+        case 5443:
+          return stylisExports.WEBKIT + value + stylisExports.MS + 'flex-item-' + stylisExports.replace(value, /flex-|-self/, '') + value;
+        // align-content
+
+        case 4675:
+          return stylisExports.WEBKIT + value + stylisExports.MS + 'flex-line-pack' + stylisExports.replace(value, /align-content|flex-|-self/, '') + value;
+        // flex-shrink
+
+        case 5548:
+          return stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, 'shrink', 'negative') + value;
+        // flex-basis
+
+        case 5292:
+          return stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, 'basis', 'preferred-size') + value;
+        // flex-grow
+
+        case 6060:
+          return stylisExports.WEBKIT + 'box-' + stylisExports.replace(value, '-grow', '') + stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, 'grow', 'positive') + value;
+        // transition
+
+        case 4554:
+          return stylisExports.WEBKIT + stylisExports.replace(value, /([^-])(transform)/g, '$1' + stylisExports.WEBKIT + '$2') + value;
+        // cursor
+
+        case 6187:
+          return stylisExports.replace(stylisExports.replace(stylisExports.replace(value, /(zoom-|grab)/, stylisExports.WEBKIT + '$1'), /(image-set)/, stylisExports.WEBKIT + '$1'), value, '') + value;
+        // background, background-image
+
+        case 5495:
+        case 3959:
+          return stylisExports.replace(value, /(image-set\([^]*)/, stylisExports.WEBKIT + '$1' + '$`$1');
+        // justify-content
+
+        case 4968:
+          return stylisExports.replace(stylisExports.replace(value, /(.+:)(flex-)?(.*)/, stylisExports.WEBKIT + 'box-pack:$3' + stylisExports.MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + stylisExports.WEBKIT + value + value;
+        // (margin|padding)-inline-(start|end)
+
+        case 4095:
+        case 3583:
+        case 4068:
+        case 2532:
+          return stylisExports.replace(value, /(.+)-inline(.+)/, stylisExports.WEBKIT + '$1$2') + value;
+        // (min|max)?(width|height|inline-size|block-size)
+
+        case 8116:
+        case 7059:
+        case 5753:
+        case 5535:
+        case 5445:
+        case 5701:
+        case 4933:
+        case 4677:
+        case 5533:
+        case 5789:
+        case 5021:
+        case 4765:
+          // stretch, max-content, min-content, fill-available
+          if (stylisExports.strlen(value) - 1 - length > 6) switch (stylisExports.charat(value, length + 1)) {
+            // (m)ax-content, (m)in-content
+            case 109:
+              // -
+              if (stylisExports.charat(value, length + 4) !== 45) break;
+            // (f)ill-available, (f)it-content
+
+            case 102:
+              return stylisExports.replace(value, /(.+:)(.+)-([^]+)/, '$1' + stylisExports.WEBKIT + '$2-$3' + '$1' + stylisExports.MOZ + (stylisExports.charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
+            // (s)tretch
+
+            case 115:
+              return ~stylisExports.indexof(value, 'stretch') ? prefix(stylisExports.replace(value, 'stretch', 'fill-available'), length) + value : value;
+          }
+          break;
+        // position: sticky
+
+        case 4949:
+          // (s)ticky?
+          if (stylisExports.charat(value, length + 1) !== 115) break;
+        // display: (flex|inline-flex)
+
+        case 6444:
+          switch (stylisExports.charat(value, stylisExports.strlen(value) - 3 - (~stylisExports.indexof(value, '!important') && 10))) {
+            // stic(k)y
+            case 107:
+              return stylisExports.replace(value, ':', ':' + stylisExports.WEBKIT) + value;
+            // (inline-)?fl(e)x
+
+            case 101:
+              return stylisExports.replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + stylisExports.WEBKIT + (stylisExports.charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + stylisExports.WEBKIT + '$2$3' + '$1' + stylisExports.MS + '$2box$3') + value;
+          }
+          break;
+        // writing-mode
+
+        case 5936:
+          switch (stylisExports.charat(value, length + 11)) {
+            // vertical-l(r)
+            case 114:
+              return stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
+            // vertical-r(l)
+
+            case 108:
+              return stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
+            // horizontal(-)tb
+
+            case 45:
+              return stylisExports.WEBKIT + value + stylisExports.MS + stylisExports.replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
+          }
+          return stylisExports.WEBKIT + value + stylisExports.MS + value + value;
+      }
+      return value;
+    }
+    var prefixer = function prefixer(element, index, children, callback) {
+      if (element.length > -1) if (!element["return"]) switch (element.type) {
+        case stylisExports.DECLARATION:
+          element["return"] = prefix(element.value, element.length);
+          break;
+        case stylisExports.KEYFRAMES:
+          return stylisExports.serialize([stylisExports.copy(element, {
+            value: stylisExports.replace(element.value, '@', '@' + stylisExports.WEBKIT)
+          })], callback);
+        case stylisExports.RULESET:
+          if (element.length) return stylisExports.combine(element.props, function (value) {
+            switch (stylisExports.match(value, /(::plac\w+|:read-\w+)/)) {
+              // :read-(only|write)
+              case ':read-only':
+              case ':read-write':
+                return stylisExports.serialize([stylisExports.copy(element, {
+                  props: [stylisExports.replace(value, /:(read-\w+)/, ':' + stylisExports.MOZ + '$1')]
+                })], callback);
+              // :placeholder
+
+              case '::placeholder':
+                return stylisExports.serialize([stylisExports.copy(element, {
+                  props: [stylisExports.replace(value, /:(plac\w+)/, ':' + stylisExports.WEBKIT + 'input-$1')]
+                }), stylisExports.copy(element, {
+                  props: [stylisExports.replace(value, /:(plac\w+)/, ':' + stylisExports.MOZ + '$1')]
+                }), stylisExports.copy(element, {
+                  props: [stylisExports.replace(value, /:(plac\w+)/, stylisExports.MS + 'input-$1')]
+                })], callback);
+            }
+            return '';
+          });
+      }
+    };
+    var getServerStylisCache = isBrowser$3 ? undefined : weakMemoize(function () {
+      return memoize(function () {
+        return {};
+      });
+    });
+    var defaultStylisPlugins = [prefixer];
+    var createCache = function createCache(options) {
+      var key = options.key;
+      if (isBrowser$3 && key === 'css') {
+        var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
+        // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
+        // note this very very intentionally targets all style elements regardless of the key to ensure
+        // that creating a cache works inside of render of a React component
+
+        Array.prototype.forEach.call(ssrStyles, function (node) {
+          // we want to only move elements which have a space in the data-emotion attribute value
+          // because that indicates that it is an Emotion 11 server-side rendered style elements
+          // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
+          // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
+          // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
+          // will not result in the Emotion 10 styles being destroyed
+          var dataEmotionAttribute = node.getAttribute('data-emotion');
+          if (dataEmotionAttribute.indexOf(' ') === -1) {
+            return;
+          }
+          document.head.appendChild(node);
+          node.setAttribute('data-s', '');
+        });
+      }
+      var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+      var inserted = {};
+      var container;
+      var nodesToHydrate = [];
+      if (isBrowser$3) {
+        container = options.container || document.head;
+        Array.prototype.forEach.call(
+        // this means we will ignore elements which don't have a space in them which
+        // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
+        document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
+          var attrib = node.getAttribute("data-emotion").split(' ');
+          for (var i = 1; i < attrib.length; i++) {
+            inserted[attrib[i]] = true;
+          }
+          nodesToHydrate.push(node);
+        });
+      }
+      var _insert;
+      var omnipresentPlugins = [compat, removeLabel];
+      if (!getServerStylisCache) {
+        var currentSheet;
+        var finalizingPlugins = [stylisExports.stringify, stylisExports.rulesheet(function (rule) {
+          currentSheet.insert(rule);
+        })];
+        var serializer = stylisExports.middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
+        var stylis = function stylis(styles) {
+          return stylisExports.serialize(stylisExports.compile(styles), serializer);
+        };
+        _insert = function insert(selector, serialized, sheet, shouldCache) {
+          currentSheet = sheet;
+          stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+          if (shouldCache) {
+            cache.inserted[serialized.name] = true;
+          }
+        };
+      } else {
+        var _finalizingPlugins = [stylisExports.stringify];
+        var _serializer = stylisExports.middleware(omnipresentPlugins.concat(stylisPlugins, _finalizingPlugins));
+        var _stylis = function _stylis(styles) {
+          return stylisExports.serialize(stylisExports.compile(styles), _serializer);
+        };
+        var serverStylisCache = getServerStylisCache(stylisPlugins)(key);
+        var getRules = function getRules(selector, serialized) {
+          var name = serialized.name;
+          if (serverStylisCache[name] === undefined) {
+            serverStylisCache[name] = _stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+          }
+          return serverStylisCache[name];
+        };
+        _insert = function _insert(selector, serialized, sheet, shouldCache) {
+          var name = serialized.name;
+          var rules = getRules(selector, serialized);
+          if (cache.compat === undefined) {
+            // in regular mode, we don't set the styles on the inserted cache
+            // since we don't need to and that would be wasting memory
+            // we return them so that they are rendered in a style tag
+            if (shouldCache) {
+              cache.inserted[name] = true;
+            }
+            return rules;
+          } else {
+            // in compat mode, we put the styles on the inserted cache so
+            // that emotion-server can pull out the styles
+            // except when we don't want to cache it which was in Global but now
+            // is nowhere but we don't want to do a major right now
+            // and just in case we're going to leave the case here
+            // it's also not affecting client side bundle size
+            // so it's really not a big deal
+            if (shouldCache) {
+              cache.inserted[name] = rules;
+            } else {
+              return rules;
+            }
+          }
+        };
+      }
+      var cache = {
+        key: key,
+        sheet: new StyleSheet({
+          key: key,
+          container: container,
+          nonce: options.nonce,
+          speedy: options.speedy,
+          prepend: options.prepend,
+          insertionPoint: options.insertionPoint
+        }),
+        nonce: options.nonce,
+        inserted: inserted,
+        registered: {},
+        insert: _insert
+      };
+      cache.sheet.hydrate(nodesToHydrate);
+      return cache;
+    };
+
+    var reactIsExports = {};
+    var reactIs$1 = {
+      get exports(){ return reactIsExports; },
+      set exports(v){ reactIsExports = v; },
+    };
+
+    var reactIs_production_min = {};
+
+    /** @license React v16.13.1
+     * react-is.production.min.js
+     *
+     * Copyright (c) Facebook, Inc. and its affiliates.
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE file in the root directory of this source tree.
+     */
+    var hasRequiredReactIs_production_min;
+    function requireReactIs_production_min() {
+      if (hasRequiredReactIs_production_min) return reactIs_production_min;
+      hasRequiredReactIs_production_min = 1;
+      var b = "function" === typeof Symbol && Symbol.for,
+        c = b ? Symbol.for("react.element") : 60103,
+        d = b ? Symbol.for("react.portal") : 60106,
+        e = b ? Symbol.for("react.fragment") : 60107,
+        f = b ? Symbol.for("react.strict_mode") : 60108,
+        g = b ? Symbol.for("react.profiler") : 60114,
+        h = b ? Symbol.for("react.provider") : 60109,
+        k = b ? Symbol.for("react.context") : 60110,
+        l = b ? Symbol.for("react.async_mode") : 60111,
+        m = b ? Symbol.for("react.concurrent_mode") : 60111,
+        n = b ? Symbol.for("react.forward_ref") : 60112,
+        p = b ? Symbol.for("react.suspense") : 60113,
+        q = b ? Symbol.for("react.suspense_list") : 60120,
+        r = b ? Symbol.for("react.memo") : 60115,
+        t = b ? Symbol.for("react.lazy") : 60116,
+        v = b ? Symbol.for("react.block") : 60121,
+        w = b ? Symbol.for("react.fundamental") : 60117,
+        x = b ? Symbol.for("react.responder") : 60118,
+        y = b ? Symbol.for("react.scope") : 60119;
+      function z(a) {
+        if ("object" === typeof a && null !== a) {
+          var u = a.$$typeof;
+          switch (u) {
+            case c:
+              switch (a = a.type, a) {
+                case l:
+                case m:
+                case e:
+                case g:
+                case f:
+                case p:
+                  return a;
+                default:
+                  switch (a = a && a.$$typeof, a) {
+                    case k:
+                    case n:
+                    case t:
+                    case r:
+                    case h:
+                      return a;
+                    default:
+                      return u;
+                  }
+              }
+            case d:
+              return u;
+          }
+        }
+      }
+      function A(a) {
+        return z(a) === m;
+      }
+      reactIs_production_min.AsyncMode = l;
+      reactIs_production_min.ConcurrentMode = m;
+      reactIs_production_min.ContextConsumer = k;
+      reactIs_production_min.ContextProvider = h;
+      reactIs_production_min.Element = c;
+      reactIs_production_min.ForwardRef = n;
+      reactIs_production_min.Fragment = e;
+      reactIs_production_min.Lazy = t;
+      reactIs_production_min.Memo = r;
+      reactIs_production_min.Portal = d;
+      reactIs_production_min.Profiler = g;
+      reactIs_production_min.StrictMode = f;
+      reactIs_production_min.Suspense = p;
+      reactIs_production_min.isAsyncMode = function (a) {
+        return A(a) || z(a) === l;
+      };
+      reactIs_production_min.isConcurrentMode = A;
+      reactIs_production_min.isContextConsumer = function (a) {
+        return z(a) === k;
+      };
+      reactIs_production_min.isContextProvider = function (a) {
+        return z(a) === h;
+      };
+      reactIs_production_min.isElement = function (a) {
+        return "object" === typeof a && null !== a && a.$$typeof === c;
+      };
+      reactIs_production_min.isForwardRef = function (a) {
+        return z(a) === n;
+      };
+      reactIs_production_min.isFragment = function (a) {
+        return z(a) === e;
+      };
+      reactIs_production_min.isLazy = function (a) {
+        return z(a) === t;
+      };
+      reactIs_production_min.isMemo = function (a) {
+        return z(a) === r;
+      };
+      reactIs_production_min.isPortal = function (a) {
+        return z(a) === d;
+      };
+      reactIs_production_min.isProfiler = function (a) {
+        return z(a) === g;
+      };
+      reactIs_production_min.isStrictMode = function (a) {
+        return z(a) === f;
+      };
+      reactIs_production_min.isSuspense = function (a) {
+        return z(a) === p;
+      };
+      reactIs_production_min.isValidElementType = function (a) {
+        return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+      };
+      reactIs_production_min.typeOf = z;
+      return reactIs_production_min;
+    }
+
+    (function (module) {
+
+      {
+        module.exports = requireReactIs_production_min();
+      }
+    })(reactIs$1);
+
+    var reactIs = reactIsExports;
+    var FORWARD_REF_STATICS = {
+      '$$typeof': true,
+      render: true,
+      defaultProps: true,
+      displayName: true,
+      propTypes: true
+    };
+    var MEMO_STATICS = {
+      '$$typeof': true,
+      compare: true,
+      defaultProps: true,
+      displayName: true,
+      propTypes: true,
+      type: true
+    };
+    var TYPE_STATICS = {};
+    TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+    TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+
+    var isBrowser$2 = typeof document !== 'undefined';
+    function getRegisteredStyles(registered, registeredStyles, classNames) {
+      var rawClassName = '';
+      classNames.split(' ').forEach(function (className) {
+        if (registered[className] !== undefined) {
+          registeredStyles.push(registered[className] + ";");
+        } else if (className) {
+          rawClassName += className + " ";
+        }
+      });
+      return rawClassName;
+    }
+    var registerStyles = function registerStyles(cache, serialized, isStringTag) {
+      var className = cache.key + "-" + serialized.name;
+      if (
+      // we only need to add the styles to the registered cache if the
+      // class name could be used further down
+      // the tree but if it's a string tag, we know it won't
+      // so we don't have to add it to registered cache.
+      // this improves memory usage since we can avoid storing the whole style string
+      (isStringTag === false ||
+      // we need to always store it if we're in compat mode and
+      // in node since emotion-server relies on whether a style is in
+      // the registered cache to know whether a style is global or not
+      // also, note that this check will be dead code eliminated in the browser
+      isBrowser$2 === false && cache.compat !== undefined) && cache.registered[className] === undefined) {
+        cache.registered[className] = serialized.styles;
+      }
+    };
+    var insertStyles = function insertStyles(cache, serialized, isStringTag) {
+      registerStyles(cache, serialized, isStringTag);
+      var className = cache.key + "-" + serialized.name;
+      if (cache.inserted[serialized.name] === undefined) {
+        var stylesForSSR = '';
+        var current = serialized;
+        do {
+          var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
+          if (!isBrowser$2 && maybeStyles !== undefined) {
+            stylesForSSR += maybeStyles;
+          }
+          current = current.next;
+        } while (current !== undefined);
+        if (!isBrowser$2 && stylesForSSR.length !== 0) {
+          return stylesForSSR;
+        }
+      }
+    };
+
+    /* eslint-disable */
+    // Inspired by https://github.com/garycourt/murmurhash-js
+    // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
+    function murmur2(str) {
+      // 'm' and 'r' are mixing constants generated offline.
+      // They're not really 'magic', they just happen to work well.
+      // const m = 0x5bd1e995;
+      // const r = 24;
+      // Initialize the hash
+      var h = 0; // Mix 4 bytes at a time into the hash
+
+      var k,
+        i = 0,
+        len = str.length;
+      for (; len >= 4; ++i, len -= 4) {
+        k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
+        k = /* Math.imul(k, m): */
+        (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
+        k ^= /* k >>> r: */
+        k >>> 24;
+        h = /* Math.imul(k, m): */
+        (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^ /* Math.imul(h, m): */
+        (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+      } // Handle the last few bytes of the input array
+
+      switch (len) {
+        case 3:
+          h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
+        case 2:
+          h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
+        case 1:
+          h ^= str.charCodeAt(i) & 0xff;
+          h = /* Math.imul(h, m): */
+          (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+      } // Do a few final mixes of the hash to ensure the last few
+      // bytes are well-incorporated.
+
+      h ^= h >>> 13;
+      h = /* Math.imul(h, m): */
+      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+      return ((h ^ h >>> 15) >>> 0).toString(36);
+    }
+
+    var unitlessKeys = {
+      animationIterationCount: 1,
+      aspectRatio: 1,
+      borderImageOutset: 1,
+      borderImageSlice: 1,
+      borderImageWidth: 1,
+      boxFlex: 1,
+      boxFlexGroup: 1,
+      boxOrdinalGroup: 1,
+      columnCount: 1,
+      columns: 1,
+      flex: 1,
+      flexGrow: 1,
+      flexPositive: 1,
+      flexShrink: 1,
+      flexNegative: 1,
+      flexOrder: 1,
+      gridRow: 1,
+      gridRowEnd: 1,
+      gridRowSpan: 1,
+      gridRowStart: 1,
+      gridColumn: 1,
+      gridColumnEnd: 1,
+      gridColumnSpan: 1,
+      gridColumnStart: 1,
+      msGridRow: 1,
+      msGridRowSpan: 1,
+      msGridColumn: 1,
+      msGridColumnSpan: 1,
+      fontWeight: 1,
+      lineHeight: 1,
+      opacity: 1,
+      order: 1,
+      orphans: 1,
+      scale: 1,
+      tabSize: 1,
+      widows: 1,
+      zIndex: 1,
+      zoom: 1,
+      WebkitLineClamp: 1,
+      // SVG-related properties
+      fillOpacity: 1,
+      floodOpacity: 1,
+      stopOpacity: 1,
+      strokeDasharray: 1,
+      strokeDashoffset: 1,
+      strokeMiterlimit: 1,
+      strokeOpacity: 1,
+      strokeWidth: 1
+    };
+
+    var isDevelopment$1 = false;
+    var hyphenateRegex = /[A-Z]|^ms/g;
+    var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
+    var isCustomProperty = function isCustomProperty(property) {
+      return property.charCodeAt(1) === 45;
+    };
+    var isProcessableValue = function isProcessableValue(value) {
+      return value != null && typeof value !== 'boolean';
+    };
+    var processStyleName = /* #__PURE__ */memoize(function (styleName) {
+      return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
+    });
+    var processStyleValue = function processStyleValue(key, value) {
+      switch (key) {
+        case 'animation':
+        case 'animationName':
+          {
+            if (typeof value === 'string') {
+              return value.replace(animationRegex, function (match, p1, p2) {
+                cursor = {
+                  name: p1,
+                  styles: p2,
+                  next: cursor
+                };
+                return p1;
+              });
+            }
+          }
+      }
+      if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
+        return value + 'px';
+      }
+      return value;
+    };
+    var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';
+    function handleInterpolation(mergedProps, registered, interpolation) {
+      if (interpolation == null) {
+        return '';
+      }
+      var componentSelector = interpolation;
+      if (componentSelector.__emotion_styles !== undefined) {
+        return componentSelector;
+      }
+      switch (typeof interpolation) {
+        case 'boolean':
+          {
+            return '';
+          }
+        case 'object':
+          {
+            var keyframes = interpolation;
+            if (keyframes.anim === 1) {
+              cursor = {
+                name: keyframes.name,
+                styles: keyframes.styles,
+                next: cursor
+              };
+              return keyframes.name;
+            }
+            var serializedStyles = interpolation;
+            if (serializedStyles.styles !== undefined) {
+              var next = serializedStyles.next;
+              if (next !== undefined) {
+                // not the most efficient thing ever but this is a pretty rare case
+                // and there will be very few iterations of this generally
+                while (next !== undefined) {
+                  cursor = {
+                    name: next.name,
+                    styles: next.styles,
+                    next: cursor
+                  };
+                  next = next.next;
+                }
+              }
+              var styles = serializedStyles.styles + ";";
+              return styles;
+            }
+            return createStringFromObject(mergedProps, registered, interpolation);
+          }
+        case 'function':
+          {
+            if (mergedProps !== undefined) {
+              var previousCursor = cursor;
+              var result = interpolation(mergedProps);
+              cursor = previousCursor;
+              return handleInterpolation(mergedProps, registered, result);
+            }
+            break;
+          }
+      } // finalize string values (regular strings and functions interpolated into css calls)
+
+      var asString = interpolation;
+      if (registered == null) {
+        return asString;
+      }
+      var cached = registered[asString];
+      return cached !== undefined ? cached : asString;
+    }
+    function createStringFromObject(mergedProps, registered, obj) {
+      var string = '';
+      if (Array.isArray(obj)) {
+        for (var i = 0; i < obj.length; i++) {
+          string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
+        }
+      } else {
+        for (var key in obj) {
+          var value = obj[key];
+          if (typeof value !== 'object') {
+            var asString = value;
+            if (registered != null && registered[asString] !== undefined) {
+              string += key + "{" + registered[asString] + "}";
+            } else if (isProcessableValue(asString)) {
+              string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
+            }
+          } else {
+            if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment$1) {
+              throw new Error(noComponentSelectorMessage);
+            }
+            if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
+              for (var _i = 0; _i < value.length; _i++) {
+                if (isProcessableValue(value[_i])) {
+                  string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
+                }
+              }
+            } else {
+              var interpolated = handleInterpolation(mergedProps, registered, value);
+              switch (key) {
+                case 'animation':
+                case 'animationName':
+                  {
+                    string += processStyleName(key) + ":" + interpolated + ";";
+                    break;
+                  }
+                default:
+                  {
+                    string += key + "{" + interpolated + "}";
+                  }
+              }
+            }
+          }
+        }
+      }
+      return string;
+    }
+    var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
+    // keyframes are stored on the SerializedStyles object as a linked list
+
+    var cursor;
+    function serializeStyles(args, registered, mergedProps) {
+      if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
+        return args[0];
+      }
+      var stringMode = true;
+      var styles = '';
+      cursor = undefined;
+      var strings = args[0];
+      if (strings == null || strings.raw === undefined) {
+        stringMode = false;
+        styles += handleInterpolation(mergedProps, registered, strings);
+      } else {
+        var asTemplateStringsArr = strings;
+        styles += asTemplateStringsArr[0];
+      } // we start at 1 since we've already handled the first arg
+
+      for (var i = 1; i < args.length; i++) {
+        styles += handleInterpolation(mergedProps, registered, args[i]);
+        if (stringMode) {
+          var templateStringsArr = strings;
+          styles += templateStringsArr[i];
+        }
+      } // using a global regex with .exec is stateful so lastIndex has to be reset each time
+
+      labelPattern.lastIndex = 0;
+      var identifierName = '';
+      var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
+
+      while ((match = labelPattern.exec(styles)) !== null) {
+        identifierName += '-' + match[1];
+      }
+      var name = murmur2(styles) + identifierName;
+      return {
+        name: name,
+        styles: styles,
+        next: cursor
+      };
+    }
+
+    var isBrowser$1 = typeof document !== 'undefined';
+    var syncFallback = function syncFallback(create) {
+      return create();
+    };
+    var useInsertionEffect = React__namespace['useInsertion' + 'Effect'] ? React__namespace['useInsertion' + 'Effect'] : false;
+    var useInsertionEffectAlwaysWithSyncFallback = !isBrowser$1 ? syncFallback : useInsertionEffect || syncFallback;
+
+    var isDevelopment = false;
+    var isBrowser = typeof document !== 'undefined';
+    var EmotionCacheContext = /* #__PURE__ */React__namespace.createContext(
+    // we're doing this to avoid preconstruct's dead code elimination in this one case
+    // because this module is primarily intended for the browser and node
+    // but it's also required in react native and similar environments sometimes
+    // and we could have a special build just for that
+    // but this is much easier and the native packages
+    // might use a different theme context in the future anyway
+    typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+      key: 'css'
+    }) : null);
+    EmotionCacheContext.Provider;
+    var withEmotionCache = function withEmotionCache(func) {
+      return /*#__PURE__*/React.forwardRef(function (props, ref) {
+        // the cache will never be null in the browser
+        var cache = React.useContext(EmotionCacheContext);
+        return func(props, cache, ref);
+      });
+    };
+    if (!isBrowser) {
+      withEmotionCache = function withEmotionCache(func) {
+        return function (props) {
+          var cache = React.useContext(EmotionCacheContext);
+          if (cache === null) {
+            // yes, we're potentially creating this on every render
+            // it doesn't actually matter though since it's only on the server
+            // so there will only every be a single render
+            // that could change in the future because of suspense and etc. but for now,
+            // this works and i don't want to optimise for a future thing that we aren't sure about
+            cache = createCache({
+              key: 'css'
+            });
+            return /*#__PURE__*/React__namespace.createElement(EmotionCacheContext.Provider, {
+              value: cache
+            }, func(props, cache));
+          } else {
+            return func(props, cache);
+          }
+        };
+      };
+    }
+    var ThemeContext = /* #__PURE__ */React__namespace.createContext({});
+    var hasOwn = {}.hasOwnProperty;
+    var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+    var createEmotionProps = function createEmotionProps(type, props) {
+      var newProps = {};
+      for (var _key in props) {
+        if (hasOwn.call(props, _key)) {
+          newProps[_key] = props[_key];
+        }
+      }
+      newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:
+
+      return newProps;
+    };
+    var Insertion = function Insertion(_ref) {
+      var cache = _ref.cache,
+        serialized = _ref.serialized,
+        isStringTag = _ref.isStringTag;
+      registerStyles(cache, serialized, isStringTag);
+      var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
+        return insertStyles(cache, serialized, isStringTag);
+      });
+      if (!isBrowser && rules !== undefined) {
+        var _ref2;
+        var serializedNames = serialized.name;
+        var next = serialized.next;
+        while (next !== undefined) {
+          serializedNames += ' ' + next.name;
+          next = next.next;
+        }
+        return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
+          __html: rules
+        }, _ref2.nonce = cache.sheet.nonce, _ref2));
+      }
+      return null;
+    };
+    var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
+      var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+      // not passing the registered cache to serializeStyles because it would
+      // make certain babel optimisations not possible
+
+      if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+        cssProp = cache.registered[cssProp];
+      }
+      var WrappedComponent = props[typePropName];
+      var registeredStyles = [cssProp];
+      var className = '';
+      if (typeof props.className === 'string') {
+        className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+      } else if (props.className != null) {
+        className = props.className + " ";
+      }
+      var serialized = serializeStyles(registeredStyles, undefined, React__namespace.useContext(ThemeContext));
+      className += cache.key + "-" + serialized.name;
+      var newProps = {};
+      for (var _key2 in props) {
+        if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && !isDevelopment) {
+          newProps[_key2] = props[_key2];
+        }
+      }
+      newProps.className = className;
+      if (ref) {
+        newProps.ref = ref;
+      }
+      return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+        cache: cache,
+        serialized: serialized,
+        isStringTag: typeof WrappedComponent === 'string'
+      }), /*#__PURE__*/React__namespace.createElement(WrappedComponent, newProps));
+    });
+    var Emotion$1 = Emotion;
+
+    var _extendsExports = {};
+    var _extends = {
+      get exports(){ return _extendsExports; },
+      set exports(v){ _extendsExports = v; },
+    };
+
+    (function (module) {
+      function _extends() {
+        return module.exports = _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;
+        }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
+      }
+      module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    })(_extends);
+
+    var jsx = function jsx(type, props) {
+      // eslint-disable-next-line prefer-rest-params
+      var args = arguments;
+      if (props == null || !hasOwn.call(props, 'css')) {
+        return React__namespace.createElement.apply(undefined, args);
+      }
+      var argsLength = args.length;
+      var createElementArgArray = new Array(argsLength);
+      createElementArgArray[0] = Emotion$1;
+      createElementArgArray[1] = createEmotionProps(type, props);
+      for (var i = 2; i < argsLength; i++) {
+        createElementArgArray[i] = args[i];
+      }
+      return React__namespace.createElement.apply(null, createElementArgArray);
+    };
+    (function (_jsx) {
+      var JSX;
+      (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
+    })(jsx || (jsx = {}));
+    function css() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return serializeStyles(args);
+    }
+
     exports.IDotsStripPosition = void 0;
     (function (IDotsStripPosition) {
         IDotsStripPosition["INSIDE"] = "INSIDE";
@@ -87,14 +1961,14 @@
     })(exports.STRIP_POSITION || (exports.STRIP_POSITION = {}));
 
     var getActiveDotsStyle = function () {
-        return react.css(templateObject_1$4 || (templateObject_1$4 = __makeTemplateObject(["\n    opacity: 1;\n    width: 12px;\n  "], ["\n    opacity: 1;\n    width: 12px;\n  "])));
+        return css(templateObject_1$4 || (templateObject_1$4 = __makeTemplateObject(["\n    opacity: 1;\n    width: 12px;\n  "], ["\n    opacity: 1;\n    width: 12px;\n  "])));
     };
     var getDotsPositionStyle = function (pos) {
         if (pos === exports.IDotsStripPosition[exports.STRIP_POSITION.INSIDE]) {
-            return react.css(templateObject_2$3 || (templateObject_2$3 = __makeTemplateObject(["\n      position: absolute;\n    "], ["\n      position: absolute;\n    "])));
+            return css(templateObject_2$3 || (templateObject_2$3 = __makeTemplateObject(["\n      position: absolute;\n    "], ["\n      position: absolute;\n    "])));
         }
         else {
-            return react.css(templateObject_3$1 || (templateObject_3$1 = __makeTemplateObject(["\n      paddingitop: 4px;\n    "], ["\n      paddingitop: 4px;\n    "])));
+            return css(templateObject_3$1 || (templateObject_3$1 = __makeTemplateObject(["\n      paddingitop: 4px;\n    "], ["\n      paddingitop: 4px;\n    "])));
         }
     };
     var templateObject_1$4, templateObject_2$3, templateObject_3$1;
@@ -109,8 +1983,8 @@
         return (jsxRuntime.jsxs(DotsContainer, __assign({ pos: stripPosition, className: dotsContainerMergedStyles }, { children: [customSliderIconWithDots && (jsxRuntime.jsx(ctDesignContainer.Container, __assign({ paddingRight: '12px', onClick: onLeftChevronClick }, { children: jsxRuntime.jsx(ctDesignIcons.LeftChevronNoBg, { color: leftArrowColor }) }))), Array(maxDotsToShow < length ? maxDotsToShow : length)
                     .fill(0)
                     .map(function (_, index) {
-                    return index === customIconIndex && customIcon ? (jsxRuntime.jsx(ctDesignContainer.Container, __assign({ className: 'flex flex-center z-10' }, { children: React__default.default.isValidElement(customIcon)
-                            ? React__default.default.cloneElement(customIcon, {
+                    return index === customIconIndex && customIcon ? (jsxRuntime.jsx(ctDesignContainer.Container, __assign({ className: 'flex flex-center z-10' }, { children: React__namespace.default.isValidElement(customIcon)
+                            ? React__namespace.default.cloneElement(customIcon, {
                                 color: index === pos ? 'rgba(255, 255, 255, 1)' : 'rgba(255, 255, 255, 0.5)',
                             })
                             : customIcon }), index)) : (jsxRuntime.jsx(DotsWrapper, { index: index, pos: pos, className: carousalDotsMergedStyles, selectedClassName: selectedDotsMergedStyles }, index));
@@ -121,10 +1995,10 @@
     var getChevronHoverStyles = function (_a) {
         var isHovering = _a.isHovering;
         if (isHovering) {
-            return react.css(templateObject_1$2 || (templateObject_1$2 = __makeTemplateObject(["\n      opacity: 1;\n      transition: opacity 500ms ease-out;\n      background-color: white;\n    "], ["\n      opacity: 1;\n      transition: opacity 500ms ease-out;\n      background-color: white;\n    "])));
+            return css$1.css(templateObject_1$2 || (templateObject_1$2 = __makeTemplateObject(["\n      opacity: 1;\n      transition: opacity 500ms ease-out;\n      background-color: white;\n    "], ["\n      opacity: 1;\n      transition: opacity 500ms ease-out;\n      background-color: white;\n    "])));
         }
         else {
-            return react.css(templateObject_2$1 || (templateObject_2$1 = __makeTemplateObject(["\n      display: none;\n      left: unset;\n      right: unset;\n      opacity: 0;\n      transition: opacity 500ms ease-out;\n    "], ["\n      display: none;\n      left: unset;\n      right: unset;\n      opacity: 0;\n      transition: opacity 500ms ease-out;\n    "])));
+            return css$1.css(templateObject_2$1 || (templateObject_2$1 = __makeTemplateObject(["\n      display: none;\n      left: unset;\n      right: unset;\n      opacity: 0;\n      transition: opacity 500ms ease-out;\n    "], ["\n      display: none;\n      left: unset;\n      right: unset;\n      opacity: 0;\n      transition: opacity 500ms ease-out;\n    "])));
         }
     };
     var templateObject_1$2, templateObject_2$1;
@@ -227,7 +2101,7 @@
         var _v = styleConfig || {}, _w = _v.wrapper, customWrapper = _w === void 0 ? [] : _w, _x = _v.carouselContainer, customCarouselContainer = _x === void 0 ? [] : _x, _y = _v.carouselSlot, customCarouselSlot = _y === void 0 ? [] : _y, _z = _v.carousalDots, customCarousalDots = _z === void 0 ? [] : _z, _0 = _v.selectedDots, customSelectedDots = _0 === void 0 ? [] : _0, _1 = _v.dotsContainer, customDotsContainer = _1 === void 0 ? [] : _1, _2 = _v.imageCountChipContainer, customImageCountChipContainer = _2 === void 0 ? [] : _2, _3 = _v.imageCountChipWrapper, customImageCountChipWrapper = _3 === void 0 ? [] : _3, rightArrowColor = _v.rightArrowColor, leftArrowColor = _v.leftArrowColor, _4 = _v.chevronContainer, customChevronContainer = _4 === void 0 ? [] : _4;
         var _5 = React.useState(false), isHovering = _5[0], setIsHovering = _5[1];
         var numItems = React.useMemo(function () {
-            return React__default.default.Children.count(props.children);
+            return React__namespace.default.Children.count(props.children);
         }, [props.children]);
         var carouselRef = React.useRef(null);
         var containerRef = React.useRef(null);
@@ -349,7 +2223,7 @@
                 getIsHovering === null || getIsHovering === void 0 ? void 0 : getIsHovering(false);
             }
         }; }, []);
-        var length = React__default.default.Children.count(props.children);
+        var length = React__namespace.default.Children.count(props.children);
         var onLeftClick = function (e) {
             e.stopPropagation();
             e.preventDefault();
@@ -427,7 +2301,7 @@
                             root: __spreadArray(__spreadArray([staticCarouselStyles.wrapper], customWrapper, true), [{ height: wrapperHeight }], false),
                         } }, { children: [showSliderIcons && !customSliderIconWithDots && (jsxRuntime.jsx(SliderChevron, { onClick: onLeftClick, Icon: ctDesignIcons.SliderLeftChevron, dir: exports.SLIDER_DIRECTION.PREV, isHovering: isHovering, className: chevronContainerMergedStyles })), jsxRuntime.jsx(ctDesignContainer.Container, __assign({ styleConfig: {
                                     root: __spreadArray([staticCarouselStyles.carouselContainer], customCarouselContainer, true),
-                                }, ref: carouselRef }, { children: React__default.default.Children.map(props.children, function (child, index) { return (jsxRuntime.jsx(ctDesignContainer.Container, __assign({ styleConfig: {
+                                }, ref: carouselRef }, { children: React__namespace.default.Children.map(props.children, function (child, index) { return (jsxRuntime.jsx(ctDesignContainer.Container, __assign({ styleConfig: {
                                         root: __spreadArray([staticCarouselStyles.carouselSlot], customCarouselSlot, true),
                                     } }, { children: child }))); }) })), showSliderIcons && !customSliderIconWithDots && (jsxRuntime.jsx(SliderChevron, { onClick: onRightClick, Icon: ctDesignIcons.SliderRightChevron, dir: exports.SLIDER_DIRECTION.NEXT, isHovering: isHovering, className: chevronContainerMergedStyles })), CustomDotsComponent ? (jsxRuntime.jsx(CustomDotsComponent, { onLeftChevronClick: onLeftClick, onRightChevronClick: onRightClick, length: length, maxDotsToShow: maxDotsToShow, pos: pos })) : (showDots && (jsxRuntime.jsx(DotsComponent, { length: length, maxDotsToShow: maxDotsToShow, pos: pos, customSliderIconWithDots: customSliderIconWithDots, onLeftChevronClick: onLeftClick, onRightChevronClick: onRightClick, carousalDotsStyles: customCarousalDots, selectedDotsStyles: customSelectedDots, dotsContainerStyles: customDotsContainer, leftArrowColor: leftArrowColor, rightArrowColor: rightArrowColor, stripPosition: dotsStripPosition, customIcon: customIcon, customIconIndex: customIconIndex }))), showCountChip && (jsxRuntime.jsx(StyledImageCountChipWrapper, __assign({ className: imageCountChipMergedStyles }, { children: jsxRuntime.jsx(StyledImageCountChipContainer, __assign({ className: imageCountChipContainerMergedStyles }, { children: "".concat(pos + 1, "/").concat(length) })) })))] })), CustomLeftCarousalComponent && jsxRuntime.jsx(CustomLeftCarousalComponent, { onSlide: onSwipe })] })) })));
     });