@class101/cdn-ui-system 0.0.8 → 0.0.12

package/lib/Slider/Slider.js

@@ -1,148 +1,1252 @@
 import {
-  h
-} from "../../chunk-K4YVFYII.js";
+  EVENTS,
+  ExternalPanel,
+  ExternalRenderer,
+  Flicking,
+  NormalRenderingStrategy,
+  VirtualRenderingStrategy,
+  component_esm_default,
+  getDefaultCameraTransform,
+  getFlickingAttached,
+  getRenderingPanels,
+  range,
+  sync,
+  withFlickingMethods
+} from "../../chunk-IPFBPHEG.js";
 import {
   emotion_styled_browser_esm_default
-} from "../../chunk-KBR5BGSG.js";
+} from "../../chunk-SFQY5CLW.js";
 import {
-  css,
   useTheme
-} from "../../chunk-UAWCTQGC.js";
-import "../../chunk-QN5Q5NTF.js";
+} from "../../chunk-T7TBQTBE.js";
+import "../../chunk-LE44IRCL.js";
+import "../../chunk-CGEEKALF.js";
+import "../../chunk-J3Q2BPOW.js";
 import {
   React,
+  __commonJS,
+  __spreadValues,
+  __toModule,
   init_react_shim
-} from "../../chunk-CPDZ2HQZ.js";
+} from "../../chunk-VIIHQGZ3.js";
+
+// node_modules/@egjs/react-flicking/node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "node_modules/@egjs/react-flicking/node_modules/react-is/cjs/react-is.development.js"(exports) {
+    init_react_shim();
+    "use strict";
+    if (true) {
+      (function() {
+        "use strict";
+        var REACT_ELEMENT_TYPE = 60103;
+        var REACT_PORTAL_TYPE = 60106;
+        var REACT_FRAGMENT_TYPE = 60107;
+        var REACT_STRICT_MODE_TYPE = 60108;
+        var REACT_PROFILER_TYPE = 60114;
+        var REACT_PROVIDER_TYPE = 60109;
+        var REACT_CONTEXT_TYPE = 60110;
+        var REACT_FORWARD_REF_TYPE = 60112;
+        var REACT_SUSPENSE_TYPE = 60113;
+        var REACT_SUSPENSE_LIST_TYPE = 60120;
+        var REACT_MEMO_TYPE = 60115;
+        var REACT_LAZY_TYPE = 60116;
+        var REACT_BLOCK_TYPE = 60121;
+        var REACT_SERVER_BLOCK_TYPE = 60122;
+        var REACT_FUNDAMENTAL_TYPE = 60117;
+        var REACT_SCOPE_TYPE = 60119;
+        var REACT_OPAQUE_ID_TYPE = 60128;
+        var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
+        var REACT_OFFSCREEN_TYPE = 60130;
+        var REACT_LEGACY_HIDDEN_TYPE = 60131;
+        if (typeof Symbol === "function" && Symbol.for) {
+          var symbolFor = Symbol.for;
+          REACT_ELEMENT_TYPE = symbolFor("react.element");
+          REACT_PORTAL_TYPE = symbolFor("react.portal");
+          REACT_FRAGMENT_TYPE = symbolFor("react.fragment");
+          REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
+          REACT_PROFILER_TYPE = symbolFor("react.profiler");
+          REACT_PROVIDER_TYPE = symbolFor("react.provider");
+          REACT_CONTEXT_TYPE = symbolFor("react.context");
+          REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
+          REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
+          REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
+          REACT_MEMO_TYPE = symbolFor("react.memo");
+          REACT_LAZY_TYPE = symbolFor("react.lazy");
+          REACT_BLOCK_TYPE = symbolFor("react.block");
+          REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
+          REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
+          REACT_SCOPE_TYPE = symbolFor("react.scope");
+          REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
+          REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
+          REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
+          REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
+        }
+        var enableScopeAPI = false;
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
+            return true;
+          }
+          if (typeof type === "object" && type !== null) {
+            if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                  case REACT_SUSPENSE_LIST_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment2 = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense = REACT_SUSPENSE_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        var hasWarnedAboutDeprecatedIsConcurrentMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isConcurrentMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+              hasWarnedAboutDeprecatedIsConcurrentMode = true;
+              console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment2(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment2;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment2;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+        exports.isValidElementType = isValidElementType;
+        exports.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// node_modules/@egjs/react-flicking/node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "node_modules/@egjs/react-flicking/node_modules/react-is/index.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_is_development();
+    }
+  }
+});
 
 // libs/shared/ui-system/src/lib/Slider/Slider.tsx
 init_react_shim();
-import {forwardRef, useCallback, useState} from "react";
-import {Box} from "../../private/Box/index.js";
-import {skipForwardProps, getPaddedResponsiveArray, getResponsiveOptions} from "../../core/index.js";
-import {INITIAL_STATES} from "./constants.js";
-import {useAutoPlay} from "./internalHooks/useAutoPlay.js";
-import {usePageControl} from "./internalHooks/usePageControl.js";
-import {useVirtual} from "./internalHooks/useVirtual.js";
-var Slider = forwardRef(({
-  className,
-  autoPlay = false,
-  autoPlayDurationMs = 1e3,
-  controls = true,
-  loop = false,
-  spacing = 0,
-  slidesPerView = 1,
-  centered = false,
-  offsetX,
-  children,
-  onIndexChange,
-  onProgressStateChange,
-  initial = 0
-}, forwardedRef) => {
-  const {breakpoints} = useTheme();
-  const responsiveSlidesPerView = getPaddedResponsiveArray(breakpoints, slidesPerView);
-  const responsiveSpacing = getPaddedResponsiveArray(breakpoints, spacing);
-  const responsiveControls = getPaddedResponsiveArray(breakpoints, controls);
-  const [index, setIndex] = useState(INITIAL_STATES.index);
-  const [currentSlidesPerView, setCurrentSlidesPerView] = useState(responsiveSlidesPerView?.slice(-1)[0]);
-  const responsiveOptions = getResponsiveOptions(breakpoints, {
-    controls: responsiveControls,
-    spacing: responsiveSpacing,
-    slidesPerView: responsiveSlidesPerView
-  });
-  const [sliderRef, slider] = h({
-    loop,
-    initial,
-    centered,
-    rubberband: false,
-    breakpoints: responsiveOptions,
-    slideChanged: (sliderElement) => {
-      const {relativeSlide} = sliderElement.details();
-      handleIndexChange(relativeSlide);
-    },
-    afterChange: (sliderElement) => {
-      setAutoPlayTimer(sliderElement);
+import {
+  Children as Children2,
+  forwardRef,
+  isValidElement,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef
+} from "react";
+
+// node_modules/@egjs/react-flicking/dist/flicking.esm.js
+init_react_shim();
+import {
+  Children,
+  Component,
+  Fragment,
+  PureComponent,
+  cloneElement,
+  createElement,
+  createRef
+} from "react";
+import React__default from "react";
+
+// node_modules/@egjs/list-differ/dist/list-differ.esm.js
+init_react_shim();
+var PolyMap = /* @__PURE__ */ function() {
+  function PolyMap2() {
+    this.keys = [];
+    this.values = [];
+  }
+  var __proto = PolyMap2.prototype;
+  __proto.get = function(key) {
+    return this.values[this.keys.indexOf(key)];
+  };
+  __proto.set = function(key, value) {
+    var keys = this.keys;
+    var values = this.values;
+    var prevIndex = keys.indexOf(key);
+    var index = prevIndex === -1 ? keys.length : prevIndex;
+    keys[index] = key;
+    values[index] = value;
+  };
+  return PolyMap2;
+}();
+var HashMap = /* @__PURE__ */ function() {
+  function HashMap2() {
+    this.object = {};
+  }
+  var __proto = HashMap2.prototype;
+  __proto.get = function(key) {
+    return this.object[key];
+  };
+  __proto.set = function(key, value) {
+    this.object[key] = value;
+  };
+  return HashMap2;
+}();
+var SUPPORT_MAP = typeof Map === "function";
+var Link = /* @__PURE__ */ function() {
+  function Link2() {
+  }
+  var __proto = Link2.prototype;
+  __proto.connect = function(prevLink, nextLink) {
+    this.prev = prevLink;
+    this.next = nextLink;
+    prevLink && (prevLink.next = this);
+    nextLink && (nextLink.prev = this);
+  };
+  __proto.disconnect = function() {
+    var prevLink = this.prev;
+    var nextLink = this.next;
+    prevLink && (prevLink.next = nextLink);
+    nextLink && (nextLink.prev = prevLink);
+  };
+  __proto.getIndex = function() {
+    var link = this;
+    var index = -1;
+    while (link) {
+      link = link.prev;
+      ++index;
+    }
+    return index;
+  };
+  return Link2;
+}();
+function orderChanged(changed, fixed) {
+  var fromLinks = [];
+  var toLinks = [];
+  changed.forEach(function(_a) {
+    var from = _a[0], to = _a[1];
+    var link = new Link();
+    fromLinks[from] = link;
+    toLinks[to] = link;
+  });
+  fromLinks.forEach(function(link, i) {
+    link.connect(fromLinks[i - 1]);
+  });
+  return changed.filter(function(_, i) {
+    return !fixed[i];
+  }).map(function(_a, i) {
+    var from = _a[0], to = _a[1];
+    if (from === to) {
+      return [0, 0];
+    }
+    var fromLink = fromLinks[from];
+    var toLink = toLinks[to - 1];
+    var fromIndex = fromLink.getIndex();
+    fromLink.disconnect();
+    if (!toLink) {
+      fromLink.connect(void 0, fromLinks[0]);
+    } else {
+      fromLink.connect(toLink, toLink.next);
+    }
+    var toIndex = fromLink.getIndex();
+    return [fromIndex, toIndex];
+  });
+}
+var Result = /* @__PURE__ */ function() {
+  function Result2(prevList, list, added, removed, changed, maintained, changedBeforeAdded, fixed) {
+    this.prevList = prevList;
+    this.list = list;
+    this.added = added;
+    this.removed = removed;
+    this.changed = changed;
+    this.maintained = maintained;
+    this.changedBeforeAdded = changedBeforeAdded;
+    this.fixed = fixed;
+  }
+  var __proto = Result2.prototype;
+  Object.defineProperty(__proto, "ordered", {
+    get: function() {
+      if (!this.cacheOrdered) {
+        this.caculateOrdered();
+      }
+      return this.cacheOrdered;
     },
-    dragStart: () => {
-      clearAutoPlayTimer();
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "pureChanged", {
+    get: function() {
+      if (!this.cachePureChanged) {
+        this.caculateOrdered();
+      }
+      return this.cachePureChanged;
     },
-    mounted: (sliderElement) => {
-      setCurrentSlidesPerView(sliderElement.details().slidesPerView);
+    enumerable: true,
+    configurable: true
+  });
+  __proto.caculateOrdered = function() {
+    var ordered = orderChanged(this.changedBeforeAdded, this.fixed);
+    var changed = this.changed;
+    var pureChanged = [];
+    this.cacheOrdered = ordered.filter(function(_a, i) {
+      var from = _a[0], to = _a[1];
+      var _b = changed[i], fromBefore = _b[0], toBefore = _b[1];
+      if (from !== to) {
+        pureChanged.push([fromBefore, toBefore]);
+        return true;
+      }
+    });
+    this.cachePureChanged = pureChanged;
+  };
+  return Result2;
+}();
+function diff(prevList, list, findKeyCallback) {
+  var mapClass = SUPPORT_MAP ? Map : findKeyCallback ? HashMap : PolyMap;
+  var callback = findKeyCallback || function(e) {
+    return e;
+  };
+  var added = [];
+  var removed = [];
+  var maintained = [];
+  var prevKeys = prevList.map(callback);
+  var keys = list.map(callback);
+  var prevKeyMap = new mapClass();
+  var keyMap = new mapClass();
+  var changedBeforeAdded = [];
+  var fixed = [];
+  var removedMap = {};
+  var changed = [];
+  var addedCount = 0;
+  var removedCount = 0;
+  prevKeys.forEach(function(key, prevListIndex) {
+    prevKeyMap.set(key, prevListIndex);
+  });
+  keys.forEach(function(key, listIndex) {
+    keyMap.set(key, listIndex);
+  });
+  prevKeys.forEach(function(key, prevListIndex) {
+    var listIndex = keyMap.get(key);
+    if (typeof listIndex === "undefined") {
+      ++removedCount;
+      removed.push(prevListIndex);
+    } else {
+      removedMap[listIndex] = removedCount;
     }
   });
-  const {setAutoPlayTimer, clearAutoPlayTimer} = useAutoPlay({
-    slider,
-    autoPlay,
-    durationMs: autoPlayDurationMs,
-    onProgressStateChange
-  });
-  usePageControl({
-    controlRef: forwardedRef,
-    slider,
-    callback: clearAutoPlayTimer
-  });
-  const {slides} = useVirtual({
-    loop,
-    currentIndex: index,
-    currentSlidesPerView,
-    slideElements: children
-  });
-  const handleIndexChange = useCallback((nextIndex) => {
-    setIndex(nextIndex);
-    onIndexChange?.(nextIndex);
-  }, [onIndexChange, setIndex]);
-  const responsivePaddingX = typeof offsetX === "number" ? [offsetX] : offsetX;
-  const responvieMarginX = responsivePaddingX?.map((x) => x * -1);
-  return /* @__PURE__ */ React.createElement(Box, {
-    overflowX: "hidden",
-    px: responsivePaddingX,
-    mx: responvieMarginX
-  }, /* @__PURE__ */ React.createElement(SliderContainer, {
-    className: `${className ?? ""} keen-slider`,
-    ref: sliderRef,
-    slidesPerView: responsiveSlidesPerView,
-    spacing: responsiveSpacing,
-    visible: Boolean(offsetX)
-  }, slides));
-});
-var SliderContainer = emotion_styled_browser_esm_default(Box, skipForwardProps(["spacing"]))`
-  ${({visible}) => visible && css`
-      overflow: visible;
-    `}
-
-  .keen-slider__slide {
-    ${({slidesPerView, spacing}) => css`
-      min-width: calc((100% - ${spacing[0] * (slidesPerView[0] - 1)}px) / ${slidesPerView[0]});
-      max-width: calc((100% - ${spacing[0] * (slidesPerView[0] - 1)}px) / ${slidesPerView[0]});
-    `}
+  keys.forEach(function(key, listIndex) {
+    var prevListIndex = prevKeyMap.get(key);
+    if (typeof prevListIndex === "undefined") {
+      added.push(listIndex);
+      ++addedCount;
+    } else {
+      maintained.push([prevListIndex, listIndex]);
+      removedCount = removedMap[listIndex] || 0;
+      changedBeforeAdded.push([prevListIndex - removedCount, listIndex - addedCount]);
+      fixed.push(listIndex === prevListIndex);
+      if (prevListIndex !== listIndex) {
+        changed.push([prevListIndex, listIndex]);
+      }
+    }
+  });
+  removed.reverse();
+  return new Result(prevList, list, added, removed, changed, maintained, changedBeforeAdded, fixed);
+}
+var ListDiffer = /* @__PURE__ */ function() {
+  function ListDiffer2(list, findKeyCallback) {
+    if (list === void 0) {
+      list = [];
+    }
+    this.findKeyCallback = findKeyCallback;
+    this.list = [].slice.call(list);
+  }
+  var __proto = ListDiffer2.prototype;
+  __proto.update = function(list) {
+    var newData = [].slice.call(list);
+    var result = diff(this.list, newData, this.findKeyCallback);
+    this.list = newData;
+    return result;
+  };
+  return ListDiffer2;
+}();
+var list_differ_esm_default = ListDiffer;
 
-    ${({theme, slidesPerView, spacing}) => theme.breakpoints.map((breakpoint, index) => slidesPerView[index + 1] && spacing[index + 1] && css`
-            @media screen and (min-width: ${breakpoint}) {
-              min-width: calc(
-                (100% - ${spacing[index + 1] * (slidesPerView[index + 1] - 1)}px) / ${slidesPerView[index + 1]}
-              );
-              max-width: calc(
-                (100% - ${spacing[index + 1] * (slidesPerView[index + 1] - 1)}px) / ${slidesPerView[index + 1]}
-              );
+// node_modules/@egjs/react-flicking/dist/flicking.esm.js
+var import_react_is = __toModule(require_react_is());
+import { findDOMNode } from "react-dom";
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      if (Object.prototype.hasOwnProperty.call(b2, p))
+        d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  }, f, y, t, g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (_)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return {
+              value: op[1],
+              done: false
+            };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
             }
-          `)}
-
-    &:not(:first-child) {
-      ${({spacing}) => css`
-        margin-left: ${spacing[0]};
-      `}
-
-      ${({theme, spacing}) => theme.breakpoints.map((breakpoint, index) => spacing[index + 1] && css`
-              @media screen and (min-width: ${breakpoint}) {
-                margin-left: ${spacing[index + 1]}px;
-              }
-            `)}
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar)
+          ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+var DEFAULT_PROPS = {
+  viewportTag: "div",
+  cameraTag: "div",
+  plugins: [],
+  useFindDOMNode: false,
+  hideBeforeInit: false,
+  onReady: function(e) {
+  },
+  onBeforeResize: function(e) {
+  },
+  onAfterResize: function(e) {
+  },
+  onHoldStart: function(e) {
+  },
+  onHoldEnd: function(e) {
+  },
+  onMoveStart: function(e) {
+  },
+  onMove: function(e) {
+  },
+  onMoveEnd: function(e) {
+  },
+  onWillChange: function(e) {
+  },
+  onChanged: function(e) {
+  },
+  onWillRestore: function(e) {
+  },
+  onRestored: function(e) {
+  },
+  onSelect: function(e) {
+  },
+  onNeedPanel: function(e) {
+  },
+  onVisibleChange: function(e) {
+  },
+  onReachEdge: function(e) {
+  },
+  onPanelChange: function(e) {
+  }
+};
+var ReactRenderer = /* @__PURE__ */ function(_super) {
+  __extends(ReactRenderer2, _super);
+  function ReactRenderer2(options) {
+    var _this = _super.call(this, options) || this;
+    _this._reactFlicking = options.reactFlicking;
+    return _this;
+  }
+  var __proto = ReactRenderer2.prototype;
+  __proto.render = function() {
+    return __awaiter(this, void 0, void 0, function() {
+      var flicking, reactFlicking, strategy;
+      return __generator(this, function(_a) {
+        flicking = getFlickingAttached(this._flicking);
+        reactFlicking = this._reactFlicking;
+        strategy = this._strategy;
+        strategy.updateRenderingPanels(flicking);
+        strategy.renderPanels(flicking);
+        return [
+          2,
+          new Promise(function(resolve) {
+            reactFlicking.renderEmitter.once("render", resolve);
+            reactFlicking.forceUpdate();
+          })
+        ];
+      });
+    });
+  };
+  __proto.forceRenderAllPanels = function() {
+    return __awaiter(this, void 0, void 0, function() {
+      var reactFlicking;
+      return __generator(this, function(_a) {
+        switch (_a.label) {
+          case 0:
+            reactFlicking = this._reactFlicking;
+            return [
+              4,
+              _super.prototype.forceRenderAllPanels.call(this)
+            ];
+          case 1:
+            _a.sent();
+            return [
+              2,
+              new Promise(function(resolve) {
+                reactFlicking.renderEmitter.once("render", resolve);
+                reactFlicking.forceUpdate();
+              })
+            ];
+        }
+      });
+    });
+  };
+  __proto._collectPanels = function() {
+    var flicking = getFlickingAttached(this._flicking);
+    var reactFlicking = this._reactFlicking;
+    var reactPanels = reactFlicking.reactPanels;
+    this._panels = this._strategy.collectPanels(flicking, reactPanels);
+  };
+  __proto._createPanel = function(externalComponent, options) {
+    return this._strategy.createPanel(externalComponent, options);
+  };
+  return ReactRenderer2;
+}(ExternalRenderer);
+var StrictPanel = /* @__PURE__ */ function(_super) {
+  __extends(StrictPanel2, _super);
+  function StrictPanel2() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this._hide = false;
+    _this._elRef = createRef();
+    return _this;
+  }
+  var __proto = StrictPanel2.prototype;
+  Object.defineProperty(__proto, "nativeElement", {
+    get: function() {
+      return this._elRef.current;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "rendered", {
+    get: function() {
+      return !this._hide;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  __proto.render = function() {
+    return this._hide ? createElement(Fragment, null) : this._getElement();
+  };
+  __proto.show = function() {
+    this._hide = false;
+  };
+  __proto.hide = function() {
+    this._hide = true;
+  };
+  __proto._getElement = function() {
+    return cloneElement(Children.only(this.props.children), {
+      ref: this._elRef
+    });
+  };
+  return StrictPanel2;
+}(Component);
+var NonStrictPanel = /* @__PURE__ */ function(_super) {
+  __extends(NonStrictPanel2, _super);
+  function NonStrictPanel2() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this._hide = false;
+    return _this;
+  }
+  var __proto = NonStrictPanel2.prototype;
+  Object.defineProperty(__proto, "nativeElement", {
+    get: function() {
+      return findDOMNode(this);
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "rendered", {
+    get: function() {
+      return !this._hide;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  __proto.render = function() {
+    return this._hide ? createElement(Fragment, null) : this.props.children;
+  };
+  __proto.show = function() {
+    this._hide = false;
+  };
+  __proto.hide = function() {
+    this._hide = true;
+  };
+  return NonStrictPanel2;
+}(Component);
+var ViewportSlot = function(_a) {
+  var children = _a.children;
+  return React__default.createElement(React__default.Fragment, null, children);
+};
+var ReactElementProvider = /* @__PURE__ */ function() {
+  function ReactElementProvider2(el) {
+    this._el = el;
+  }
+  var __proto = ReactElementProvider2.prototype;
+  Object.defineProperty(__proto, "element", {
+    get: function() {
+      return this._el.nativeElement;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "rendered", {
+    get: function() {
+      return this._el.rendered;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  __proto.show = function() {
+    this._el.show();
+  };
+  __proto.hide = function() {
+    this._el.hide();
+  };
+  return ReactElementProvider2;
+}();
+var Flicking2 = /* @__PURE__ */ function(_super) {
+  __extends(Flicking3, _super);
+  function Flicking3() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this._panels = [];
+    _this._renderEmitter = new component_esm_default();
+    return _this;
+  }
+  var __proto = Flicking3.prototype;
+  Object.defineProperty(__proto, "reactPanels", {
+    get: function() {
+      return this._panels.map(function(panel) {
+        return panel.current;
+      });
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "renderEmitter", {
+    get: function() {
+      return this._renderEmitter;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  __proto.componentDidMount = function() {
+    var props = this.props;
+    var rendererOptions = {
+      reactFlicking: this,
+      strategy: props.virtual && props.panelsPerView > 0 ? new VirtualRenderingStrategy() : new NormalRenderingStrategy({
+        providerCtor: ReactElementProvider,
+        panelCtor: ExternalPanel
+      })
+    };
+    var flicking = new Flicking(this._viewportElement, __assign(__assign({}, props), {
+      renderExternal: {
+        renderer: ReactRenderer,
+        rendererOptions
+      }
+    }));
+    this._vanillaFlicking = flicking;
+    var children = this._getChildren();
+    this._jsxDiffer = new list_differ_esm_default(children, function(panel) {
+      return panel.key;
+    });
+    this._pluginsDiffer = new list_differ_esm_default();
+    this._bindEvents();
+    this._checkPlugins();
+    if (props.status) {
+      flicking.setStatus(props.status);
+    }
+  };
+  __proto.componentWillUnmount = function() {
+    var _a;
+    (_a = this._vanillaFlicking) === null || _a === void 0 ? void 0 : _a.destroy();
+  };
+  __proto.componentDidUpdate = function() {
+    var flicking = this._vanillaFlicking;
+    var diffResult = this._diffResult;
+    this._checkPlugins();
+    this._renderEmitter.trigger("render");
+    if (!diffResult || !flicking.initialized)
+      return;
+    sync(flicking, diffResult, this.reactPanels);
+    if (diffResult.added.length > 0 || diffResult.removed.length > 0) {
+      this.forceUpdate();
     }
+    this._diffResult = null;
+  };
+  __proto.render = function() {
+    var _this = this;
+    var _a, _b, _c, _d;
+    var props = this.props;
+    var Viewport = props.viewportTag;
+    var Camera = props.cameraTag;
+    var attributes = {};
+    var flicking = this._vanillaFlicking;
+    var children = this._getChildren(props.children);
+    var diffResult = (_b = (_a = this._jsxDiffer) === null || _a === void 0 ? void 0 : _a.update(children)) !== null && _b !== void 0 ? _b : null;
+    this._panels = this._createPanelRefs(props, children);
+    this._diffResult = diffResult;
+    for (var name in props) {
+      if (!(name in DEFAULT_PROPS) && !(name in Flicking.prototype)) {
+        attributes[name] = props[name];
+      }
+    }
+    var initialized = !!this._diffResult && flicking && flicking.initialized;
+    var viewportClasses = ["flicking-viewport"];
+    var isHorizontal = flicking ? flicking.horizontal : (_c = props.horizontal) !== null && _c !== void 0 ? _c : true;
+    if (!isHorizontal) {
+      viewportClasses.push("vertical");
+    }
+    if (props.hideBeforeInit && !initialized) {
+      viewportClasses.push("flicking-hidden");
+    }
+    if (attributes.className) {
+      viewportClasses.push(attributes.className);
+    }
+    var cameraProps = !initialized && props.firstPanelSize ? {
+      style: {
+        transform: getDefaultCameraTransform(this.props.align, this.props.horizontal, this.props.firstPanelSize)
+      }
+    } : {};
+    var panels = !!props.virtual && ((_d = props.panelsPerView) !== null && _d !== void 0 ? _d : -1) > 0 ? this._getVirtualPanels(initialized) : this._getPanels(initialized);
+    return createElement(Viewport, __assign({}, attributes, {
+      className: viewportClasses.join(" "),
+      ref: function(e) {
+        e && (_this._viewportElement = e);
+      }
+    }), createElement(Camera, __assign({
+      className: "flicking-camera"
+    }, cameraProps), panels), this._getViewportSlot());
+  };
+  __proto._createPanelRefs = function(props, children) {
+    var _a;
+    var panelsPerView = (_a = props.panelsPerView) !== null && _a !== void 0 ? _a : -1;
+    return panelsPerView > 0 && !!props.virtual ? range(panelsPerView + 1).map(function() {
+      return createRef();
+    }) : children.map(function() {
+      return createRef();
+    });
+  };
+  __proto._bindEvents = function() {
+    var _this = this;
+    var flicking = this._vanillaFlicking;
+    var props = this.props;
+    Object.keys(EVENTS).forEach(function(eventKey) {
+      var eventName = EVENTS[eventKey];
+      var propName = "on" + (eventName.charAt(0).toUpperCase() + eventName.slice(1));
+      flicking.on(eventName, function(e) {
+        e.currentTarget = _this;
+        props[propName](e);
+      });
+    });
+    flicking.once(EVENTS.READY, function() {
+      _this.forceUpdate();
+    });
+  };
+  __proto._checkPlugins = function() {
+    var flicking = this._vanillaFlicking;
+    var _a = this._pluginsDiffer.update(this.props.plugins), list = _a.list, added = _a.added, removed = _a.removed, prevList = _a.prevList;
+    flicking.addPlugins.apply(flicking, added.map(function(index) {
+      return list[index];
+    }));
+    flicking.removePlugins.apply(flicking, removed.map(function(index) {
+      return prevList[index];
+    }));
+  };
+  __proto._getChildren = function(children) {
+    var _this = this;
+    if (children === void 0) {
+      children = this.props.children;
+    }
+    return Children.toArray(children).filter(function(child) {
+      return child.type !== ViewportSlot;
+    }).reduce(function(all, child) {
+      return __spreadArray(__spreadArray([], all, true), _this._unpackFragment(child), true);
+    }, []);
+  };
+  __proto._getViewportSlot = function() {
+    return Children.toArray(this.props.children).filter(function(child) {
+      return child.type === ViewportSlot;
+    });
+  };
+  __proto._unpackFragment = function(child) {
+    var _this = this;
+    return (0, import_react_is.isFragment)(child) ? Children.toArray(child.props.children).reduce(function(allChilds, fragChild) {
+      return __spreadArray(__spreadArray([], allChilds, true), _this._unpackFragment(fragChild), true);
+    }, []) : [child];
+  };
+  __proto._getVirtualPanels = function(initialized) {
+    var _this = this;
+    var _a = this.props.virtual.panelClass, panelClass = _a === void 0 ? "flicking-panel" : _a;
+    var panelsPerView = this.props.panelsPerView;
+    var flicking = this._vanillaFlicking;
+    var renderingIndexes = initialized ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking) : range(panelsPerView + 1);
+    var firstPanel = flicking && flicking.panels[0];
+    var size = firstPanel ? flicking.horizontal ? {
+      width: firstPanel.size
+    } : {
+      height: firstPanel.size
+    } : {};
+    return renderingIndexes.map(function(idx) {
+      return createElement("div", {
+        key: idx,
+        "data-element-index": idx,
+        ref: _this._panels[idx],
+        className: panelClass,
+        style: size
+      });
+    });
+  };
+  __proto._getPanels = function(initialized) {
+    var _this = this;
+    var children = initialized ? getRenderingPanels(this._vanillaFlicking, this._diffResult) : this._getChildren();
+    return this.props.useFindDOMNode ? children.map(function(child, idx) {
+      return createElement(NonStrictPanel, {
+        key: child.key,
+        ref: _this._panels[idx]
+      }, child);
+    }) : children.map(function(child, idx) {
+      return createElement(StrictPanel, {
+        key: child.key,
+        ref: _this._panels[idx]
+      }, child);
+    });
+  };
+  Flicking3.defaultProps = DEFAULT_PROPS;
+  __decorate([withFlickingMethods], Flicking3.prototype, "_vanillaFlicking", void 0);
+  return Flicking3;
+}(PureComponent);
 
-    &[style*='transform'] {
-      margin-left: 0;
+// libs/shared/ui-system/src/lib/Slider/Slider.tsx
+import { getPaddedResponsiveArray } from "../../core/index.js";
+import { Box } from "../../private/Box/index.js";
+import { usePageControl } from "./hooks/usePageControl.js";
+import AutoPlay from "./plugins/AutoPlay.js";
+import { withSliderVariation } from "./variants.js";
+var Slider = withSliderVariation(forwardRef(({
+  children,
+  web_syncRef: syncRef,
+  panelWidth,
+  spacing,
+  initial = 0,
+  autoPlay = false,
+  autoPlayDurationMs,
+  loop = false,
+  align,
+  moveType,
+  controls = true,
+  offsetPaddingX,
+  offsetMarginX
+}, forwardedRef) => {
+  const ref = useRef(null);
+  const { breakpoints } = useTheme();
+  const plugins = useMemo(() => autoPlay ? [new AutoPlay({ duration: autoPlayDurationMs })] : [], [
+    autoPlay,
+    autoPlayDurationMs
+  ]);
+  const controlsArray = getPaddedResponsiveArray(breakpoints, controls);
+  const handleMoveStart = useCallback((event) => {
+    if (!event.isTrusted || controlsArray.every((value) => value)) {
+      return;
     }
+    if (controlsArray.every((value) => !value)) {
+      event.stop();
+      return;
+    }
+    const breakpointIndex = breakpoints.findIndex((breakpoint) => parseInt(breakpoint, 10) > window.innerWidth);
+    if (!controlsArray[breakpointIndex]) {
+      event.stop();
+    }
+  }, [breakpoints, controlsArray]);
+  const {
+    focusToSlide,
+    moveToSlide,
+    moveToPrevSlide,
+    moveToNextSlide,
+    moveToPrevPage,
+    moveToNextPage
+  } = usePageControl({
+    sliderRef: ref,
+    loop
+  });
+  useImperativeHandle(forwardedRef, () => ({
+    focusToSlide,
+    moveToSlide,
+    moveToPrevSlide,
+    moveToNextSlide,
+    moveToPrevPage,
+    moveToNextPage,
+    getCurrentIndex: () => {
+      var _a, _b, _c, _d;
+      return (_d = ((_a = ref.current) == null ? void 0 : _a.index) === -1 ? (_b = ref.current) == null ? void 0 : _b.defaultIndex : (_c = ref.current) == null ? void 0 : _c.index) != null ? _d : 0;
+    },
+    addEventListener: (eventName, handler) => {
+      var _a;
+      (_a = ref.current) == null ? void 0 : _a.on(eventName, handler);
+    },
+    removeEventListener: (eventName, handler) => {
+      var _a;
+      (_a = ref.current) == null ? void 0 : _a.off(eventName, handler);
+    }
+  }), [focusToSlide, moveToNextPage, moveToNextSlide, moveToPrevPage, moveToPrevSlide, moveToSlide]);
+  useEffect(() => {
+    var _a;
+    (_a = syncRef == null ? void 0 : syncRef.current) == null ? void 0 : _a.addEventListener("indexChange", focusToSlide);
+    return () => {
+      var _a2;
+      (_a2 = syncRef == null ? void 0 : syncRef.current) == null ? void 0 : _a2.removeEventListener("indexChange", focusToSlide);
+    };
+  }, [focusToSlide, syncRef]);
+  useEffect(() => {
+    var _a;
+    (_a = ref.current) == null ? void 0 : _a.on("moveStart", handleMoveStart);
+    return () => {
+      var _a2;
+      (_a2 = ref.current) == null ? void 0 : _a2.off("moveStart", handleMoveStart);
+    };
+  }, [handleMoveStart]);
+  return /* @__PURE__ */ React.createElement(Box, {
+    overflowX: "hidden",
+    px: offsetPaddingX,
+    mx: offsetMarginX
+  }, /* @__PURE__ */ React.createElement(StyledFlicking, {
+    ref,
+    align,
+    bound: true,
+    noPanelStyleOverride: true,
+    inputType: ["touch", "mouse", "pointer"],
+    renderOnlyVisible: true,
+    autoResize: true,
+    plugins,
+    defaultIndex: initial,
+    circular: loop,
+    moveType,
+    interruptable: false,
+    onWillChange: ({ index }) => {
+      var _a;
+      return (_a = ref.current) == null ? void 0 : _a.trigger("indexChange", index);
+    },
+    onSelect: ({ index }) => {
+      var _a;
+      return (_a = syncRef == null ? void 0 : syncRef.current) == null ? void 0 : _a.moveToSlide(index);
+    }
+  }, Children2.toArray(children).map((child, index) => isValidElement(child) && /* @__PURE__ */ React.createElement(Box, __spreadValues({
+    key: index,
+    width: panelWidth
+  }, index > 0 && { ml: spacing }), child))));
+}));
+var StyledFlicking = emotion_styled_browser_esm_default(Flicking2)`
+  .flicking-viewport {
+    position: relative;
+    overflow: visible;
+  }
+  .flicking-camera {
+    width: 100%;
+    height: 100%;
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+    position: relative;
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+    -ms-flex-direction: row;
+    flex-direction: row;
+    z-index: 1;
+  }
+  .flicking-camera > * {
+    -ms-flex-negative: 0;
+    flex-shrink: 0;
+  }
+  .flicking-viewport.vertical {
+    display: -webkit-inline-box;
+    display: -ms-inline-flexbox;
+    display: inline-flex;
+  }
+  .flicking-viewport.vertical > .flicking-camera {
+    display: -webkit-inline-box;
+    display: -ms-inline-flexbox;
+    display: inline-flex;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+    -ms-flex-direction: column;
+    flex-direction: column;
+  }
+  .flicking-viewport.flicking-hidden .flicking-camera > * {
+    visibility: hidden;
   }
 `;
 export {
   Slider
 };
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/** @license React v17.0.2
+ * react-is.development.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.
+ */