@telus-uds/components-base 4.0.0-beta.1 → 4.1.0

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/d1/Carousel_d184fba2a81fcd8cf3d8856fb35b2507

@@ -0,0 +1,1121 @@
+2d6fcd7f1a147720400a56b61b594512
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Carousel = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireDefault(require("react"));
+var _reactNative = require("react-native");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _useThemeTokens = require("../ThemeProvider/useThemeTokens");
+var _useTheme2 = require("../ThemeProvider/useTheme");
+var _useViewport = require("../ViewportProvider/useViewport");
+var _tokens = require("../utils/props/tokens");
+var _semantics = require("../utils/a11y/semantics");
+var _variantProp = require("../utils/props/variantProp");
+var _selectSystemProps3 = require("../utils/props/selectSystemProps");
+var _a11yProps = require("../utils/props/a11yProps");
+var _viewProps = require("../utils/props/viewProps");
+var _useCopy = require("../utils/useCopy");
+var _children = require("../utils/children");
+var _isTouchDevice = require("../utils/isTouchDevice");
+var _useResponsiveProp = require("../utils/useResponsiveProp");
+var _resolveContentMaxWidth = require("../utils/resolveContentMaxWidth");
+var _A11yInfoProvider = require("../A11yInfoProvider/A11yInfoProvider");
+var _CarouselContext = require("./CarouselContext");
+var _IconButton = require("../IconButton/IconButton");
+var _SkipLink = require("../SkipLink/SkipLink");
+var _A11yText = require("../A11yText/A11yText");
+var _CarouselStepTracker = require("./CarouselStepTracker/CarouselStepTracker");
+var _CarouselThumbnailNavigation = require("./CarouselThumbnailNavigation");
+var _CarouselTabsPanel = require("./CarouselTabs/CarouselTabsPanel");
+var _CarouselTabsPanelItem = require("./CarouselTabs/CarouselTabsPanelItem");
+var _dictionary = require("./dictionary");
+var _Box = require("../Box/Box");
+var _Constants = require("./Constants");
+var _jsxRuntime = require("react/jsx-runtime");
+var _excluded = ["tokens", "variant", "children", "itemLabel", "previousNextNavigationPosition", "stepTrackerVariant", "progressBarVariant", "previousNextIconSize", "minDistanceToCapture", "minDistanceForAction", "onAnimationStart", "onAnimationEnd", "onIndexChanged", "skipLinkHref", "tabs", "refocus", "title", "springConfig", "thumbnails", "enableDisplayMultipleItemsPerSlide", "enableHero", "panelNavigation", "tag", "accessibilityRole", "accessibilityLabel", "accessibilityLiveRegion", "copy", "slideDuration", "transitionDuration", "loopDuration", "autoPlay", "enablePeeking", "contentMaxWidth", "swipeReleaseStyle", "swipeReleaseDuration"];
+var staticStyles = _reactNative.StyleSheet.create({
+  root: {
+    backgroundColor: 'transparent',
+    justifyContent: 'center',
+    alignItems: 'center',
+    position: 'relative',
+    top: 0,
+    left: 0
+  },
+  animationControlButton: {
+    position: 'absolute',
+    zIndex: 1,
+    right: _reactNative.Platform.OS === 'web' ? undefined : 40,
+    top: 40
+  },
+  heroMainContainer: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    overflow: 'hidden',
+    zIndex: -1
+  },
+  heroSwipeArea: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    zIndex: -1,
+    flexDirection: 'row'
+  }
+});
+var selectContainerStyles = function selectContainerStyles(width) {
+  return {
+    backgroundColor: 'transparent',
+    overflow: 'hidden',
+    width: width
+  };
+};
+var selectSwipeAreaStyles = function selectSwipeAreaStyles(count, width, enablePeeking, enableDisplayMultipleItemsPerSlide) {
+  return {
+    width: width * count,
+    justifyContent: enablePeeking || enableDisplayMultipleItemsPerSlide ? 'flex-start' : 'space-between',
+    flexDirection: 'row'
+  };
+};
+var selectHeroContainerStyles = function selectHeroContainerStyles(width, hidden) {
+  return {
+    width: width,
+    visibility: hidden ? 'hidden' : 'visible'
+  };
+};
+var getDynamicPositionProperty = function getDynamicPositionProperty(areStylesAppliedOnPreviousButton) {
+  return areStylesAppliedOnPreviousButton ? _Constants.POSITION_PROPERTIES.LEFT : _Constants.POSITION_PROPERTIES.RIGHT;
+};
+var selectControlButtonPositionStyles = function selectControlButtonPositionStyles(_ref) {
+  var positionVariant = _ref.positionVariant,
+    buttonWidth = _ref.buttonWidth,
+    _ref$positionProperty = _ref.positionProperty,
+    positionProperty = _ref$positionProperty === void 0 ? getDynamicPositionProperty() : _ref$positionProperty,
+    spaceBetweenSlideAndButton = _ref.spaceBetweenSlideAndButton,
+    enablePeeking = _ref.enablePeeking,
+    enableDisplayMultipleItemsPerSlide = _ref.enableDisplayMultipleItemsPerSlide,
+    isAutoPlayEnabled = _ref.isAutoPlayEnabled,
+    viewport = _ref.viewport,
+    maxWidth = _ref.maxWidth,
+    containerWidth = _ref.containerWidth;
+  var styles = {};
+  var positionOffset = 0;
+  if (positionVariant === _Constants.POSITION_VARIANTS.EDGE) {
+    positionOffset = -1 * (buttonWidth / 2);
+  } else if (positionVariant === _Constants.POSITION_VARIANTS.INSIDE) {
+    positionOffset = _Constants.DEFAULT_POSITION_OFFSET;
+  } else if (positionVariant === _Constants.POSITION_VARIANTS.OUTSIDE) {
+    if (enablePeeking || enableDisplayMultipleItemsPerSlide || isAutoPlayEnabled && viewport === 'xs') {
+      positionOffset = 0;
+    } else {
+      positionOffset = -1 * (spaceBetweenSlideAndButton + buttonWidth);
+    }
+  }
+  if (enablePeeking) {
+    var _getPeekingProps = getPeekingProps(viewport),
+      peekingMiddleSpace = _getPeekingProps.peekingMiddleSpace,
+      peekingGap = _getPeekingProps.peekingGap;
+    var clampedMaxWidth = Math.min(maxWidth || containerWidth, containerWidth);
+    var slideRightEdge = (containerWidth + clampedMaxWidth) / 2 - peekingMiddleSpace;
+    var buttonCenter = slideRightEdge + peekingGap / 2;
+    positionOffset = containerWidth - buttonCenter - buttonWidth / 2;
+  }
+  styles[positionProperty] = positionOffset;
+  return styles;
+};
+var selectPreviousNextNavigationButtonStyles = function selectPreviousNextNavigationButtonStyles(previousNextNavigationButtonWidth, previousNextNavigationPosition, spaceBetweenSlideAndPreviousNextNavigation, isFirstSlide, isLastSlide, areStylesAppliedOnPreviousButton, enablePeeking, enableDisplayMultipleItemsPerSlide, isAutoPlayEnabled, viewport, maxWidth, containerWidth) {
+  var styles = {
+    zIndex: 1,
+    position: 'absolute'
+  };
+  if (isFirstSlide) {
+    styles.visibility = areStylesAppliedOnPreviousButton ? 'hidden' : 'visible';
+  } else if (isLastSlide) {
+    styles.visibility = areStylesAppliedOnPreviousButton ? 'visible' : 'hidden';
+  } else {
+    styles.visibility = 'visible';
+  }
+  return Object.assign({}, styles, selectControlButtonPositionStyles({
+    positionVariant: previousNextNavigationPosition,
+    buttonWidth: previousNextNavigationButtonWidth,
+    positionProperty: getDynamicPositionProperty(areStylesAppliedOnPreviousButton),
+    spaceBetweenSlideAndButton: spaceBetweenSlideAndPreviousNextNavigation,
+    enablePeeking: enablePeeking,
+    enableDisplayMultipleItemsPerSlide: enableDisplayMultipleItemsPerSlide,
+    isAutoPlayEnabled: isAutoPlayEnabled,
+    viewport: viewport,
+    maxWidth: maxWidth,
+    containerWidth: containerWidth
+  }));
+};
+var getPeekingProps = function getPeekingProps(viewport) {
+  if (viewport === 'xs' || viewport === 'sm' || viewport === 'md') {
+    return {
+      peekingFirstSpace: 48,
+      peekingGap: 16,
+      peekingLastSpace: 48,
+      peekingMarginLeft: 24,
+      peekingMarginRight: 24,
+      peekingMiddleSpace: 28
+    };
+  }
+  return {
+    peekingFirstSpace: 48,
+    peekingGap: 16,
+    peekingLastSpace: 48,
+    peekingMarginLeft: 16,
+    peekingMarginRight: 16,
+    peekingMiddleSpace: 24
+  };
+};
+var getTotalItems = function getTotalItems(enableDisplayMultipleItemsPerSlide, childrenArray, viewport) {
+  if (enableDisplayMultipleItemsPerSlide) {
+    switch (viewport) {
+      case 'xs':
+      case 'sm':
+        return childrenArray.length;
+      case 'md':
+        return Math.ceil(childrenArray.length / _Constants.ITEMS_PER_VIEWPORT_MD);
+      case 'lg':
+      case 'xl':
+        return Math.ceil(childrenArray.length / _Constants.ITEMS_PER_VIEWPORT_LG_XL);
+      default:
+        break;
+    }
+  }
+  return childrenArray.length;
+};
+var getMaximumItemsForSlide = function getMaximumItemsForSlide(enableDisplayMultipleItemsPerSlide, viewport) {
+  if (enableDisplayMultipleItemsPerSlide) {
+    switch (viewport) {
+      case 'xs':
+      case 'sm':
+        return _Constants.ITEMS_PER_VIEWPORT_XS_SM;
+      case 'md':
+        return _Constants.ITEMS_PER_VIEWPORT_MD;
+      case 'lg':
+      case 'xl':
+        return _Constants.ITEMS_PER_VIEWPORT_LG_XL;
+      default:
+        return _Constants.ITEMS_PER_VIEWPORT_XS_SM;
+    }
+  }
+  return _Constants.ITEMS_PER_VIEWPORT_XS_SM;
+};
+var selectRootContainerStyles = function selectRootContainerStyles(enableHero, viewport, enablePeeking) {
+  if (enableHero && viewport === 'xl' && _reactNative.Platform.OS === 'web') {
+    return {
+      alignItems: 'center'
+    };
+  }
+  if (enableHero) {
+    return {
+      paddingHorizontal: 16
+    };
+  }
+  if (enablePeeking) {
+    return {
+      width: '100%'
+    };
+  }
+  return {};
+};
+var selectMainContainerStyles = function selectMainContainerStyles(enableHero, viewport, maxWidth, enablePeeking) {
+  if (enableHero && viewport === 'xl' && _reactNative.Platform.OS === 'web' && !enablePeeking) {
+    return {
+      width: '100%',
+      maxWidth: maxWidth || 1200
+    };
+  }
+  if (enablePeeking) {
+    return {
+      width: '100%'
+    };
+  }
+  if (maxWidth !== null && maxWidth !== undefined) {
+    return {
+      maxWidth: maxWidth,
+      alignSelf: 'center',
+      width: '100%'
+    };
+  }
+  return {};
+};
+var selectNavigationStyles = function selectNavigationStyles(tabs, enableHero, viewport, enablePeeking, maxWidth) {
+  var marginHorizontal = 0;
+  if (enableHero && tabs) {
+    marginHorizontal = viewport === 'xl' ? _Constants.LARGE_VIEWPORT_MARGIN : _Constants.DEFAULT_VIEWPORT_MARGIN;
+  }
+  var styles = {
+    marginHorizontal: marginHorizontal
+  };
+  if (enablePeeking && maxWidth) {
+    styles.maxWidth = maxWidth;
+    styles.alignSelf = 'center';
+    styles.width = '100%';
+  }
+  return styles;
+};
+var calculateFinalWidth = function calculateFinalWidth(containerWidth, enablePeeking, viewport, maxWidth) {
+  var finalWidth = containerWidth;
+  if (enablePeeking) {
+    var _getPeekingProps2 = getPeekingProps(viewport),
+      peekingGap = _getPeekingProps2.peekingGap,
+      peekingMiddleSpace = _getPeekingProps2.peekingMiddleSpace;
+    var baseWidth = Math.min(maxWidth || containerWidth, containerWidth);
+    finalWidth = baseWidth - peekingMiddleSpace * _Constants.PEEKING_MULTIPLIER + peekingGap;
+  }
+  return finalWidth;
+};
+var selectIconStyles = function selectIconStyles(_ref2) {
+  var iconBackgroundColor = _ref2.iconBackgroundColor;
+  return {
+    backgroundColor: iconBackgroundColor
+  };
+};
+var _selectSystemProps = (0, _selectSystemProps3.selectSystemProps)([_a11yProps.a11yProps, _viewProps.viewProps]),
+  _selectSystemProps2 = (0, _slicedToArray2.default)(_selectSystemProps, 2),
+  selectProps = _selectSystemProps2[0],
+  selectedSystemPropTypes = _selectSystemProps2[1];
+var Carousel = exports.Carousel = _react.default.forwardRef(function (_ref3, ref) {
+  var _systemProps$accessib;
+  var tokens = _ref3.tokens,
+    variant = _ref3.variant,
+    children = _ref3.children,
+    _ref3$itemLabel = _ref3.itemLabel,
+    itemLabel = _ref3$itemLabel === void 0 ? 'item' : _ref3$itemLabel,
+    _ref3$previousNextNav = _ref3.previousNextNavigationPosition,
+    previousNextNavigationPosition = _ref3$previousNextNav === void 0 ? 'inside' : _ref3$previousNextNav,
+    stepTrackerVariant = _ref3.stepTrackerVariant,
+    _ref3$progressBarVari = _ref3.progressBarVariant,
+    progressBarVariant = _ref3$progressBarVari === void 0 ? {
+      style: 'subtle'
+    } : _ref3$progressBarVari,
+    _ref3$previousNextIco = _ref3.previousNextIconSize,
+    previousNextIconSize = _ref3$previousNextIco === void 0 ? 'default' : _ref3$previousNextIco,
+    _ref3$minDistanceToCa = _ref3.minDistanceToCapture,
+    minDistanceToCapture = _ref3$minDistanceToCa === void 0 ? 5 : _ref3$minDistanceToCa,
+    _ref3$minDistanceForA = _ref3.minDistanceForAction,
+    minDistanceForAction = _ref3$minDistanceForA === void 0 ? 0.2 : _ref3$minDistanceForA,
+    onAnimationStart = _ref3.onAnimationStart,
+    onAnimationEnd = _ref3.onAnimationEnd,
+    onIndexChanged = _ref3.onIndexChanged,
+    skipLinkHref = _ref3.skipLinkHref,
+    tabs = _ref3.tabs,
+    _ref3$refocus = _ref3.refocus,
+    refocus = _ref3$refocus === void 0 ? Boolean(tabs) : _ref3$refocus,
+    _ref3$title = _ref3.title,
+    title = _ref3$title === void 0 ? 'carousel' : _ref3$title,
+    _ref3$springConfig = _ref3.springConfig,
+    springConfig = _ref3$springConfig === void 0 ? undefined : _ref3$springConfig,
+    _ref3$thumbnails = _ref3.thumbnails,
+    thumbnails = _ref3$thumbnails === void 0 ? undefined : _ref3$thumbnails,
+    _ref3$enableDisplayMu = _ref3.enableDisplayMultipleItemsPerSlide,
+    enableDisplayMultipleItemsPerSlide = _ref3$enableDisplayMu === void 0 ? false : _ref3$enableDisplayMu,
+    _ref3$enableHero = _ref3.enableHero,
+    enableHero = _ref3$enableHero === void 0 ? false : _ref3$enableHero,
+    _ref3$panelNavigation = _ref3.panelNavigation,
+    panelNavigation = _ref3$panelNavigation === void 0 ? thumbnails ? (0, _jsxRuntime.jsx)(_CarouselThumbnailNavigation.CarouselThumbnailNavigation, {
+      thumbnails: thumbnails
+    }) : (0, _jsxRuntime.jsx)(_CarouselStepTracker.CarouselStepTracker, {
+      stepTrackerVariant: stepTrackerVariant,
+      progressBarVariant: progressBarVariant,
+      enableDisplayMultipleItemsPerSlide: enableDisplayMultipleItemsPerSlide
+    }) : _ref3$panelNavigation,
+    _ref3$tag = _ref3.tag,
+    tag = _ref3$tag === void 0 ? 'ul' : _ref3$tag,
+    accessibilityRole = _ref3.accessibilityRole,
+    accessibilityLabel = _ref3.accessibilityLabel,
+    _ref3$accessibilityLi = _ref3.accessibilityLiveRegion,
+    accessibilityLiveRegion = _ref3$accessibilityLi === void 0 ? 'polite' : _ref3$accessibilityLi,
+    copy = _ref3.copy,
+    _ref3$slideDuration = _ref3.slideDuration,
+    slideDuration = _ref3$slideDuration === void 0 ? 0 : _ref3$slideDuration,
+    _ref3$transitionDurat = _ref3.transitionDuration,
+    transitionDuration = _ref3$transitionDurat === void 0 ? 0 : _ref3$transitionDurat,
+    _ref3$loopDuration = _ref3.loopDuration,
+    loopDuration = _ref3$loopDuration === void 0 ? transitionDuration : _ref3$loopDuration,
+    _ref3$autoPlay = _ref3.autoPlay,
+    autoPlay = _ref3$autoPlay === void 0 ? false : _ref3$autoPlay,
+    _ref3$enablePeeking = _ref3.enablePeeking,
+    enablePeeking = _ref3$enablePeeking === void 0 ? false : _ref3$enablePeeking,
+    contentMaxWidth = _ref3.contentMaxWidth,
+    _ref3$swipeReleaseSty = _ref3.swipeReleaseStyle,
+    swipeReleaseStyle = _ref3$swipeReleaseSty === void 0 ? _Constants.SWIPE_RELEASE_STYLES.INSTANT : _ref3$swipeReleaseSty,
+    _ref3$swipeReleaseDur = _ref3.swipeReleaseDuration,
+    swipeReleaseDuration = _ref3$swipeReleaseDur === void 0 ? _Constants.DEFAULT_SWIPE_RELEASE_DURATION : _ref3$swipeReleaseDur,
+    rest = (0, _objectWithoutProperties2.default)(_ref3, _excluded);
+  var childrenArray = (0, _children.unpackFragment)(children);
+  var isTransitioningRef = _react.default.useRef(false);
+  var viewport = (0, _useViewport.useViewport)();
+  var _useTheme = (0, _useTheme2.useTheme)(),
+    themeOptions = _useTheme.themeOptions;
+  var contentMaxWidthValue = (0, _useResponsiveProp.useResponsiveProp)(contentMaxWidth);
+  var responsiveWidth = (0, _useResponsiveProp.useResponsiveProp)(themeOptions == null ? void 0 : themeOptions.contentMaxWidth);
+  var maxWidth = null;
+  if (enablePeeking || contentMaxWidth !== undefined) {
+    maxWidth = contentMaxWidthValue === undefined ? responsiveWidth : (0, _resolveContentMaxWidth.resolveContentMaxWidth)(contentMaxWidthValue, responsiveWidth);
+  }
+  var totalItems = getTotalItems(enableDisplayMultipleItemsPerSlide, childrenArray, viewport);
+  var autoPlayFeatureEnabled = autoPlay && slideDuration > 0 && transitionDuration > 0 && totalItems > 1;
+  if (!Array.isArray(childrenArray)) {
+    childrenArray = [childrenArray];
+  }
+  var getCopy = (0, _useCopy.useCopy)({
+    dictionary: _dictionary.dictionary,
+    copy: copy
+  });
+  var themeTokens = (0, _useThemeTokens.useThemeTokens)('Carousel', tokens, variant, {
+    viewport: viewport
+  });
+  var previousIcon = themeTokens.previousIcon,
+    nextIcon = themeTokens.nextIcon,
+    playIcon = themeTokens.playIcon,
+    pauseIcon = themeTokens.pauseIcon,
+    showPreviousNextNavigation = themeTokens.showPreviousNextNavigation,
+    showPanelNavigation = themeTokens.showPanelNavigation,
+    showPanelTabs = themeTokens.showPanelTabs,
+    spaceBetweenSlideAndPreviousNextNavigation = themeTokens.spaceBetweenSlideAndPreviousNextNavigation;
+  var _React$useState = _react.default.useState(0),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    activeIndex = _React$useState2[0],
+    setActiveIndex = _React$useState2[1];
+  var activeIndexRef = _react.default.useRef(activeIndex);
+  var _useA11yInfo = (0, _A11yInfoProvider.useA11yInfo)(),
+    reduceMotionEnabled = _useA11yInfo.reduceMotionEnabled;
+  var reduceMotionRef = _react.default.useRef(reduceMotionEnabled);
+  var _React$useState3 = _react.default.useState({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }),
+    _React$useState4 = (0, _slicedToArray2.default)(_React$useState3, 2),
+    containerLayout = _React$useState4[0],
+    setContainerLayout = _React$useState4[1];
+  var containerLayoutRef = _react.default.useRef(containerLayout);
+  var _React$useState5 = _react.default.useState({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }),
+    _React$useState6 = (0, _slicedToArray2.default)(_React$useState5, 2),
+    heroContainerLayout = _React$useState6[0],
+    setHeroContainerLayout = _React$useState6[1];
+  var heroContainerLayoutRef = _react.default.useRef(heroContainerLayout);
+  var _React$useState7 = _react.default.useState(0),
+    _React$useState8 = (0, _slicedToArray2.default)(_React$useState7, 2),
+    previousNextNavigationButtonWidth = _React$useState8[0],
+    setPreviousNextNavigationButtonWidth = _React$useState8[1];
+  var firstFocusRef = _react.default.useRef(null);
+  var pan = _react.default.useRef(new _reactNative.Animated.ValueXY()).current;
+  var animatedX = _react.default.useRef(0);
+  var animatedY = _react.default.useRef(0);
+  var heroPan = _react.default.useRef(new _reactNative.Animated.ValueXY()).current;
+  var heroAnimatedX = _react.default.useRef(0);
+  var heroAnimatedY = _react.default.useRef(0);
+  var _React$useState9 = _react.default.useState(false),
+    _React$useState0 = (0, _slicedToArray2.default)(_React$useState9, 2),
+    isAnimating = _React$useState0[0],
+    setIsAnimating = _React$useState0[1];
+  var _React$useState1 = _react.default.useState(autoPlayFeatureEnabled),
+    _React$useState10 = (0, _slicedToArray2.default)(_React$useState1, 2),
+    isAutoPlayEnabled = _React$useState10[0],
+    setIsAutoPlayEnabled = _React$useState10[1];
+  var _React$useState11 = _react.default.useState(autoPlayFeatureEnabled),
+    _React$useState12 = (0, _slicedToArray2.default)(_React$useState11, 2),
+    isCarouselPlaying = _React$useState12[0],
+    setisCarouselPlaying = _React$useState12[1];
+  var isSwiping = _react.default.useRef(false);
+  var autoPlayRef = _react.default.useRef(null);
+  var _React$useState13 = _react.default.useState({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }),
+    _React$useState14 = (0, _slicedToArray2.default)(_React$useState13, 2),
+    rootContainerLayout = _React$useState14[0],
+    setRootContainerLayout = _React$useState14[1];
+  var rootContainerLayoutRef = _react.default.useRef(rootContainerLayout);
+  var isFirstSlide = !activeIndex;
+  var isLastSlide = activeIndex + 1 >= totalItems;
+  var currentViewportWidth = rootContainerLayout.width;
+  var handleAnimationStart = _react.default.useCallback(function () {
+    if (typeof onAnimationStart === 'function') onAnimationStart.apply(void 0, arguments);
+    setIsAnimating(true);
+  }, [onAnimationStart]);
+  var handleAnimationEnd = _react.default.useCallback(function () {
+    var _ref4;
+    var result = (_ref4 = arguments.length - 1, _ref4 < 0 || arguments.length <= _ref4 ? undefined : arguments[_ref4]);
+    if (result != null && result.finished) {
+      if (typeof onAnimationEnd === 'function') onAnimationEnd.apply(void 0, arguments);
+      setIsAnimating(false);
+      isTransitioningRef.current = false;
+    }
+  }, [onAnimationEnd, isTransitioningRef]);
+  var updateOffset = _react.default.useCallback(function () {
+    if (enablePeeking) {
+      var _getPeekingProps3 = getPeekingProps(viewport),
+        peekingGap = _getPeekingProps3.peekingGap,
+        peekingMiddleSpace = _getPeekingProps3.peekingMiddleSpace;
+      var finalWidth;
+      var baseWidth = Math.min(maxWidth || containerLayoutRef.current.width, containerLayoutRef.current.width);
+      var slideWide = baseWidth - peekingMiddleSpace * _Constants.PEEKING_MULTIPLIER;
+      if (activeIndexRef.current === 0) {
+        finalWidth = 0;
+      } else {
+        finalWidth = (slideWide + peekingGap) * activeIndexRef.current;
+      }
+      animatedX.current = finalWidth * _Constants.NEGATIVE_MULTIPLIER;
+    } else {
+      animatedX.current = containerLayoutRef.current.width * activeIndexRef.current * _Constants.NEGATIVE_MULTIPLIER;
+    }
+    animatedY.current = 0;
+    pan.setOffset({
+      x: animatedX.current,
+      y: animatedY.current
+    });
+    pan.setValue({
+      x: 0,
+      y: 0
+    });
+    if (enableHero) {
+      heroAnimatedX.current = heroContainerLayoutRef.current.width * activeIndexRef.current * _Constants.NEGATIVE_MULTIPLIER;
+      heroAnimatedY.current = 0;
+      heroPan.setOffset({
+        x: heroAnimatedX.current,
+        y: heroAnimatedY.current
+      });
+      heroPan.setValue({
+        x: 0,
+        y: 0
+      });
+    }
+  }, [pan, animatedX, heroPan, heroAnimatedX, enableHero, viewport, enablePeeking, maxWidth]);
+  var animate = _react.default.useCallback(function (panToAnimate, toValue, toIndex) {
+    var isSwipeRelease = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var applicableTransitionDuration = isLastSlide && toIndex === 0 ? loopDuration : transitionDuration;
+    var handleAnimationEndToIndex = function handleAnimationEndToIndex() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return handleAnimationEnd.apply(void 0, [toIndex].concat(args));
+    };
+    if (reduceMotionRef.current) {
+      _reactNative.Animated.timing(panToAnimate, {
+        toValue: toValue,
+        duration: _Constants.INSTANT_ANIMATION_DURATION,
+        useNativeDriver: false
+      }).start(handleAnimationEndToIndex);
+    } else if (isSwipeRelease && swipeReleaseStyle === _Constants.SWIPE_RELEASE_STYLES.EASE_OUT) {
+      _reactNative.Animated.timing(panToAnimate, {
+        toValue: toValue,
+        duration: swipeReleaseDuration,
+        easing: _reactNative.Easing.out(_reactNative.Easing.cubic),
+        useNativeDriver: false
+      }).start(handleAnimationEndToIndex);
+    } else if (isSwiping.current || isSwipeRelease) {
+      _reactNative.Animated.timing(panToAnimate, {
+        toValue: toValue,
+        duration: _Constants.INSTANT_ANIMATION_DURATION,
+        useNativeDriver: false
+      }).start(handleAnimationEndToIndex);
+    } else if (isAutoPlayEnabled) {
+      _reactNative.Animated.timing(panToAnimate, Object.assign({}, springConfig, {
+        toValue: toValue,
+        useNativeDriver: false,
+        duration: applicableTransitionDuration * 1000
+      })).start(handleAnimationEndToIndex);
+    } else if (enablePeeking || enableDisplayMultipleItemsPerSlide) {
+      _reactNative.Animated.timing(panToAnimate, Object.assign({}, springConfig, {
+        toValue: toValue,
+        useNativeDriver: false,
+        duration: applicableTransitionDuration ? applicableTransitionDuration * 1000 : 1000
+      })).start(handleAnimationEndToIndex);
+    } else {
+      _reactNative.Animated.spring(panToAnimate, Object.assign({}, springConfig, {
+        toValue: toValue,
+        useNativeDriver: false
+      })).start(handleAnimationEndToIndex);
+    }
+  }, [springConfig, handleAnimationEnd, transitionDuration, loopDuration, isLastSlide, isAutoPlayEnabled, enablePeeking, enableDisplayMultipleItemsPerSlide, swipeReleaseStyle, swipeReleaseDuration]);
+  var stopAutoplay = _react.default.useCallback(function () {
+    if (autoPlayRef != null && autoPlayRef.current) {
+      clearTimeout(autoPlayRef == null ? void 0 : autoPlayRef.current);
+    }
+  }, []);
+  var triggerRefocus = _react.default.useCallback(function () {
+    if (refocus && _reactNative.Platform.OS === 'web') {
+      var _firstFocusRef$curren;
+      (_firstFocusRef$curren = firstFocusRef.current) == null || _firstFocusRef$curren.focus({
+        preventScroll: true,
+        focusVisible: false
+      });
+    }
+  }, [refocus, firstFocusRef]);
+  var updateIndex = _react.default.useCallback(function () {
+    var delta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    var transitionMode = arguments.length > 1 ? arguments[1] : undefined;
+    var toValue = {
+      x: 0,
+      y: 0
+    };
+    var skipChanges = !delta;
+    var calcDelta = delta;
+    var isSwipeRelease = transitionMode === _Constants.TRANSITION_MODES.SWIPE;
+    if (activeIndexRef.current <= 0 && delta < 0) {
+      skipChanges = transitionMode !== _Constants.TRANSITION_MODES.AUTOMATIC;
+      calcDelta = totalItems + delta;
+    } else if (activeIndexRef.current + 1 >= totalItems && delta > 0) {
+      skipChanges = transitionMode !== _Constants.TRANSITION_MODES.AUTOMATIC;
+      calcDelta = -1 * activeIndexRef.current + delta - 1;
+    }
+    var index = activeIndexRef.current + calcDelta;
+    if (skipChanges) {
+      isTransitioningRef.current = true;
+      animate(pan, toValue, index, isSwipeRelease);
+      if (enableHero) {
+        animate(heroPan, toValue, index, isSwipeRelease);
+      }
+      return calcDelta;
+    }
+    stopAutoplay();
+    setActiveIndex(index);
+    var finalWidth = calculateFinalWidth(containerLayoutRef.current.width, enablePeeking, viewport, maxWidth);
+    toValue.x = finalWidth * -1 * calcDelta;
+    var heroToValue = {
+      x: 0,
+      y: 0
+    };
+    heroToValue.x = heroContainerLayoutRef.current.width * -1 * calcDelta;
+    isTransitioningRef.current = true;
+    animate(pan, toValue, index, isSwipeRelease);
+    if (enableHero) {
+      animate(heroPan, heroToValue, index, isSwipeRelease);
+    }
+    if (isCarouselPlaying) {
+      stopAutoplay();
+      if (index === 0 && activeIndexRef.current + 1 === totalItems && transitionMode === _Constants.TRANSITION_MODES.AUTOMATIC) {
+        setisCarouselPlaying(false);
+      } else if (isAutoPlayEnabled) {
+        autoPlayRef.current = setTimeout(function () {
+          updateOffset();
+          handleAnimationStart(activeIndexRef.current);
+          updateIndex(slideDuration < 0 ? -1 : 1, _Constants.TRANSITION_MODES.AUTOMATIC);
+          triggerRefocus();
+        }, Math.abs(slideDuration) * 1000);
+      }
+    }
+    if (onIndexChanged) onIndexChanged(calcDelta, index);
+    return calcDelta;
+  }, [handleAnimationStart, triggerRefocus, slideDuration, updateOffset, animate, totalItems, onIndexChanged, isCarouselPlaying, stopAutoplay, isAutoPlayEnabled, viewport, enablePeeking, pan, heroPan, enableHero, maxWidth]);
+  var startAutoplay = _react.default.useCallback(function () {
+    stopAutoplay();
+    if (isAutoPlayEnabled) {
+      autoPlayRef.current = setTimeout(function () {
+        updateOffset();
+        handleAnimationStart(activeIndexRef.current);
+        updateIndex(slideDuration < 0 ? -1 : 1, _Constants.TRANSITION_MODES.AUTOMATIC);
+        triggerRefocus();
+      }, Math.abs(slideDuration) * 1000);
+    }
+  }, [handleAnimationStart, triggerRefocus, updateIndex, updateOffset, slideDuration, stopAutoplay, isAutoPlayEnabled]);
+  var fixOffsetAndGo = _react.default.useCallback(function (delta, transitionMode) {
+    updateOffset();
+    handleAnimationStart(activeIndexRef.current);
+    updateIndex(delta, transitionMode);
+    triggerRefocus();
+  }, [updateIndex, updateOffset, handleAnimationStart, triggerRefocus]);
+  var goToNeighboring = _react.default.useCallback(function () {
+    var toPrev = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var transitionMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Constants.TRANSITION_MODES.MANUAL;
+    fixOffsetAndGo(toPrev ? -1 : 1, transitionMode);
+  }, [fixOffsetAndGo]);
+  _react.default.useEffect(function () {
+    activeIndexRef.current = activeIndex;
+  }, [activeIndex]);
+  _react.default.useEffect(function () {
+    reduceMotionRef.current = reduceMotionEnabled;
+  }, [reduceMotionEnabled]);
+  _react.default.useEffect(function () {
+    containerLayoutRef.current = containerLayout;
+  }, [containerLayout]);
+  _react.default.useEffect(function () {
+    heroContainerLayoutRef.current = heroContainerLayout;
+  }, [heroContainerLayout]);
+  _react.default.useEffect(function () {
+    rootContainerLayoutRef.current = rootContainerLayout;
+  }, [rootContainerLayout]);
+  _react.default.useEffect(function () {
+    pan.x.addListener(function (_ref5) {
+      var value = _ref5.value;
+      animatedX.current = value;
+    });
+    pan.y.addListener(function (_ref6) {
+      var value = _ref6.value;
+      animatedY.current = value;
+    });
+    if (enableHero) {
+      heroPan.x.addListener(function (_ref7) {
+        var value = _ref7.value;
+        heroAnimatedX.current = value;
+      });
+      heroPan.y.addListener(function (_ref8) {
+        var value = _ref8.value;
+        heroAnimatedY.current = value;
+      });
+    }
+    if (isCarouselPlaying) {
+      startAutoplay();
+    }
+    return function () {
+      stopAutoplay();
+      pan.x.removeAllListeners();
+      pan.y.removeAllListeners();
+      if (enableHero) {
+        heroPan.x.removeAllListeners();
+        heroPan.y.removeAllListeners();
+      }
+    };
+  }, [pan.x, pan.y, heroPan.x, heroPan.y, startAutoplay, stopAutoplay, isCarouselPlaying, enableHero]);
+  _react.default.useEffect(function () {
+    var subscription = _reactNative.Dimensions.addEventListener('change', function () {
+      updateOffset();
+    });
+    return function () {
+      if (subscription.remove) {
+        subscription.remove();
+      } else {
+        _reactNative.Dimensions.removeEventListener('change', updateOffset);
+      }
+    };
+  }, [updateOffset]);
+  _react.default.useEffect(function () {
+    setIsAutoPlayEnabled(autoPlay && slideDuration > 0 && transitionDuration > 0 && totalItems > 1);
+  }, [autoPlay, slideDuration, transitionDuration, totalItems]);
+  _react.default.useEffect(function () {
+    return function () {
+      stopAutoplay();
+    };
+  }, [stopAutoplay]);
+  var onContainerLayout = function onContainerLayout(_ref9) {
+    var _ref9$nativeEvent$lay = _ref9.nativeEvent.layout,
+      x = _ref9$nativeEvent$lay.x,
+      y = _ref9$nativeEvent$lay.y,
+      width = _ref9$nativeEvent$lay.width,
+      height = _ref9$nativeEvent$lay.height;
+    return setContainerLayout(function (prevState) {
+      return Object.assign({}, prevState, {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      });
+    });
+  };
+  var onHeroContainerLayout = function onHeroContainerLayout(_ref0) {
+    var _ref0$nativeEvent$lay = _ref0.nativeEvent.layout,
+      x = _ref0$nativeEvent$lay.x,
+      y = _ref0$nativeEvent$lay.y,
+      width = _ref0$nativeEvent$lay.width,
+      height = _ref0$nativeEvent$lay.height;
+    return setHeroContainerLayout(function (prevState) {
+      return Object.assign({}, prevState, {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      });
+    });
+  };
+  var onPreviousNextNavigationButtonLayout = function onPreviousNextNavigationButtonLayout(_ref1) {
+    var width = _ref1.nativeEvent.layout.width;
+    return setPreviousNextNavigationButtonWidth(width);
+  };
+  var onRootContainerLayout = function onRootContainerLayout(_ref10) {
+    var _ref10$nativeEvent$la = _ref10.nativeEvent.layout,
+      x = _ref10$nativeEvent$la.x,
+      y = _ref10$nativeEvent$la.y,
+      width = _ref10$nativeEvent$la.width,
+      height = _ref10$nativeEvent$la.height;
+    return setRootContainerLayout(function (prevState) {
+      return Object.assign({}, prevState, {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      });
+    });
+  };
+  var isSwipeAllowed = _react.default.useCallback(function () {
+    if (totalItems === 1) {
+      return false;
+    }
+    if (_reactNative.Platform.OS === 'web') {
+      return !!(viewport === 'xs' || viewport === 'sm' || viewport === 'md' && (0, _isTouchDevice.isTouchDevice)());
+    }
+    return true;
+  }, [viewport, totalItems]);
+  var panResponder = _react.default.useMemo(function () {
+    return _reactNative.PanResponder.create({
+      onPanResponderTerminationRequest: function onPanResponderTerminationRequest() {
+        return false;
+      },
+      onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture() {
+        return true;
+      },
+      onMoveShouldSetPanResponderCapture: function onMoveShouldSetPanResponderCapture(_, gestureState) {
+        if (!isSwipeAllowed()) {
+          return false;
+        }
+        handleAnimationStart(activeIndexRef.current);
+        var allow = Math.abs(gestureState.dx) > minDistanceToCapture;
+        if (allow) {
+          isSwiping.current = true;
+          stopAutoplay();
+        }
+        return allow;
+      },
+      onPanResponderGrant: function onPanResponderGrant() {
+        updateOffset();
+      },
+      onPanResponderMove: _reactNative.Animated.event([null, {
+        dx: pan.x
+      }], {
+        useNativeDriver: false
+      }),
+      onPanResponderRelease: function onPanResponderRelease(_, gesture) {
+        if (isCarouselPlaying) {
+          startAutoplay();
+        }
+        var correction = gesture.moveX - gesture.x0;
+        isSwiping.current = false;
+        if (Math.abs(correction) < containerLayoutRef.current.width * minDistanceForAction) {
+          animate(pan, {
+            x: 0,
+            y: 0
+          }, activeIndexRef.current, true);
+        } else {
+          var delta = correction > 0 ? -1 : 1;
+          updateIndex(delta, _Constants.TRANSITION_MODES.SWIPE);
+        }
+      }
+    });
+  }, [pan, updateIndex, updateOffset, animate, isSwipeAllowed, minDistanceForAction, handleAnimationStart, minDistanceToCapture, startAutoplay, stopAutoplay, isCarouselPlaying]);
+  var heroPanResponder = _react.default.useMemo(function () {
+    return _reactNative.PanResponder.create({
+      onPanResponderTerminationRequest: function onPanResponderTerminationRequest() {
+        return false;
+      },
+      onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture() {
+        return true;
+      },
+      onMoveShouldSetPanResponderCapture: function onMoveShouldSetPanResponderCapture(_, gestureState) {
+        if (!isSwipeAllowed()) {
+          return false;
+        }
+        handleAnimationStart(activeIndexRef.current);
+        var allow = Math.abs(gestureState.dx) > minDistanceToCapture;
+        if (allow) {
+          isSwiping.current = true;
+          stopAutoplay();
+        }
+        return allow;
+      },
+      onPanResponderGrant: function onPanResponderGrant() {
+        updateOffset();
+      },
+      onPanResponderMove: _reactNative.Animated.event([null, {
+        dx: heroPan.x
+      }], {
+        useNativeDriver: false
+      }),
+      onPanResponderRelease: function onPanResponderRelease(_, gesture) {
+        if (isCarouselPlaying) {
+          startAutoplay();
+        }
+        var correction = gesture.moveX - gesture.x0;
+        isSwiping.current = false;
+        if (Math.abs(correction) < containerLayoutRef.current.width * minDistanceForAction) {
+          animate(heroPan, {
+            x: 0,
+            y: 0
+          }, activeIndexRef.current, true);
+        } else {
+          var delta = correction > 0 ? -1 : 1;
+          updateIndex(delta, _Constants.TRANSITION_MODES.SWIPE);
+        }
+      }
+    });
+  }, [heroPan, updateIndex, updateOffset, animate, isSwipeAllowed, minDistanceForAction, handleAnimationStart, minDistanceToCapture, startAutoplay, stopAutoplay, isCarouselPlaying]);
+  var goToNext = _react.default.useCallback(function () {
+    goToNeighboring();
+  }, [goToNeighboring]);
+  var goToPrev = _react.default.useCallback(function () {
+    goToNeighboring(true);
+  }, [goToNeighboring]);
+  var goTo = _react.default.useCallback(function () {
+    var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    var delta = index - activeIndexRef.current;
+    if (delta) {
+      fixOffsetAndGo(delta, _Constants.TRANSITION_MODES.MANUAL);
+    }
+  }, [fixOffsetAndGo]);
+  var previousNextIconButtonVariants = {
+    size: previousNextIconSize,
+    raised: true
+  };
+  var getCopyWithPlaceholders = _react.default.useCallback(function (copyKey) {
+    var copyText = getCopy(copyKey).replace(/%\{title\}/g, title).replace(/%\{itemLabel\}/g, itemLabel).replace(/%\{stepNumber\}/g, activeIndex + 1).replace(/%\{stepCount\}/g, totalItems);
+    return `${copyText[0].toUpperCase()}${copyText.slice(1)}`;
+  }, [activeIndex, itemLabel, getCopy, title, totalItems]);
+  var activePanelNavigation = tabs && showPanelTabs ? (0, _jsxRuntime.jsx)(_CarouselTabsPanel.CarouselTabsPanel, {
+    items: tabs
+  }) : panelNavigation;
+  var isFirstFocusContainer = Boolean(refocus && !skipLinkHref);
+  var containerRef = function containerRef(element) {
+    firstFocusRef.current = element;
+    if (ref) {
+      if (typeof ref === 'object') {
+        ref.current = element;
+      } else if (typeof ref === 'function') {
+        ref(element);
+      }
+    }
+  };
+  var systemProps = selectProps(Object.assign({}, rest, {
+    accessibilityRole: accessibilityRole,
+    accessibilityLabel: accessibilityLabel
+  }));
+  var containerAccessibilityLabel = ((_systemProps$accessib = systemProps.accessibilityLabel) != null ? _systemProps$accessib : isFirstFocusContainer) ? `${title ? `${title} ` : ''}${getCopyWithPlaceholders('stepTrackerLabel')}` : title;
+  var containerProps = Object.assign({
+    accessibilityLabel: containerAccessibilityLabel
+  }, isFirstFocusContainer && {
+    ref: containerRef,
+    focusable: true
+  });
+  var onAnimationControlButtonPress = _react.default.useCallback(function () {
+    if (isCarouselPlaying) {
+      stopAutoplay();
+    } else {
+      startAutoplay();
+    }
+    setisCarouselPlaying(function (prevState) {
+      return !prevState;
+    });
+  }, [isCarouselPlaying, stopAutoplay, startAutoplay]);
+  var handleKeyDown = _react.default.useCallback(function (event) {
+    if (isTransitioningRef.current && event.key === 'Tab') {
+      event.preventDefault();
+    }
+  }, [isTransitioningRef]);
+  return (0, _jsxRuntime.jsxs)(_reactNative.View, {
+    style: selectRootContainerStyles(enableHero, viewport, enablePeeking),
+    onLayout: onRootContainerLayout,
+    children: [(0, _jsxRuntime.jsx)(_reactNative.View, {
+      style: selectMainContainerStyles(enableHero, viewport, maxWidth, enablePeeking),
+      children: (0, _jsxRuntime.jsxs)(_CarouselContext.CarouselProvider, {
+        activeIndex: activeIndex,
+        goTo: goTo,
+        getCopyWithPlaceholders: getCopyWithPlaceholders,
+        itemLabel: itemLabel,
+        totalItems: totalItems,
+        themeTokens: themeTokens,
+        firstFocusRef: firstFocusRef,
+        refocus: refocus,
+        width: containerLayout.width,
+        maximumItemsForSlide: getMaximumItemsForSlide(enableDisplayMultipleItemsPerSlide, viewport),
+        maxWidth: maxWidth,
+        viewportWidth: currentViewportWidth,
+        children: [(0, _jsxRuntime.jsxs)(_reactNative.View, Object.assign({
+          style: [staticStyles.root, Object.assign({}, _reactNative.Platform.OS === 'web' ? {
+            outline: 'none'
+          } : {})],
+          onLayout: onContainerLayout,
+          ref: ref
+        }, systemProps, containerProps, _reactNative.Platform.OS === 'web' ? {
+          onKeyDown: handleKeyDown
+        } : {}, {
+          children: [isAutoPlayEnabled ? (0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: [staticStyles.animationControlButton, selectControlButtonPositionStyles({
+              positionVariant: previousNextNavigationPosition,
+              buttonWidth: previousNextNavigationButtonWidth,
+              positionProperty: getDynamicPositionProperty(),
+              spaceBetweenSlideAndButton: spaceBetweenSlideAndPreviousNextNavigation,
+              enablePeeking: enablePeeking,
+              enableDisplayMultipleItemsPerSlide: enableDisplayMultipleItemsPerSlide,
+              isAutoPlayEnabled: isAutoPlayEnabled,
+              viewport: viewport,
+              maxWidth: maxWidth,
+              containerWidth: containerLayout.width
+            })],
+            children: (0, _jsxRuntime.jsx)(_IconButton.IconButton, {
+              icon: isCarouselPlaying ? pauseIcon : playIcon,
+              accessibilityLabel: isCarouselPlaying ? getCopy('pauseButtonLabel') : getCopy('playButtonLabel'),
+              variant: previousNextIconButtonVariants,
+              onPress: onAnimationControlButtonPress
+            })
+          }) : null, showPreviousNextNavigation && totalItems > 1 ? (0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: selectPreviousNextNavigationButtonStyles(previousNextNavigationButtonWidth, previousNextNavigationPosition, spaceBetweenSlideAndPreviousNextNavigation, isFirstSlide, isLastSlide, true, enablePeeking, enableDisplayMultipleItemsPerSlide, isAutoPlayEnabled, viewport, maxWidth, containerLayout.width),
+            testID: "previous-button-container",
+            children: (0, _jsxRuntime.jsx)(_IconButton.IconButton, {
+              onLayout: onPreviousNextNavigationButtonLayout,
+              icon: previousIcon,
+              onPress: goToPrev,
+              variant: previousNextIconButtonVariants,
+              accessibilityLabel: getCopyWithPlaceholders('iconButtonLabel').replace('%{targetStep}', activeIndex),
+              tokens: selectIconStyles(themeTokens)
+            })
+          }) : null, Boolean(skipLinkHref) && (0, _jsxRuntime.jsx)(_SkipLink.SkipLink, {
+            ref: firstFocusRef,
+            href: skipLinkHref,
+            children: getCopyWithPlaceholders('skipLink')
+          }), !isFirstFocusContainer && (0, _jsxRuntime.jsx)(_A11yText.A11yText, {
+            accessibilityLiveRegion: !skipLinkHref && refocus ? undefined : 'polite',
+            text: getCopyWithPlaceholders('stepTrackerLabel')
+          }), (0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: selectContainerStyles(containerLayout.width),
+            children: (0, _jsxRuntime.jsx)(_reactNative.Animated.View, Object.assign({
+              style: _reactNative.StyleSheet.flatten([selectSwipeAreaStyles(totalItems, containerLayout.width, enablePeeking, enableDisplayMultipleItemsPerSlide), {
+                transform: [{
+                  translateX: pan.x
+                }, {
+                  translateY: pan.y
+                }]
+              }])
+            }, panResponder.panHandlers, (0, _semantics.getA11yPropsFromHtmlTag)(tag), {
+              accessibilityLiveRegion: accessibilityLiveRegion,
+              children: childrenArray.map(function (element, index) {
+                var hidden = !isAnimating && index !== activeIndex;
+                if (enablePeeking && !isAnimating) {
+                  hidden = false;
+                } else if (!enablePeeking && enableDisplayMultipleItemsPerSlide && !isAnimating) {
+                  var maxItemsForSlide = getMaximumItemsForSlide(enableDisplayMultipleItemsPerSlide, viewport);
+                  if (index >= activeIndex * maxItemsForSlide && index < activeIndex * maxItemsForSlide + maxItemsForSlide) {
+                    hidden = false;
+                  }
+                }
+                var clonedElement = _react.default.cloneElement(element, {
+                  elementIndex: index,
+                  hidden: hidden,
+                  enablePeeking: enablePeeking,
+                  peekingProps: getPeekingProps(viewport),
+                  enableDisplayMultipleItemsPerSlide: enableDisplayMultipleItemsPerSlide,
+                  viewport: viewport,
+                  backgroundColor: element.props.backgroundColor
+                });
+                return (0, _jsxRuntime.jsx)(_react.default.Fragment, {
+                  children: clonedElement
+                }, index.toFixed(2));
+              })
+            }))
+          }), showPreviousNextNavigation && totalItems > 1 ? (0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: selectPreviousNextNavigationButtonStyles(previousNextNavigationButtonWidth, previousNextNavigationPosition, spaceBetweenSlideAndPreviousNextNavigation, isFirstSlide, isLastSlide, false, enablePeeking, enableDisplayMultipleItemsPerSlide, isAutoPlayEnabled, viewport, maxWidth, containerLayout.width),
+            testID: "next-button-container",
+            children: (0, _jsxRuntime.jsx)(_IconButton.IconButton, {
+              onLayout: onPreviousNextNavigationButtonLayout,
+              icon: nextIcon,
+              onPress: goToNext,
+              variant: previousNextIconButtonVariants,
+              accessibilityLabel: getCopyWithPlaceholders('iconButtonLabel').replace('%{targetStep}', activeIndex + 2),
+              tokens: selectIconStyles(themeTokens)
+            })
+          }) : null]
+        })), (0, _jsxRuntime.jsx)(_reactNative.View, {
+          style: selectNavigationStyles(tabs, enableHero, viewport, enablePeeking, maxWidth),
+          children: showPanelNavigation ? activePanelNavigation : null
+        })]
+      })
+    }), enableHero && (0, _jsxRuntime.jsx)(_reactNative.View, {
+      style: staticStyles.heroMainContainer,
+      children: (0, _jsxRuntime.jsx)(_reactNative.Animated.View, Object.assign({
+        style: _reactNative.StyleSheet.flatten([staticStyles.heroSwipeArea, {
+          transform: [{
+            translateX: heroPan.x
+          }, {
+            translateY: heroPan.y
+          }]
+        }]),
+        onLayout: onHeroContainerLayout
+      }, heroPanResponder.panHandlers, (0, _semantics.getA11yPropsFromHtmlTag)(tag), {
+        accessibilityLiveRegion: accessibilityLiveRegion,
+        children: childrenArray.map(function (element, index) {
+          var hidden = !isAnimating && index !== activeIndex;
+          return (0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: selectHeroContainerStyles(heroContainerLayout.width, hidden),
+            children: (0, _jsxRuntime.jsx)(_Box.Box, {
+              flex: 1,
+              variant: {
+                background: element.props.backgroundColor
+              }
+            })
+          }, index.toFixed(2));
+        })
+      }))
+    })]
+  });
+});
+Carousel.propTypes = Object.assign({}, selectedSystemPropTypes, {
+  tokens: (0, _tokens.getTokensPropType)('Carousel'),
+  variant: _variantProp.variantProp.propType,
+  stepTrackerVariant: _variantProp.variantProp.propType,
+  progressBarVariant: _variantProp.variantProp.propType,
+  children: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.node), _propTypes.default.node]).isRequired,
+  itemLabel: _propTypes.default.string,
+  previousNextNavigationPosition: _propTypes.default.oneOf(['inside', 'outside', 'edge']),
+  previousNextIconSize: _propTypes.default.oneOf(['default', 'small', 'large']),
+  springConfig: _propTypes.default.object,
+  thumbnails: _propTypes.default.arrayOf(_propTypes.default.shape({
+    accessibilityLabel: _propTypes.default.string,
+    alt: _propTypes.default.string,
+    isVideo: _propTypes.default.bool,
+    src: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
+  })),
+  minDistanceForAction: _propTypes.default.number,
+  minDistanceToCapture: _propTypes.default.number,
+  onIndexChanged: _propTypes.default.func,
+  skipLinkHref: _propTypes.default.string,
+  tabs: _propTypes.default.arrayOf(_propTypes.default.shape(_CarouselTabsPanelItem.CarouselTabsPanelItem.propTypes || {})),
+  refocus: _propTypes.default.bool,
+  panelNavigation: _propTypes.default.element,
+  onAnimationStart: _propTypes.default.func,
+  onAnimationEnd: _propTypes.default.func,
+  panelNavigationTextDictionary: _propTypes.default.shape({
+    en: _propTypes.default.shape({
+      stepTrackerLabel: _propTypes.default.string.isRequired
+    }),
+    fr: _propTypes.default.shape({
+      stepTrackerLabel: _propTypes.default.string.isRequired
+    })
+  }),
+  accessibilityRole: _propTypes.default.string,
+  accessibilityLabel: _propTypes.default.string,
+  tag: _propTypes.default.oneOf(_semantics.layoutTags),
+  autoPlay: _propTypes.default.bool,
+  slideDuration: _propTypes.default.number,
+  transitionDuration: _propTypes.default.number,
+  loopDuration: _propTypes.default.number,
+  enablePeeking: _propTypes.default.bool,
+  enableDisplayMultipleItemsPerSlide: _propTypes.default.bool,
+  contentMaxWidth: _propTypes.default.shape({
+    xl: _propTypes.default.oneOfType([_propTypes.default.oneOf(['max', 'full']), _propTypes.default.number]),
+    lg: _propTypes.default.oneOfType([_propTypes.default.oneOf(['max', 'full']), _propTypes.default.number]),
+    md: _propTypes.default.oneOfType([_propTypes.default.oneOf(['max', 'full']), _propTypes.default.number]),
+    sm: _propTypes.default.oneOfType([_propTypes.default.oneOf(['max', 'full']), _propTypes.default.number]),
+    xs: _propTypes.default.oneOfType([_propTypes.default.oneOf(['max', 'full']), _propTypes.default.number])
+  }),
+  swipeReleaseStyle: _propTypes.default.oneOf(['instant', 'ease-out']),
+  swipeReleaseDuration: _propTypes.default.number
+});
+Carousel.displayName = 'Carousel';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_reactNative","_propTypes","_useThemeTokens","_useTheme2","_useViewport","_tokens","_semantics","_variantProp","_selectSystemProps3","_a11yProps","_viewProps","_useCopy","_children","_isTouchDevice","_useResponsiveProp","_resolveContentMaxWidth","_A11yInfoProvider","_CarouselContext","_IconButton","_SkipLink","_A11yText","_CarouselStepTracker","_CarouselThumbnailNavigation","_CarouselTabsPanel","_CarouselTabsPanelItem","_dictionary","_Box","_Constants","_jsxRuntime","_excluded","staticStyles","StyleSheet","create","root","backgroundColor","justifyContent","alignItems","position","top","left","animationControlButton","zIndex","right","Platform","OS","undefined","heroMainContainer","bottom","overflow","heroSwipeArea","flexDirection","selectContainerStyles","width","selectSwipeAreaStyles","count","enablePeeking","enableDisplayMultipleItemsPerSlide","selectHeroContainerStyles","hidden","visibility","getDynamicPositionProperty","areStylesAppliedOnPreviousButton","POSITION_PROPERTIES","LEFT","RIGHT","selectControlButtonPositionStyles","_ref","positionVariant","buttonWidth","_ref$positionProperty","positionProperty","spaceBetweenSlideAndButton","isAutoPlayEnabled","viewport","maxWidth","containerWidth","styles","positionOffset","POSITION_VARIANTS","EDGE","INSIDE","DEFAULT_POSITION_OFFSET","OUTSIDE","_getPeekingProps","getPeekingProps","peekingMiddleSpace","peekingGap","clampedMaxWidth","Math","min","slideRightEdge","buttonCenter","selectPreviousNextNavigationButtonStyles","previousNextNavigationButtonWidth","previousNextNavigationPosition","spaceBetweenSlideAndPreviousNextNavigation","isFirstSlide","isLastSlide","Object","assign","peekingFirstSpace","peekingLastSpace","peekingMarginLeft","peekingMarginRight","getTotalItems","childrenArray","length","ceil","ITEMS_PER_VIEWPORT_MD","ITEMS_PER_VIEWPORT_LG_XL","getMaximumItemsForSlide","ITEMS_PER_VIEWPORT_XS_SM","selectRootContainerStyles","enableHero","paddingHorizontal","selectMainContainerStyles","alignSelf","selectNavigationStyles","tabs","marginHorizontal","LARGE_VIEWPORT_MARGIN","DEFAULT_VIEWPORT_MARGIN","calculateFinalWidth","finalWidth","_getPeekingProps2","baseWidth","PEEKING_MULTIPLIER","selectIconStyles","_ref2","iconBackgroundColor","_selectSystemProps","selectSystemProps","a11yProps","viewProps","_selectSystemProps2","_slicedToArray2","default","selectProps","selectedSystemPropTypes","Carousel","exports","React","forwardRef","_ref3","ref","_systemProps$accessib","tokens","variant","children","_ref3$itemLabel","itemLabel","_ref3$previousNextNav","stepTrackerVariant","_ref3$progressBarVari","progressBarVariant","style","_ref3$previousNextIco","previousNextIconSize","_ref3$minDistanceToCa","minDistanceToCapture","_ref3$minDistanceForA","minDistanceForAction","onAnimationStart","onAnimationEnd","onIndexChanged","skipLinkHref","_ref3$refocus","refocus","Boolean","_ref3$title","title","_ref3$springConfig","springConfig","_ref3$thumbnails","thumbnails","_ref3$enableDisplayMu","_ref3$enableHero","_ref3$panelNavigation","panelNavigation","jsx","CarouselThumbnailNavigation","CarouselStepTracker","_ref3$tag","tag","accessibilityRole","accessibilityLabel","_ref3$accessibilityLi","accessibilityLiveRegion","copy","_ref3$slideDuration","slideDuration","_ref3$transitionDurat","transitionDuration","_ref3$loopDuration","loopDuration","_ref3$autoPlay","autoPlay","_ref3$enablePeeking","contentMaxWidth","_ref3$swipeReleaseSty","swipeReleaseStyle","SWIPE_RELEASE_STYLES","INSTANT","_ref3$swipeReleaseDur","swipeReleaseDuration","DEFAULT_SWIPE_RELEASE_DURATION","rest","_objectWithoutProperties2","unpackFragment","isTransitioningRef","useRef","useViewport","_useTheme","useTheme","themeOptions","contentMaxWidthValue","useResponsiveProp","responsiveWidth","resolveContentMaxWidth","totalItems","autoPlayFeatureEnabled","Array","isArray","getCopy","useCopy","dictionary","themeTokens","useThemeTokens","previousIcon","nextIcon","playIcon","pauseIcon","showPreviousNextNavigation","showPanelNavigation","showPanelTabs","_React$useState","useState","_React$useState2","activeIndex","setActiveIndex","activeIndexRef","_useA11yInfo","useA11yInfo","reduceMotionEnabled","reduceMotionRef","_React$useState3","x","y","height","_React$useState4","containerLayout","setContainerLayout","containerLayoutRef","_React$useState5","_React$useState6","heroContainerLayout","setHeroContainerLayout","heroContainerLayoutRef","_React$useState7","_React$useState8","setPreviousNextNavigationButtonWidth","firstFocusRef","pan","Animated","ValueXY","current","animatedX","animatedY","heroPan","heroAnimatedX","heroAnimatedY","_React$useState9","_React$useState0","isAnimating","setIsAnimating","_React$useState1","_React$useState10","setIsAutoPlayEnabled","_React$useState11","_React$useState12","isCarouselPlaying","setisCarouselPlaying","isSwiping","autoPlayRef","_React$useState13","_React$useState14","rootContainerLayout","setRootContainerLayout","rootContainerLayoutRef","currentViewportWidth","handleAnimationStart","useCallback","apply","arguments","handleAnimationEnd","_ref4","result","finished","updateOffset","_getPeekingProps3","slideWide","NEGATIVE_MULTIPLIER","setOffset","setValue","animate","panToAnimate","toValue","toIndex","isSwipeRelease","applicableTransitionDuration","handleAnimationEndToIndex","_len","args","_key","concat","timing","duration","INSTANT_ANIMATION_DURATION","useNativeDriver","start","EASE_OUT","easing","Easing","out","cubic","spring","stopAutoplay","clearTimeout","triggerRefocus","_firstFocusRef$curren","focus","preventScroll","focusVisible","updateIndex","delta","transitionMode","skipChanges","calcDelta","TRANSITION_MODES","SWIPE","AUTOMATIC","index","heroToValue","setTimeout","abs","startAutoplay","fixOffsetAndGo","goToNeighboring","toPrev","MANUAL","useEffect","addListener","_ref5","value","_ref6","_ref7","_ref8","removeAllListeners","subscription","Dimensions","addEventListener","remove","removeEventListener","onContainerLayout","_ref9","_ref9$nativeEvent$lay","nativeEvent","layout","prevState","onHeroContainerLayout","_ref0","_ref0$nativeEvent$lay","onPreviousNextNavigationButtonLayout","_ref1","onRootContainerLayout","_ref10","_ref10$nativeEvent$la","isSwipeAllowed","isTouchDevice","panResponder","useMemo","PanResponder","onPanResponderTerminationRequest","onMoveShouldSetResponderCapture","onMoveShouldSetPanResponderCapture","_","gestureState","allow","dx","onPanResponderGrant","onPanResponderMove","event","onPanResponderRelease","gesture","correction","moveX","x0","heroPanResponder","goToNext","goToPrev","goTo","previousNextIconButtonVariants","size","raised","getCopyWithPlaceholders","copyKey","copyText","replace","toUpperCase","slice","activePanelNavigation","CarouselTabsPanel","items","isFirstFocusContainer","containerRef","element","systemProps","containerAccessibilityLabel","containerProps","focusable","onAnimationControlButtonPress","handleKeyDown","key","preventDefault","jsxs","View","onLayout","CarouselProvider","maximumItemsForSlide","viewportWidth","outline","onKeyDown","IconButton","icon","onPress","testID","SkipLink","href","A11yText","text","flatten","transform","translateX","translateY","panHandlers","getA11yPropsFromHtmlTag","map","maxItemsForSlide","clonedElement","cloneElement","elementIndex","peekingProps","props","Fragment","toFixed","Box","flex","background","propTypes","getTokensPropType","variantProp","propType","PropTypes","oneOfType","arrayOf","node","isRequired","string","oneOf","object","shape","alt","isVideo","bool","src","number","func","CarouselTabsPanelItem","panelNavigationTextDictionary","en","stepTrackerLabel","fr","layoutTags","xl","lg","md","sm","xs","displayName"],"sources":["Carousel.jsx"],"sourcesContent":["import React from 'react'\nimport {\n  View,\n  Animated,\n  PanResponder,\n  StyleSheet,\n  Platform,\n  Dimensions,\n  Easing\n} from 'react-native'\nimport PropTypes from 'prop-types'\nimport { useThemeTokens } from '../ThemeProvider/useThemeTokens'\nimport { useTheme } from '../ThemeProvider/useTheme'\nimport { useViewport } from '../ViewportProvider/useViewport'\nimport { getTokensPropType } from '../utils/props/tokens'\nimport { getA11yPropsFromHtmlTag, layoutTags } from '../utils/a11y/semantics'\nimport { variantProp } from '../utils/props/variantProp'\nimport { selectSystemProps } from '../utils/props/selectSystemProps'\nimport { a11yProps } from '../utils/props/a11yProps'\nimport { viewProps } from '../utils/props/viewProps'\nimport { useCopy } from '../utils/useCopy'\nimport { unpackFragment } from '../utils/children'\nimport { isTouchDevice } from '../utils/isTouchDevice'\nimport { useResponsiveProp } from '../utils/useResponsiveProp'\nimport { resolveContentMaxWidth } from '../utils/resolveContentMaxWidth'\nimport { useA11yInfo } from '../A11yInfoProvider/A11yInfoProvider'\nimport { CarouselProvider } from './CarouselContext'\nimport { IconButton } from '../IconButton/IconButton'\nimport { SkipLink } from '../SkipLink/SkipLink'\nimport { A11yText } from '../A11yText/A11yText'\nimport { CarouselStepTracker } from './CarouselStepTracker/CarouselStepTracker'\nimport { CarouselThumbnailNavigation } from './CarouselThumbnailNavigation'\nimport { CarouselTabsPanel } from './CarouselTabs/CarouselTabsPanel'\nimport { CarouselTabsPanelItem } from './CarouselTabs/CarouselTabsPanelItem'\nimport { dictionary } from './dictionary'\nimport { Box } from '../Box/Box'\nimport {\n  ITEMS_PER_VIEWPORT_XS_SM,\n  ITEMS_PER_VIEWPORT_MD,\n  ITEMS_PER_VIEWPORT_LG_XL,\n  DEFAULT_POSITION_OFFSET,\n  LARGE_VIEWPORT_MARGIN,\n  DEFAULT_VIEWPORT_MARGIN,\n  PEEKING_MULTIPLIER,\n  NEGATIVE_MULTIPLIER,\n  TRANSITION_MODES,\n  SWIPE_RELEASE_STYLES,\n  INSTANT_ANIMATION_DURATION,\n  DEFAULT_SWIPE_RELEASE_DURATION,\n  POSITION_VARIANTS,\n  POSITION_PROPERTIES\n} from './Constants'\n\nconst staticStyles = StyleSheet.create({\n  root: {\n    backgroundColor: 'transparent',\n    justifyContent: 'center',\n    alignItems: 'center',\n    position: 'relative',\n    top: 0,\n    left: 0\n  },\n  animationControlButton: {\n    position: 'absolute',\n    zIndex: 1,\n    right: Platform.OS === 'web' ? undefined : 40,\n    top: 40\n  },\n  heroMainContainer: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    right: 0,\n    bottom: 0,\n    overflow: 'hidden',\n    zIndex: -1\n  },\n  heroSwipeArea: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    right: 0,\n    bottom: 0,\n    zIndex: -1,\n    flexDirection: 'row'\n  }\n})\n\nconst selectContainerStyles = (width) => ({\n  backgroundColor: 'transparent',\n  overflow: 'hidden',\n  width\n})\n\nconst selectSwipeAreaStyles = (\n  count,\n  width,\n  enablePeeking,\n  enableDisplayMultipleItemsPerSlide\n) => ({\n  width: width * count,\n  justifyContent:\n    enablePeeking || enableDisplayMultipleItemsPerSlide ? 'flex-start' : 'space-between',\n  flexDirection: 'row'\n})\n\nconst selectHeroContainerStyles = (width, hidden) => ({\n  width,\n  visibility: hidden ? 'hidden' : 'visible'\n})\n\nconst getDynamicPositionProperty = (areStylesAppliedOnPreviousButton) =>\n  areStylesAppliedOnPreviousButton ? POSITION_PROPERTIES.LEFT : POSITION_PROPERTIES.RIGHT\n\nconst selectControlButtonPositionStyles = ({\n  positionVariant,\n  buttonWidth,\n  positionProperty = getDynamicPositionProperty(),\n  spaceBetweenSlideAndButton,\n  enablePeeking,\n  enableDisplayMultipleItemsPerSlide,\n  isAutoPlayEnabled,\n  viewport,\n  maxWidth,\n  containerWidth\n}) => {\n  const styles = {}\n\n  let positionOffset = 0\n\n  if (positionVariant === POSITION_VARIANTS.EDGE) {\n    positionOffset = -1 * (buttonWidth / 2)\n  } else if (positionVariant === POSITION_VARIANTS.INSIDE) {\n    positionOffset = DEFAULT_POSITION_OFFSET\n  } else if (positionVariant === POSITION_VARIANTS.OUTSIDE) {\n    if (\n      enablePeeking ||\n      enableDisplayMultipleItemsPerSlide ||\n      (isAutoPlayEnabled && viewport === 'xs')\n    ) {\n      positionOffset = 0\n    } else {\n      positionOffset = -1 * (spaceBetweenSlideAndButton + buttonWidth)\n    }\n  }\n\n  if (enablePeeking) {\n    const { peekingMiddleSpace, peekingGap } = getPeekingProps(viewport)\n    const clampedMaxWidth = Math.min(maxWidth || containerWidth, containerWidth)\n    const slideRightEdge = (containerWidth + clampedMaxWidth) / 2 - peekingMiddleSpace\n    const buttonCenter = slideRightEdge + peekingGap / 2\n    positionOffset = containerWidth - buttonCenter - buttonWidth / 2\n  }\n\n  styles[positionProperty] = positionOffset\n  return styles\n}\n\nconst selectPreviousNextNavigationButtonStyles = (\n  previousNextNavigationButtonWidth,\n  previousNextNavigationPosition,\n  spaceBetweenSlideAndPreviousNextNavigation,\n  isFirstSlide,\n  isLastSlide,\n  areStylesAppliedOnPreviousButton,\n  enablePeeking,\n  enableDisplayMultipleItemsPerSlide,\n  isAutoPlayEnabled,\n  viewport,\n  maxWidth,\n  containerWidth\n) => {\n  const styles = {\n    zIndex: 1,\n    position: 'absolute'\n  }\n  if (isFirstSlide) {\n    styles.visibility = areStylesAppliedOnPreviousButton ? 'hidden' : 'visible'\n  } else if (isLastSlide) {\n    styles.visibility = areStylesAppliedOnPreviousButton ? 'visible' : 'hidden'\n  } else {\n    styles.visibility = 'visible'\n  }\n\n  return {\n    ...styles,\n    ...selectControlButtonPositionStyles({\n      positionVariant: previousNextNavigationPosition,\n      buttonWidth: previousNextNavigationButtonWidth,\n      positionProperty: getDynamicPositionProperty(areStylesAppliedOnPreviousButton),\n      spaceBetweenSlideAndButton: spaceBetweenSlideAndPreviousNextNavigation,\n      enablePeeking,\n      enableDisplayMultipleItemsPerSlide,\n      isAutoPlayEnabled,\n      viewport,\n      maxWidth,\n      containerWidth\n    })\n  }\n}\n\nconst getPeekingProps = (viewport) => {\n  if (viewport === 'xs' || viewport === 'sm' || viewport === 'md') {\n    return {\n      peekingFirstSpace: 48,\n      peekingGap: 16,\n      peekingLastSpace: 48,\n      peekingMarginLeft: 24,\n      peekingMarginRight: 24,\n      peekingMiddleSpace: 28\n    }\n  }\n  return {\n    peekingFirstSpace: 48,\n    peekingGap: 16,\n    peekingLastSpace: 48,\n    peekingMarginLeft: 16,\n    peekingMarginRight: 16,\n    peekingMiddleSpace: 24\n  }\n}\n\nconst getTotalItems = (enableDisplayMultipleItemsPerSlide, childrenArray, viewport) => {\n  if (enableDisplayMultipleItemsPerSlide) {\n    switch (viewport) {\n      case 'xs':\n      case 'sm':\n        return childrenArray.length\n      case 'md':\n        return Math.ceil(childrenArray.length / ITEMS_PER_VIEWPORT_MD)\n      case 'lg':\n      case 'xl':\n        return Math.ceil(childrenArray.length / ITEMS_PER_VIEWPORT_LG_XL)\n      default:\n        break\n    }\n  }\n  return childrenArray.length\n}\n\n/**\n * Determines the maximum number of items that can be displayed per slide based on viewport\n *\n * @param {boolean} enableDisplayMultipleItemsPerSlide - Flag indicating whether multiple items per slide is enabled\n * @param {string} viewport - The current viewport size ('xs', 'sm', 'md', 'lg', 'xl')\n * @returns {number} The maximum number of items that can be displayed per slide\n */\nconst getMaximumItemsForSlide = (enableDisplayMultipleItemsPerSlide, viewport) => {\n  if (enableDisplayMultipleItemsPerSlide) {\n    switch (viewport) {\n      case 'xs':\n      case 'sm':\n        return ITEMS_PER_VIEWPORT_XS_SM\n      case 'md':\n        return ITEMS_PER_VIEWPORT_MD\n      case 'lg':\n      case 'xl':\n        return ITEMS_PER_VIEWPORT_LG_XL\n      default:\n        return ITEMS_PER_VIEWPORT_XS_SM\n    }\n  }\n  return ITEMS_PER_VIEWPORT_XS_SM\n}\n\nconst selectRootContainerStyles = (enableHero, viewport, enablePeeking) => {\n  if (enableHero && viewport === 'xl' && Platform.OS === 'web') {\n    return {\n      alignItems: 'center'\n    }\n  }\n  if (enableHero) {\n    return {\n      paddingHorizontal: 16\n    }\n  }\n  if (enablePeeking) {\n    return {\n      width: '100%'\n    }\n  }\n  return {}\n}\n\nconst selectMainContainerStyles = (enableHero, viewport, maxWidth, enablePeeking) => {\n  if (enableHero && viewport === 'xl' && Platform.OS === 'web' && !enablePeeking) {\n    return {\n      width: '100%',\n      maxWidth: maxWidth || 1200\n    }\n  }\n  if (enablePeeking) {\n    return {\n      width: '100%'\n    }\n  }\n  if (maxWidth !== null && maxWidth !== undefined) {\n    return {\n      maxWidth,\n      alignSelf: 'center',\n      width: '100%'\n    }\n  }\n  return {}\n}\n\nconst selectNavigationStyles = (tabs, enableHero, viewport, enablePeeking, maxWidth) => {\n  let marginHorizontal = 0\n\n  if (enableHero && tabs) {\n    marginHorizontal = viewport === 'xl' ? LARGE_VIEWPORT_MARGIN : DEFAULT_VIEWPORT_MARGIN\n  }\n\n  const styles = {\n    marginHorizontal\n  }\n\n  if (enablePeeking && maxWidth) {\n    styles.maxWidth = maxWidth\n    styles.alignSelf = 'center'\n    styles.width = '100%'\n  }\n\n  return styles\n}\n\n/**\n * Calculates the final width of a carousel container based on the provided parameters.\n *\n * @param {number} containerWidth - The width of the carousel container.\n * @param {boolean} enablePeeking - Flag indicating whether peeking is enabled.\n * @param {Object} viewport - The viewport configuration object used to determine peeking properties.\n * @param {number} maxWidth - The maximum width constraint for the carousel content.\n * @returns {number} The calculated final width of the carousel container.\n */\nconst calculateFinalWidth = (containerWidth, enablePeeking, viewport, maxWidth) => {\n  let finalWidth = containerWidth\n\n  if (enablePeeking) {\n    const { peekingGap, peekingMiddleSpace } = getPeekingProps(viewport)\n    const baseWidth = Math.min(maxWidth || containerWidth, containerWidth)\n    finalWidth = baseWidth - peekingMiddleSpace * PEEKING_MULTIPLIER + peekingGap\n  }\n\n  return finalWidth\n}\n\nconst selectIconStyles = ({ iconBackgroundColor }) => ({ backgroundColor: iconBackgroundColor })\n\nconst [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps])\n\n/**\n * Carousel is a general-purpose content slider that can be used to render content in terms of slides.\n\n  ## Usage\n  - `Carousel` is a top-level export from `@telus-uds/components-base` which is used to render a Carousel\n  - Immediately within `Carousel`, individual slides are wrapped in `CarouselItem` for the top-level `Carousel` to know how to identify an individual slide\n  - You can use any UDS component or other platform-specific component, (based on the platform you're rendering) to achieve any desired layout\n  - By default, Carousel takea all the `width` available to it and the `height` is determined based on the content in the slide with more content\n  - You may want to wrap Carousel in other layout components like `Box`, `FlexGrid` etc, to achieve a responsive layout of your need\n\n  ## `useCarousel` custom hook\n\n  ```jsx\n  import { useCarousel } from '@telus-uds/components-base'\n\n  const SomeComponentWithinCarouselItem = () => {\n    const {\n      activeIndex,\n      totalItems,\n      width,\n      goTo\n    } = useCarousel()\n    return <Text>Hi!</Text>\n  }\n  ```\n\n  You can use `useCarousel` to hook into internal state of the Carousel component like:\n  - `activeIndex`: Index of the current slide\n  - `totalItems`: Total number of items/slides passed to the Carousel\n  - `width`: Width of the individual carousel slide\n  - `goTo`: A function to go to a particular slide by passing the index of that slide, e.g: goTo(0) where `0` is the index of the first slide\n\n  ## Accessibility\n\n  - Top-level `Carousel` and `CarouselItem` can take all possible React Native's `View` and `a11y` props\n  - If your slide contains input elements like buttons, you may want to configure them to be only focusable when `activeIndex` is equal to the current slide index in order to avoid tabbing going between slides\n\n  ## Platform considerations\n  The component is available on both native platforms and web.\n\n  ## Other considerations\n  - You may want to use the same kind of layout in all your slides to avoid visual and height differences\n  - `previous` and `next` navigation buttons are automatically removed in `sm` and `xs` viewports, as these smaller viewports offers swipe functionality\n\n  ## Tokens\n\n  You can override the following tokens in exceptional circumstances:\n  - `previousIcon` - Icon of the previous button\n  - `nextIcon` - Icon of the next button\n  - `showPreviousNextNavigation` - If you want to show/hide the previous/next navigation\n  - `showPanelNavigation` - If you want to show/hide the panel navigation\n  - `spaceBetweenSlideAndPreviousNextNavigation` - Horizontal space between slide and previous/next navigational buttons\n  - `spaceBetweenSlideAndPanelNavigation` - Vertical space between slide area and panel navigation area\n */\nexport const Carousel = React.forwardRef(\n  (\n    {\n      tokens,\n      variant,\n      children,\n      itemLabel = 'item',\n      previousNextNavigationPosition = 'inside',\n      stepTrackerVariant,\n      progressBarVariant = { style: 'subtle' },\n      previousNextIconSize = 'default',\n      minDistanceToCapture = 5,\n      minDistanceForAction = 0.2,\n      onAnimationStart,\n      onAnimationEnd,\n      onIndexChanged,\n      skipLinkHref,\n      tabs,\n      refocus = Boolean(tabs),\n      title = 'carousel',\n      springConfig = undefined,\n      thumbnails = undefined,\n      enableDisplayMultipleItemsPerSlide = false,\n      enableHero = false,\n      panelNavigation = thumbnails ? (\n        <CarouselThumbnailNavigation thumbnails={thumbnails} />\n      ) : (\n        <CarouselStepTracker\n          stepTrackerVariant={stepTrackerVariant}\n          progressBarVariant={progressBarVariant}\n          enableDisplayMultipleItemsPerSlide={enableDisplayMultipleItemsPerSlide}\n        />\n      ),\n      tag = 'ul',\n      accessibilityRole,\n      accessibilityLabel,\n      accessibilityLiveRegion = 'polite',\n      copy,\n      slideDuration = 0,\n      transitionDuration = 0,\n      loopDuration = transitionDuration,\n      autoPlay = false,\n      enablePeeking = false,\n      contentMaxWidth,\n      swipeReleaseStyle = SWIPE_RELEASE_STYLES.INSTANT,\n      swipeReleaseDuration = DEFAULT_SWIPE_RELEASE_DURATION,\n      ...rest\n    },\n    ref\n  ) => {\n    let childrenArray = unpackFragment(children)\n    const isTransitioningRef = React.useRef(false)\n    const viewport = useViewport()\n    const { themeOptions } = useTheme()\n\n    const contentMaxWidthValue = useResponsiveProp(contentMaxWidth)\n    const responsiveWidth = useResponsiveProp(themeOptions?.contentMaxWidth)\n\n    let maxWidth = null\n    if (enablePeeking || contentMaxWidth !== undefined) {\n      maxWidth =\n        contentMaxWidthValue === undefined\n          ? responsiveWidth\n          : resolveContentMaxWidth(contentMaxWidthValue, responsiveWidth)\n    }\n\n    const totalItems = getTotalItems(enableDisplayMultipleItemsPerSlide, childrenArray, viewport)\n    const autoPlayFeatureEnabled =\n      autoPlay && slideDuration > 0 && transitionDuration > 0 && totalItems > 1\n    // if `Carousel` only has one `CarouselItem`, convert this to a single-item array\n    if (!Array.isArray(childrenArray)) {\n      childrenArray = [childrenArray]\n    }\n    const getCopy = useCopy({ dictionary, copy })\n\n    const themeTokens = useThemeTokens('Carousel', tokens, variant, {\n      viewport\n    })\n    const {\n      previousIcon,\n      nextIcon,\n      playIcon,\n      pauseIcon,\n      showPreviousNextNavigation,\n      showPanelNavigation,\n      showPanelTabs,\n      spaceBetweenSlideAndPreviousNextNavigation\n    } = themeTokens\n    const [activeIndex, setActiveIndex] = React.useState(0)\n    const activeIndexRef = React.useRef(activeIndex)\n    const { reduceMotionEnabled } = useA11yInfo()\n    const reduceMotionRef = React.useRef(reduceMotionEnabled)\n    const [containerLayout, setContainerLayout] = React.useState({\n      x: 0,\n      y: 0,\n      width: 0,\n      height: 0\n    })\n    const containerLayoutRef = React.useRef(containerLayout)\n    const [heroContainerLayout, setHeroContainerLayout] = React.useState({\n      x: 0,\n      y: 0,\n      width: 0,\n      height: 0\n    })\n    const heroContainerLayoutRef = React.useRef(heroContainerLayout)\n\n    const [previousNextNavigationButtonWidth, setPreviousNextNavigationButtonWidth] =\n      React.useState(0)\n    const firstFocusRef = React.useRef(null)\n    const pan = React.useRef(new Animated.ValueXY()).current\n    const animatedX = React.useRef(0)\n    const animatedY = React.useRef(0)\n    const heroPan = React.useRef(new Animated.ValueXY()).current\n    const heroAnimatedX = React.useRef(0)\n    const heroAnimatedY = React.useRef(0)\n    const [isAnimating, setIsAnimating] = React.useState(false)\n    /**\n     * While having the same starting point, `isAutoPlayEnabled` and `isCarouselPlaying` are different states\n     *\n     * `isAutoPlayEnabled` is a state to determine if the autoplay feature is enabled or disabled\n     * `isCarouselPlaying` is a state to determine if the carousel is currently playing or paused\n     */\n    const [isAutoPlayEnabled, setIsAutoPlayEnabled] = React.useState(autoPlayFeatureEnabled)\n    const [isCarouselPlaying, setisCarouselPlaying] = React.useState(autoPlayFeatureEnabled)\n    const isSwiping = React.useRef(false)\n    const autoPlayRef = React.useRef(null)\n\n    const [rootContainerLayout, setRootContainerLayout] = React.useState({\n      x: 0,\n      y: 0,\n      width: 0,\n      height: 0\n    })\n    const rootContainerLayoutRef = React.useRef(rootContainerLayout)\n\n    const isFirstSlide = !activeIndex\n    const isLastSlide = activeIndex + 1 >= totalItems\n    const currentViewportWidth = rootContainerLayout.width\n\n    const handleAnimationStart = React.useCallback(\n      (...args) => {\n        if (typeof onAnimationStart === 'function') onAnimationStart(...args)\n        setIsAnimating(true)\n      },\n      [onAnimationStart]\n    )\n    const handleAnimationEnd = React.useCallback(\n      (...args) => {\n        const result = args[args.length - 1]\n        if (result?.finished) {\n          if (typeof onAnimationEnd === 'function') onAnimationEnd(...args)\n          setIsAnimating(false)\n          isTransitioningRef.current = false\n        }\n      },\n      [onAnimationEnd, isTransitioningRef]\n    )\n\n    const updateOffset = React.useCallback(() => {\n      if (enablePeeking) {\n        const { peekingGap, peekingMiddleSpace } = getPeekingProps(viewport)\n\n        let finalWidth\n        const baseWidth = Math.min(\n          maxWidth || containerLayoutRef.current.width,\n          containerLayoutRef.current.width\n        )\n        const slideWide = baseWidth - peekingMiddleSpace * PEEKING_MULTIPLIER\n\n        if (activeIndexRef.current === 0) {\n          finalWidth = 0\n        } else {\n          finalWidth = (slideWide + peekingGap) * activeIndexRef.current\n        }\n\n        animatedX.current = finalWidth * NEGATIVE_MULTIPLIER\n      } else {\n        animatedX.current =\n          containerLayoutRef.current.width * activeIndexRef.current * NEGATIVE_MULTIPLIER\n      }\n\n      animatedY.current = 0\n      pan.setOffset({\n        x: animatedX.current,\n        y: animatedY.current\n      })\n      pan.setValue({ x: 0, y: 0 })\n\n      if (enableHero) {\n        heroAnimatedX.current =\n          heroContainerLayoutRef.current.width * activeIndexRef.current * NEGATIVE_MULTIPLIER\n        heroAnimatedY.current = 0\n        heroPan.setOffset({\n          x: heroAnimatedX.current,\n          y: heroAnimatedY.current\n        })\n        heroPan.setValue({ x: 0, y: 0 })\n      }\n    }, [pan, animatedX, heroPan, heroAnimatedX, enableHero, viewport, enablePeeking, maxWidth])\n\n    const animate = React.useCallback(\n      (panToAnimate, toValue, toIndex, isSwipeRelease = false) => {\n        const applicableTransitionDuration =\n          isLastSlide && toIndex === 0 ? loopDuration : transitionDuration\n        const handleAnimationEndToIndex = (...args) => handleAnimationEnd(toIndex, ...args)\n        if (reduceMotionRef.current) {\n          Animated.timing(panToAnimate, {\n            toValue,\n            duration: INSTANT_ANIMATION_DURATION,\n            useNativeDriver: false\n          }).start(handleAnimationEndToIndex)\n        } else if (isSwipeRelease && swipeReleaseStyle === SWIPE_RELEASE_STYLES.EASE_OUT) {\n          Animated.timing(panToAnimate, {\n            toValue,\n            duration: swipeReleaseDuration,\n            easing: Easing.out(Easing.cubic),\n            useNativeDriver: false\n          }).start(handleAnimationEndToIndex)\n        } else if (isSwiping.current || isSwipeRelease) {\n          Animated.timing(panToAnimate, {\n            toValue,\n            duration: INSTANT_ANIMATION_DURATION,\n            useNativeDriver: false\n          }).start(handleAnimationEndToIndex)\n        } else if (isAutoPlayEnabled) {\n          Animated.timing(panToAnimate, {\n            ...springConfig,\n            toValue,\n            useNativeDriver: false,\n            duration: applicableTransitionDuration * 1000\n          }).start(handleAnimationEndToIndex)\n        } else if (enablePeeking || enableDisplayMultipleItemsPerSlide) {\n          Animated.timing(panToAnimate, {\n            ...springConfig,\n            toValue,\n            useNativeDriver: false,\n            duration: applicableTransitionDuration ? applicableTransitionDuration * 1000 : 1000\n          }).start(handleAnimationEndToIndex)\n        } else {\n          Animated.spring(panToAnimate, {\n            ...springConfig,\n            toValue,\n            useNativeDriver: false\n          }).start(handleAnimationEndToIndex)\n        }\n      },\n      [\n        springConfig,\n        handleAnimationEnd,\n        transitionDuration,\n        loopDuration,\n        isLastSlide,\n        isAutoPlayEnabled,\n        enablePeeking,\n        enableDisplayMultipleItemsPerSlide,\n        swipeReleaseStyle,\n        swipeReleaseDuration\n      ]\n    )\n\n    const stopAutoplay = React.useCallback(() => {\n      if (autoPlayRef?.current) {\n        clearTimeout(autoPlayRef?.current)\n      }\n    }, [])\n\n    const triggerRefocus = React.useCallback(() => {\n      if (refocus && Platform.OS === 'web') {\n        firstFocusRef.current?.focus({ preventScroll: true, focusVisible: false })\n      }\n    }, [refocus, firstFocusRef])\n\n    const updateIndex = React.useCallback(\n      (delta = 1, transitionMode) => {\n        const toValue = { x: 0, y: 0 }\n        let skipChanges = !delta\n        let calcDelta = delta\n        const isSwipeRelease = transitionMode === TRANSITION_MODES.SWIPE\n        if (activeIndexRef.current <= 0 && delta < 0) {\n          skipChanges = transitionMode !== TRANSITION_MODES.AUTOMATIC\n          calcDelta = totalItems + delta\n        } else if (activeIndexRef.current + 1 >= totalItems && delta > 0) {\n          skipChanges = transitionMode !== TRANSITION_MODES.AUTOMATIC\n          calcDelta = -1 * activeIndexRef.current + delta - 1\n        }\n\n        const index = activeIndexRef.current + calcDelta\n        if (skipChanges) {\n          isTransitioningRef.current = true\n          animate(pan, toValue, index, isSwipeRelease)\n\n          if (enableHero) {\n            animate(heroPan, toValue, index, isSwipeRelease)\n          }\n          return calcDelta\n        }\n\n        stopAutoplay()\n        setActiveIndex(index)\n\n        const finalWidth = calculateFinalWidth(\n          containerLayoutRef.current.width,\n          enablePeeking,\n          viewport,\n          maxWidth\n        )\n\n        toValue.x = finalWidth * -1 * calcDelta\n        const heroToValue = { x: 0, y: 0 }\n        heroToValue.x = heroContainerLayoutRef.current.width * -1 * calcDelta\n        isTransitioningRef.current = true\n        animate(pan, toValue, index, isSwipeRelease)\n        if (enableHero) {\n          animate(heroPan, heroToValue, index, isSwipeRelease)\n        }\n        if (isCarouselPlaying) {\n          stopAutoplay()\n          if (\n            index === 0 &&\n            activeIndexRef.current + 1 === totalItems &&\n            transitionMode === TRANSITION_MODES.AUTOMATIC\n          ) {\n            setisCarouselPlaying(false)\n          } else if (isAutoPlayEnabled) {\n            autoPlayRef.current = setTimeout(() => {\n              updateOffset()\n              handleAnimationStart(activeIndexRef.current)\n              updateIndex(slideDuration < 0 ? -1 : 1, TRANSITION_MODES.AUTOMATIC)\n              triggerRefocus()\n            }, Math.abs(slideDuration) * 1000)\n          }\n        }\n        if (onIndexChanged) onIndexChanged(calcDelta, index)\n        return calcDelta\n      },\n      [\n        handleAnimationStart,\n        triggerRefocus,\n        slideDuration,\n        updateOffset,\n        animate,\n        totalItems,\n        onIndexChanged,\n        isCarouselPlaying,\n        stopAutoplay,\n        isAutoPlayEnabled,\n        viewport,\n        enablePeeking,\n        pan,\n        heroPan,\n        enableHero,\n        maxWidth\n      ]\n    )\n\n    const startAutoplay = React.useCallback(() => {\n      stopAutoplay()\n      if (isAutoPlayEnabled) {\n        autoPlayRef.current = setTimeout(() => {\n          updateOffset()\n          handleAnimationStart(activeIndexRef.current)\n          updateIndex(slideDuration < 0 ? -1 : 1, TRANSITION_MODES.AUTOMATIC)\n          triggerRefocus()\n        }, Math.abs(slideDuration) * 1000)\n      }\n    }, [\n      handleAnimationStart,\n      triggerRefocus,\n      updateIndex,\n      updateOffset,\n      slideDuration,\n      stopAutoplay,\n      isAutoPlayEnabled\n    ])\n\n    const fixOffsetAndGo = React.useCallback(\n      (delta, transitionMode) => {\n        updateOffset()\n        handleAnimationStart(activeIndexRef.current)\n        updateIndex(delta, transitionMode)\n        triggerRefocus()\n      },\n      [updateIndex, updateOffset, handleAnimationStart, triggerRefocus]\n    )\n\n    const goToNeighboring = React.useCallback(\n      (toPrev = false, transitionMode = TRANSITION_MODES.MANUAL) => {\n        fixOffsetAndGo(toPrev ? -1 : 1, transitionMode)\n      },\n      [fixOffsetAndGo]\n    )\n\n    React.useEffect(() => {\n      activeIndexRef.current = activeIndex\n    }, [activeIndex])\n\n    React.useEffect(() => {\n      reduceMotionRef.current = reduceMotionEnabled\n    }, [reduceMotionEnabled])\n\n    React.useEffect(() => {\n      containerLayoutRef.current = containerLayout\n    }, [containerLayout])\n\n    React.useEffect(() => {\n      heroContainerLayoutRef.current = heroContainerLayout\n    }, [heroContainerLayout])\n\n    React.useEffect(() => {\n      rootContainerLayoutRef.current = rootContainerLayout\n    }, [rootContainerLayout])\n\n    React.useEffect(() => {\n      pan.x.addListener(({ value }) => {\n        animatedX.current = value\n      })\n      pan.y.addListener(({ value }) => {\n        animatedY.current = value\n      })\n      if (enableHero) {\n        heroPan.x.addListener(({ value }) => {\n          heroAnimatedX.current = value\n        })\n        heroPan.y.addListener(({ value }) => {\n          heroAnimatedY.current = value\n        })\n      }\n      if (isCarouselPlaying) {\n        startAutoplay()\n      }\n      return () => {\n        stopAutoplay()\n        pan.x.removeAllListeners()\n        pan.y.removeAllListeners()\n        if (enableHero) {\n          heroPan.x.removeAllListeners()\n          heroPan.y.removeAllListeners()\n        }\n      }\n    }, [\n      pan.x,\n      pan.y,\n      heroPan.x,\n      heroPan.y,\n      startAutoplay,\n      stopAutoplay,\n      isCarouselPlaying,\n      enableHero\n    ])\n\n    React.useEffect(() => {\n      const subscription = Dimensions.addEventListener('change', () => {\n        updateOffset()\n      })\n\n      return () => {\n        if (subscription.remove) {\n          subscription.remove()\n        } else {\n          Dimensions.removeEventListener('change', updateOffset)\n        }\n      }\n    }, [updateOffset])\n\n    React.useEffect(() => {\n      setIsAutoPlayEnabled(\n        autoPlay && slideDuration > 0 && transitionDuration > 0 && totalItems > 1\n      )\n    }, [autoPlay, slideDuration, transitionDuration, totalItems])\n\n    React.useEffect(() => {\n      return () => {\n        stopAutoplay()\n      }\n    }, [stopAutoplay])\n\n    const onContainerLayout = ({\n      nativeEvent: {\n        layout: { x, y, width, height }\n      }\n    }) => setContainerLayout((prevState) => ({ ...prevState, x, y, width, height }))\n\n    const onHeroContainerLayout = ({\n      nativeEvent: {\n        layout: { x, y, width, height }\n      }\n    }) => setHeroContainerLayout((prevState) => ({ ...prevState, x, y, width, height }))\n\n    const onPreviousNextNavigationButtonLayout = ({\n      nativeEvent: {\n        layout: { width }\n      }\n    }) => setPreviousNextNavigationButtonWidth(width)\n\n    const onRootContainerLayout = ({\n      nativeEvent: {\n        layout: { x, y, width, height }\n      }\n    }) => setRootContainerLayout((prevState) => ({ ...prevState, x, y, width, height }))\n\n    const isSwipeAllowed = React.useCallback(() => {\n      if (totalItems === 1) {\n        return false\n      }\n      if (Platform.OS === 'web') {\n        return !!(viewport === 'xs' || viewport === 'sm' || (viewport === 'md' && isTouchDevice()))\n      }\n      return true\n    }, [viewport, totalItems])\n\n    const panResponder = React.useMemo(\n      () =>\n        PanResponder.create({\n          onPanResponderTerminationRequest: () => false,\n          onMoveShouldSetResponderCapture: () => true,\n          onMoveShouldSetPanResponderCapture: (_, gestureState) => {\n            if (!isSwipeAllowed()) {\n              return false\n            }\n\n            handleAnimationStart(activeIndexRef.current)\n\n            const allow = Math.abs(gestureState.dx) > minDistanceToCapture\n\n            if (allow) {\n              isSwiping.current = true\n              stopAutoplay()\n            }\n\n            return allow\n          },\n          onPanResponderGrant: () => {\n            updateOffset()\n          },\n          onPanResponderMove: Animated.event([null, { dx: pan.x }], {\n            useNativeDriver: false\n          }),\n          onPanResponderRelease: (_, gesture) => {\n            if (isCarouselPlaying) {\n              startAutoplay()\n            }\n            const correction = gesture.moveX - gesture.x0\n\n            isSwiping.current = false\n\n            if (Math.abs(correction) < containerLayoutRef.current.width * minDistanceForAction) {\n              animate(pan, { x: 0, y: 0 }, activeIndexRef.current, true)\n            } else {\n              const delta = correction > 0 ? -1 : 1\n              updateIndex(delta, TRANSITION_MODES.SWIPE)\n            }\n          }\n        }),\n      [\n        pan,\n        updateIndex,\n        updateOffset,\n        animate,\n        isSwipeAllowed,\n        minDistanceForAction,\n        handleAnimationStart,\n        minDistanceToCapture,\n        startAutoplay,\n        stopAutoplay,\n        isCarouselPlaying\n      ]\n    )\n\n    const heroPanResponder = React.useMemo(\n      () =>\n        PanResponder.create({\n          onPanResponderTerminationRequest: () => false,\n          onMoveShouldSetResponderCapture: () => true,\n          onMoveShouldSetPanResponderCapture: (_, gestureState) => {\n            if (!isSwipeAllowed()) {\n              return false\n            }\n\n            handleAnimationStart(activeIndexRef.current)\n\n            const allow = Math.abs(gestureState.dx) > minDistanceToCapture\n\n            if (allow) {\n              isSwiping.current = true\n              stopAutoplay()\n            }\n\n            return allow\n          },\n          onPanResponderGrant: () => {\n            updateOffset()\n          },\n          onPanResponderMove: Animated.event([null, { dx: heroPan.x }], {\n            useNativeDriver: false\n          }),\n          onPanResponderRelease: (_, gesture) => {\n            if (isCarouselPlaying) {\n              startAutoplay()\n            }\n            const correction = gesture.moveX - gesture.x0\n\n            isSwiping.current = false\n\n            if (Math.abs(correction) < containerLayoutRef.current.width * minDistanceForAction) {\n              animate(heroPan, { x: 0, y: 0 }, activeIndexRef.current, true)\n            } else {\n              const delta = correction > 0 ? -1 : 1\n              updateIndex(delta, TRANSITION_MODES.SWIPE)\n            }\n          }\n        }),\n      [\n        heroPan,\n        updateIndex,\n        updateOffset,\n        animate,\n        isSwipeAllowed,\n        minDistanceForAction,\n        handleAnimationStart,\n        minDistanceToCapture,\n        startAutoplay,\n        stopAutoplay,\n        isCarouselPlaying\n      ]\n    )\n\n    const goToNext = React.useCallback(() => {\n      goToNeighboring()\n    }, [goToNeighboring])\n\n    const goToPrev = React.useCallback(() => {\n      goToNeighboring(true)\n    }, [goToNeighboring])\n\n    const goTo = React.useCallback(\n      (index = 0) => {\n        const delta = index - activeIndexRef.current\n        if (delta) {\n          fixOffsetAndGo(delta, TRANSITION_MODES.MANUAL)\n        }\n      },\n      [fixOffsetAndGo]\n    )\n\n    // @TODO: - these are Allium-theme variants and won't have any effect in themes that don't implement them.\n    // Normally we avoid setting variants of subcomponents, however this could be re-considered.\n    // Related discussion - https://github.com/telus/universal-design-system/issues/1549\n    const previousNextIconButtonVariants = {\n      size: previousNextIconSize,\n      raised: true\n    }\n\n    const getCopyWithPlaceholders = React.useCallback(\n      (copyKey) => {\n        const copyText = getCopy(copyKey)\n          .replace(/%\\{title\\}/g, title)\n          .replace(/%\\{itemLabel\\}/g, itemLabel)\n          .replace(/%\\{stepNumber\\}/g, activeIndex + 1)\n          .replace(/%\\{stepCount\\}/g, totalItems)\n\n        // First word might be a lowercase placeholder: capitalize the first letter\n        return `${copyText[0].toUpperCase()}${copyText.slice(1)}`\n      },\n      [activeIndex, itemLabel, getCopy, title, totalItems]\n    )\n\n    const activePanelNavigation =\n      tabs && showPanelTabs ? <CarouselTabsPanel items={tabs} /> : panelNavigation\n\n    const isFirstFocusContainer = Boolean(refocus && !skipLinkHref)\n    const containerRef = (element) => {\n      // Apply both firstFocusRef to the container\n      firstFocusRef.current = element\n      // Also apply forwarded ref if there is one (which could be a function ref)\n      if (ref) {\n        if (typeof ref === 'object') {\n          // eslint-disable-next-line no-param-reassign\n          ref.current = element\n        } else if (typeof ref === 'function') {\n          ref(element)\n        }\n      }\n    }\n\n    const systemProps = selectProps({\n      ...rest,\n      accessibilityRole,\n      accessibilityLabel\n    })\n\n    // If container isn't used for focus, give it a label of title if none is passed in,\n    // otherwise read the current position on focus\n    const containerAccessibilityLabel =\n      systemProps.accessibilityLabel ?? isFirstFocusContainer\n        ? `${title ? `${title} ` : ''}${getCopyWithPlaceholders('stepTrackerLabel')}`\n        : title\n    const containerProps = {\n      accessibilityLabel: containerAccessibilityLabel,\n      // If used for focus, attach the ref and draw a focus box around the whole carousel\n      ...(isFirstFocusContainer && { ref: containerRef, focusable: true })\n    }\n\n    const onAnimationControlButtonPress = React.useCallback(() => {\n      if (isCarouselPlaying) {\n        stopAutoplay()\n      } else {\n        startAutoplay()\n      }\n      setisCarouselPlaying((prevState) => !prevState)\n    }, [isCarouselPlaying, stopAutoplay, startAutoplay])\n\n    const handleKeyDown = React.useCallback(\n      (event) => {\n        if (isTransitioningRef.current && event.key === 'Tab') {\n          event.preventDefault()\n        }\n      },\n      [isTransitioningRef]\n    )\n\n    return (\n      <View\n        style={selectRootContainerStyles(enableHero, viewport, enablePeeking)}\n        onLayout={onRootContainerLayout}\n      >\n        <View style={selectMainContainerStyles(enableHero, viewport, maxWidth, enablePeeking)}>\n          <CarouselProvider\n            activeIndex={activeIndex}\n            goTo={goTo}\n            getCopyWithPlaceholders={getCopyWithPlaceholders}\n            itemLabel={itemLabel}\n            totalItems={totalItems}\n            themeTokens={themeTokens}\n            firstFocusRef={firstFocusRef}\n            refocus={refocus}\n            width={containerLayout.width}\n            maximumItemsForSlide={getMaximumItemsForSlide(\n              enableDisplayMultipleItemsPerSlide,\n              viewport\n            )}\n            maxWidth={maxWidth}\n            viewportWidth={currentViewportWidth}\n          >\n            <View\n              style={[\n                staticStyles.root,\n                {\n                  ...(Platform.OS === 'web' ? { outline: 'none' } : {})\n                }\n              ]}\n              onLayout={onContainerLayout}\n              ref={ref}\n              {...systemProps}\n              {...containerProps}\n              {...(Platform.OS === 'web' ? { onKeyDown: handleKeyDown } : {})}\n            >\n              {isAutoPlayEnabled ? (\n                <View\n                  style={[\n                    staticStyles.animationControlButton,\n                    selectControlButtonPositionStyles({\n                      positionVariant: previousNextNavigationPosition,\n                      buttonWidth: previousNextNavigationButtonWidth,\n                      positionProperty: getDynamicPositionProperty(),\n                      spaceBetweenSlideAndButton: spaceBetweenSlideAndPreviousNextNavigation,\n                      enablePeeking,\n                      enableDisplayMultipleItemsPerSlide,\n                      isAutoPlayEnabled,\n                      viewport,\n                      maxWidth,\n                      containerWidth: containerLayout.width\n                    })\n                  ]}\n                >\n                  <IconButton\n                    icon={isCarouselPlaying ? pauseIcon : playIcon}\n                    accessibilityLabel={\n                      isCarouselPlaying ? getCopy('pauseButtonLabel') : getCopy('playButtonLabel')\n                    }\n                    variant={previousNextIconButtonVariants}\n                    onPress={onAnimationControlButtonPress}\n                  />\n                </View>\n              ) : null}\n              {showPreviousNextNavigation && totalItems > 1 ? (\n                <View\n                  style={selectPreviousNextNavigationButtonStyles(\n                    previousNextNavigationButtonWidth,\n                    previousNextNavigationPosition,\n                    spaceBetweenSlideAndPreviousNextNavigation,\n                    isFirstSlide,\n                    isLastSlide,\n                    true,\n                    enablePeeking,\n                    enableDisplayMultipleItemsPerSlide,\n                    isAutoPlayEnabled,\n                    viewport,\n                    maxWidth,\n                    containerLayout.width\n                  )}\n                  testID=\"previous-button-container\"\n                >\n                  <IconButton\n                    onLayout={onPreviousNextNavigationButtonLayout}\n                    icon={previousIcon}\n                    onPress={goToPrev}\n                    variant={previousNextIconButtonVariants}\n                    accessibilityLabel={getCopyWithPlaceholders('iconButtonLabel').replace(\n                      '%{targetStep}',\n                      activeIndex\n                    )}\n                    tokens={selectIconStyles(themeTokens)}\n                  />\n                </View>\n              ) : null}\n              {Boolean(skipLinkHref) && (\n                <SkipLink ref={firstFocusRef} href={skipLinkHref}>\n                  {getCopyWithPlaceholders('skipLink')}\n                </SkipLink>\n              )}\n              {!isFirstFocusContainer && (\n                <A11yText\n                  // Read the current slide position to screen readers on slide.\n                  // If it's set to refocus and doesn't have a SkipLink to focus to, focus this.\n                  accessibilityLiveRegion={!skipLinkHref && refocus ? undefined : 'polite'}\n                  text={getCopyWithPlaceholders('stepTrackerLabel')}\n                />\n              )}\n              <View style={selectContainerStyles(containerLayout.width)}>\n                <Animated.View\n                  style={StyleSheet.flatten([\n                    selectSwipeAreaStyles(\n                      totalItems,\n                      containerLayout.width,\n                      enablePeeking,\n                      enableDisplayMultipleItemsPerSlide\n                    ),\n                    {\n                      transform: [{ translateX: pan.x }, { translateY: pan.y }]\n                    }\n                  ])}\n                  {...panResponder.panHandlers}\n                  {...getA11yPropsFromHtmlTag(tag)}\n                  // In iframes on Mac (e.g. in Storybook), this content may be misread or read twice.\n                  // This is a known Voiceover bug: https://github.com/phetsims/a11y-research/issues/132\n                  accessibilityLiveRegion={accessibilityLiveRegion}\n                >\n                  {childrenArray.map((element, index) => {\n                    let hidden = !isAnimating && index !== activeIndex\n\n                    if (enablePeeking && !isAnimating) {\n                      hidden = false\n                    } else if (\n                      !enablePeeking &&\n                      enableDisplayMultipleItemsPerSlide &&\n                      !isAnimating\n                    ) {\n                      const maxItemsForSlide = getMaximumItemsForSlide(\n                        enableDisplayMultipleItemsPerSlide,\n                        viewport\n                      )\n                      if (\n                        index >= activeIndex * maxItemsForSlide &&\n                        index < activeIndex * maxItemsForSlide + maxItemsForSlide\n                      ) {\n                        hidden = false\n                      }\n                    }\n\n                    const clonedElement = React.cloneElement(element, {\n                      elementIndex: index,\n                      hidden,\n                      enablePeeking,\n                      peekingProps: getPeekingProps(viewport),\n                      enableDisplayMultipleItemsPerSlide,\n                      viewport,\n                      backgroundColor: element.props.backgroundColor\n                    })\n                    return <React.Fragment key={index.toFixed(2)}>{clonedElement}</React.Fragment>\n                  })}\n                </Animated.View>\n              </View>\n              {showPreviousNextNavigation && totalItems > 1 ? (\n                <View\n                  style={selectPreviousNextNavigationButtonStyles(\n                    previousNextNavigationButtonWidth,\n                    previousNextNavigationPosition,\n                    spaceBetweenSlideAndPreviousNextNavigation,\n                    isFirstSlide,\n                    isLastSlide,\n                    false,\n                    enablePeeking,\n                    enableDisplayMultipleItemsPerSlide,\n                    isAutoPlayEnabled,\n                    viewport,\n                    maxWidth,\n                    containerLayout.width\n                  )}\n                  testID=\"next-button-container\"\n                >\n                  <IconButton\n                    onLayout={onPreviousNextNavigationButtonLayout}\n                    icon={nextIcon}\n                    onPress={goToNext}\n                    variant={previousNextIconButtonVariants}\n                    accessibilityLabel={getCopyWithPlaceholders('iconButtonLabel').replace(\n                      '%{targetStep}',\n                      activeIndex + 2\n                    )}\n                    tokens={selectIconStyles(themeTokens)}\n                  />\n                </View>\n              ) : null}\n            </View>\n            <View\n              style={selectNavigationStyles(tabs, enableHero, viewport, enablePeeking, maxWidth)}\n            >\n              {showPanelNavigation ? activePanelNavigation : null}\n            </View>\n          </CarouselProvider>\n        </View>\n        {enableHero && (\n          <View style={staticStyles.heroMainContainer}>\n            <Animated.View\n              style={StyleSheet.flatten([\n                staticStyles.heroSwipeArea,\n                {\n                  transform: [{ translateX: heroPan.x }, { translateY: heroPan.y }]\n                }\n              ])}\n              onLayout={onHeroContainerLayout}\n              {...heroPanResponder.panHandlers}\n              {...getA11yPropsFromHtmlTag(tag)}\n              accessibilityLiveRegion={accessibilityLiveRegion}\n            >\n              {childrenArray.map((element, index) => {\n                const hidden = !isAnimating && index !== activeIndex\n                return (\n                  <View\n                    style={selectHeroContainerStyles(heroContainerLayout.width, hidden)}\n                    key={index.toFixed(2)}\n                  >\n                    <Box flex={1} variant={{ background: element.props.backgroundColor }} />\n                  </View>\n                )\n              })}\n            </Animated.View>\n          </View>\n        )}\n      </View>\n    )\n  }\n)\n\nCarousel.propTypes = {\n  ...selectedSystemPropTypes,\n  tokens: getTokensPropType('Carousel'),\n  variant: variantProp.propType,\n  /**\n   * Prop related to StepTracker Variants\n   */\n  stepTrackerVariant: variantProp.propType,\n  /**\n   * Prop related to ProgressBar Variants\n   */\n  progressBarVariant: variantProp.propType,\n  /**\n   * Slides to render in Carousel. Wrap individual slides in `CarouselItem`\n   */\n  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]).isRequired,\n  /**\n   * Lowercase language-appropriate user-facing description of what each Carousel slide represents.\n   * This is used when generating item labels. For example, if a carousel contains offers,\n   * pass itemLabel=\"summer offer\" (or copy=\"fr\" and an appropriate French translation) to genereate\n   * accessible labels such as \"Summer offer 1 of 3\" and \"Show summer offer 2 of 3\".\n   */\n  itemLabel: PropTypes.string,\n  /**\n   * `inside` renders the previous and next buttons inside the slide\n   * `outside` renders the previous and next buttons outside the slide\n   * `edge` renders the previous and next buttons at the edge of the slide\n   */\n  previousNextNavigationPosition: PropTypes.oneOf(['inside', 'outside', 'edge']),\n  /**\n   * Defines the size of the `IconButton` which is being used to render next and previous buttons\n   */\n  previousNextIconSize: PropTypes.oneOf(['default', 'small', 'large']),\n  /**\n   * Carousel uses `Animated.spring` to animate slide changes, use this option to pass custom animation configuration\n   */\n  springConfig: PropTypes.object,\n  /**\n   * An array of objects containing information on the thumbnails to be rendered as navigation panel\n   */\n  thumbnails: PropTypes.arrayOf(\n    PropTypes.shape({\n      /** Accessibility label for the thumbnail image, used by assistive technologies. */\n      accessibilityLabel: PropTypes.string,\n      /** Alternative text for the thumbnail image, displayed when the image cannot be rendered. */\n      alt: PropTypes.string,\n      /** When true, renders a play icon overlay on the thumbnail to indicate that the slide contains a video. */\n      isVideo: PropTypes.bool,\n      /** URL or path of the thumbnail image. When used with `isVideo`, this should be the video's poster/preview image. */\n      src: PropTypes.oneOfType([PropTypes.string, PropTypes.number])\n    })\n  ),\n  /**\n   * Minimal part of slide width must be swiped for changing index.\n   * Otherwise animation restore current slide. Default value 0.2 means that 20% must be swiped for change index\n   */\n  minDistanceForAction: PropTypes.number,\n  /**\n   * Initiate animation after swipe this distance.\n   */\n  minDistanceToCapture: PropTypes.number,\n  /**\n   * Called when active index changed\n   * This function is also provided with a parameter indicating changed index (either 1, or -1)\n   * Use it as follows:\n   * ```js\n   *    const onIndexChangedCallback = React.useCallback((changedIndex, currentActiveIndex) => {\n   *      console.log(changedIndex)\n   *    }, [])  // pass local dependencies as per your component\n   *    <Carousel\n   *      onIndexChanged={onIndexChangedCallback}\n   *    >\n   *      <CarouselItem>First Slide</CarouselItem>\n   *    </Carousel>\n   * ```\n   * Caution: Always consider wrapping your callback for `onIndexChanged` in `React.useCallback` in order to avoid bugs and performance issues\n   */\n  onIndexChanged: PropTypes.func,\n  /**\n   * If this is a complex carousel with a lot of focusable content, pass a href for a skip link. Typically, this will be an anchor link\n   * with the ID of a focusable element immediately after the Carousel, e.g. `'#section-2-heading'`.\n   */\n  skipLinkHref: PropTypes.string,\n  /**\n   * If provided, defaults the navigation panel to a CarouselTabsPanel element passing each item as props for one tab.\n   *\n   * Be careful to ensure that the order of each element in the items array matches the order of each child in the Carousel.\n   */\n  tabs: PropTypes.arrayOf(PropTypes.shape(CarouselTabsPanelItem.propTypes || {})),\n  /**\n   * If true, whenever a new slide comes into view, the focus of the Carousel switches to the start.\n   *\n   * Pass this as true when using carousel items that contain interactive content, so a user can easily tab into that content.\n   *\n   * If skipLinkHref is passed, the focus target will be the SkipLink; if not, it'll be an empty element before the slide content.\n   */\n  refocus: PropTypes.bool,\n  /**\n   * Use this to render a custom panel navigation element instead of the default StepTracker's based navigation\n   * You can make use of `useCarousel` within your custom panel navigation component to hook into various Carousel states such as:\n   * - activeIndex: index of current slide\n   * - totalItems: total number of slides\n   * Use it as follows:\n   * ```js\n   *    <Carousel\n   *      panelNavigation={<CustomPanelNavigation />}\n   *    >\n   *      <CarouselItem>First Slide</CarouselItem>\n   *    </Carousel>\n   * ```\n   */\n  panelNavigation: PropTypes.element,\n  /**\n   * When slide animation start\n   * This function is also provided with a parameter indicating the current slide index before animation starts\n   * Use it as follows:\n   * ```js\n   *    const onAnimationStartCallback = React.useCallback((currentIndex) => {\n   *      console.log(currentIndex)\n   *    }, [])  // pass local dependencies as per your component\n   *    <Carousel\n   *      onAnimationStart={onAnimationStartCallback}\n   *    >\n   *      <CarouselItem>First Slide</CarouselItem>\n   *    </Carousel>\n   * ```\n   * Caution: Always consider wrapping your callback for `onAnimationStart` in `React.useCallback` in order to avoid bugs and performance issues\n   */\n  onAnimationStart: PropTypes.func,\n  /**\n   * When slide animation end with parameter of current index (after animation ends)\n   * This function is also provided with a parameter indicating the updated slide index after animation ends\n   * Use it as follows:\n   * ```js\n   *    const onAnimationEndCallback = React.useCallback((changedIndex) => {\n   *      console.log(changedIndex)\n   *    }, [])  // pass local dependencies as per your component\n   *    <Carousel\n   *      onAnimationEnd={onAnimationEndCallback}\n   *    >\n   *      <CarouselItem>First Slide</CarouselItem>\n   *    </Carousel>\n   * ```\n   * Caution: Always consider wrapping your callback for `onAnimationEnd` in `React.useCallback` in order to avoid bugs and performance issues\n   */\n  onAnimationEnd: PropTypes.func,\n  /**\n   * Use this to override the default text for panel navigation\n   */\n  panelNavigationTextDictionary: PropTypes.shape({\n    en: PropTypes.shape({ stepTrackerLabel: PropTypes.string.isRequired }),\n    fr: PropTypes.shape({ stepTrackerLabel: PropTypes.string.isRequired })\n  }),\n  /**\n   * Provide custom accessibilityRole for Carousel container\n   */\n  accessibilityRole: PropTypes.string,\n  /**\n   * Provide custom accessibilityLabel for Carousel container\n   */\n  accessibilityLabel: PropTypes.string,\n  /**\n   * HTML tag to use for the Carousel item's immediate parent. Defaults to `'ul'` so that\n   * assistive technology tools know to intepret the carousel as a list.\n   *\n   * Note that if the immediate Carousel children do not all render as `'li'` elements,\n   * this should be changed (e.g. pass tag=\"div\") because only 'li' is a valid child of 'ul'.\n   */\n  tag: PropTypes.oneOf(layoutTags),\n  /**\n   * If set to `true`, the Carousel will automatically transition between slides\n   * and show the play/pause button\n   * - Default value is `false`\n   * - `slideDuration` and `transitionDuration` are required to be set for this to work\n   */\n  autoPlay: PropTypes.bool,\n  /**\n   * Duration of the time in seconds spent on each slide\n   * - Default value is `0`\n   * - `autoPlay` and `transitionDuration` are required to be set for this to work\n   */\n  slideDuration: PropTypes.number,\n  /**\n   * Duration of the time in seconds between each slide transition\n   * - Default value is `0`\n   * - `autoPlay` and `slideDuration` are required to be set for this to work\n   */\n  transitionDuration: PropTypes.number,\n  /**\n   * Time it takes in seconds to transition from last slide to first slide\n   * - Default value equals `transitionDuration`'s value\n   * - `autoPlay` and `transitionDuration` are required to be set for this to work\n   */\n  loopDuration: PropTypes.number,\n  /**\n   * If set to `true`, the Carousel will show the previous and next slides\n   * - Default value is `false`\n   */\n  enablePeeking: PropTypes.bool,\n  /**\n   * If set to `true`, the Carousel will show multiple slides at once\n   * - Default value is `false`\n   */\n  enableDisplayMultipleItemsPerSlide: PropTypes.bool,\n  /**\n   * The maximum width of the content in the Carousel.\n   * This prop accepts responsive values for different viewports. If a number is provided,\n   * it will be the max content width for the desired viewport.\n   * - `xs`: 'max' | 'full' | <number>\n   * - `sm`: 'max' | 'full' | <number>\n   * - `md`: 'max' | 'full' | <number>\n   * - `lg`: 'max' | 'full' | <number>\n   * - `xl`: 'max' | 'full' | <number>\n   */\n  contentMaxWidth: PropTypes.shape({\n    xl: PropTypes.oneOfType([PropTypes.oneOf(['max', 'full']), PropTypes.number]),\n    lg: PropTypes.oneOfType([PropTypes.oneOf(['max', 'full']), PropTypes.number]),\n    md: PropTypes.oneOfType([PropTypes.oneOf(['max', 'full']), PropTypes.number]),\n    sm: PropTypes.oneOfType([PropTypes.oneOf(['max', 'full']), PropTypes.number]),\n    xs: PropTypes.oneOfType([PropTypes.oneOf(['max', 'full']), PropTypes.number])\n  }),\n  /**\n   * Animation style for swipe release transitions.\n   * - `'instant'`: Immediate snap to position (current default)\n   * - `'ease-out'`: Smooth deceleration animation\n   * - Default value is `'instant'`\n   * - Use `swipeReleaseDuration` to customize the animation duration when using `'ease-out'`\n   *\n   * @deprecated The default will change to `'ease-out'` in Q2 2026 (introduced Jan 2026).\n   */\n  swipeReleaseStyle: PropTypes.oneOf(['instant', 'ease-out']),\n  /**\n   * Duration in milliseconds of the ease-out animation when releasing a swipe gesture.\n   * Only applies when `swipeReleaseStyle` is set to `'ease-out'`.\n   * - Default value is `500` (500ms)\n   */\n  swipeReleaseDuration: PropTypes.number\n}\n\nCarousel.displayName = 'Carousel'\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AASA,IAAAE,UAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,eAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AACA,IAAAO,UAAA,GAAAP,OAAA;AACA,IAAAQ,YAAA,GAAAR,OAAA;AACA,IAAAS,mBAAA,GAAAT,OAAA;AACA,IAAAU,UAAA,GAAAV,OAAA;AACA,IAAAW,UAAA,GAAAX,OAAA;AACA,IAAAY,QAAA,GAAAZ,OAAA;AACA,IAAAa,SAAA,GAAAb,OAAA;AACA,IAAAc,cAAA,GAAAd,OAAA;AACA,IAAAe,kBAAA,GAAAf,OAAA;AACA,IAAAgB,uBAAA,GAAAhB,OAAA;AACA,IAAAiB,iBAAA,GAAAjB,OAAA;AACA,IAAAkB,gBAAA,GAAAlB,OAAA;AACA,IAAAmB,WAAA,GAAAnB,OAAA;AACA,IAAAoB,SAAA,GAAApB,OAAA;AACA,IAAAqB,SAAA,GAAArB,OAAA;AACA,IAAAsB,oBAAA,GAAAtB,OAAA;AACA,IAAAuB,4BAAA,GAAAvB,OAAA;AACA,IAAAwB,kBAAA,GAAAxB,OAAA;AACA,IAAAyB,sBAAA,GAAAzB,OAAA;AACA,IAAA0B,WAAA,GAAA1B,OAAA;AACA,IAAA2B,IAAA,GAAA3B,OAAA;AACA,IAAA4B,UAAA,GAAA5B,OAAA;AAeoB,IAAA6B,WAAA,GAAA7B,OAAA;AAAA,IAAA8B,SAAA;AAEpB,IAAMC,YAAY,GAAGC,uBAAU,CAACC,MAAM,CAAC;EACrCC,IAAI,EAAE;IACJC,eAAe,EAAE,aAAa;IAC9BC,cAAc,EAAE,QAAQ;IACxBC,UAAU,EAAE,QAAQ;IACpBC,QAAQ,EAAE,UAAU;IACpBC,GAAG,EAAE,CAAC;IACNC,IAAI,EAAE;EACR,CAAC;EACDC,sBAAsB,EAAE;IACtBH,QAAQ,EAAE,UAAU;IACpBI,MAAM,EAAE,CAAC;IACTC,KAAK,EAAEC,qBAAQ,CAACC,EAAE,KAAK,KAAK,GAAGC,SAAS,GAAG,EAAE;IAC7CP,GAAG,EAAE;EACP,CAAC;EACDQ,iBAAiB,EAAE;IACjBT,QAAQ,EAAE,UAAU;IACpBC,GAAG,EAAE,CAAC;IACNC,IAAI,EAAE,CAAC;IACPG,KAAK,EAAE,CAAC;IACRK,MAAM,EAAE,CAAC;IACTC,QAAQ,EAAE,QAAQ;IAClBP,MAAM,EAAE,CAAC;EACX,CAAC;EACDQ,aAAa,EAAE;IACbZ,QAAQ,EAAE,UAAU;IACpBC,GAAG,EAAE,CAAC;IACNC,IAAI,EAAE,CAAC;IACPG,KAAK,EAAE,CAAC;IACRK,MAAM,EAAE,CAAC;IACTN,MAAM,EAAE,CAAC,CAAC;IACVS,aAAa,EAAE;EACjB;AACF,CAAC,CAAC;AAEF,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAqBA,CAAIC,KAAK;EAAA,OAAM;IACxClB,eAAe,EAAE,aAAa;IAC9Bc,QAAQ,EAAE,QAAQ;IAClBI,KAAK,EAALA;EACF,CAAC;AAAA,CAAC;AAEF,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAqBA,CACzBC,KAAK,EACLF,KAAK,EACLG,aAAa,EACbC,kCAAkC;EAAA,OAC9B;IACJJ,KAAK,EAAEA,KAAK,GAAGE,KAAK;IACpBnB,cAAc,EACZoB,aAAa,IAAIC,kCAAkC,GAAG,YAAY,GAAG,eAAe;IACtFN,aAAa,EAAE;EACjB,CAAC;AAAA,CAAC;AAEF,IAAMO,yBAAyB,GAAG,SAA5BA,yBAAyBA,CAAIL,KAAK,EAAEM,MAAM;EAAA,OAAM;IACpDN,KAAK,EAALA,KAAK;IACLO,UAAU,EAAED,MAAM,GAAG,QAAQ,GAAG;EAClC,CAAC;AAAA,CAAC;AAEF,IAAME,0BAA0B,GAAG,SAA7BA,0BAA0BA,CAAIC,gCAAgC;EAAA,OAClEA,gCAAgC,GAAGC,8BAAmB,CAACC,IAAI,GAAGD,8BAAmB,CAACE,KAAK;AAAA;AAEzF,IAAMC,iCAAiC,GAAG,SAApCA,iCAAiCA,CAAAC,IAAA,EAWjC;EAAA,IAVJC,eAAe,GAAAD,IAAA,CAAfC,eAAe;IACfC,WAAW,GAAAF,IAAA,CAAXE,WAAW;IAAAC,qBAAA,GAAAH,IAAA,CACXI,gBAAgB;IAAhBA,gBAAgB,GAAAD,qBAAA,cAAGT,0BAA0B,CAAC,CAAC,GAAAS,qBAAA;IAC/CE,0BAA0B,GAAAL,IAAA,CAA1BK,0BAA0B;IAC1BhB,aAAa,GAAAW,IAAA,CAAbX,aAAa;IACbC,kCAAkC,GAAAU,IAAA,CAAlCV,kCAAkC;IAClCgB,iBAAiB,GAAAN,IAAA,CAAjBM,iBAAiB;IACjBC,QAAQ,GAAAP,IAAA,CAARO,QAAQ;IACRC,QAAQ,GAAAR,IAAA,CAARQ,QAAQ;IACRC,cAAc,GAAAT,IAAA,CAAdS,cAAc;EAEd,IAAMC,MAAM,GAAG,CAAC,CAAC;EAEjB,IAAIC,cAAc,GAAG,CAAC;EAEtB,IAAIV,eAAe,KAAKW,4BAAiB,CAACC,IAAI,EAAE;IAC9CF,cAAc,GAAG,CAAC,CAAC,IAAIT,WAAW,GAAG,CAAC,CAAC;EACzC,CAAC,MAAM,IAAID,eAAe,KAAKW,4BAAiB,CAACE,MAAM,EAAE;IACvDH,cAAc,GAAGI,kCAAuB;EAC1C,CAAC,MAAM,IAAId,eAAe,KAAKW,4BAAiB,CAACI,OAAO,EAAE;IACxD,IACE3B,aAAa,IACbC,kCAAkC,IACjCgB,iBAAiB,IAAIC,QAAQ,KAAK,IAAK,EACxC;MACAI,cAAc,GAAG,CAAC;IACpB,CAAC,MAAM;MACLA,cAAc,GAAG,CAAC,CAAC,IAAIN,0BAA0B,GAAGH,WAAW,CAAC;IAClE;EACF;EAEA,IAAIb,aAAa,EAAE;IACjB,IAAA4B,gBAAA,GAA2CC,eAAe,CAACX,QAAQ,CAAC;MAA5DY,kBAAkB,GAAAF,gBAAA,CAAlBE,kBAAkB;MAAEC,UAAU,GAAAH,gBAAA,CAAVG,UAAU;IACtC,IAAMC,eAAe,GAAGC,IAAI,CAACC,GAAG,CAACf,QAAQ,IAAIC,cAAc,EAAEA,cAAc,CAAC;IAC5E,IAAMe,cAAc,GAAG,CAACf,cAAc,GAAGY,eAAe,IAAI,CAAC,GAAGF,kBAAkB;IAClF,IAAMM,YAAY,GAAGD,cAAc,GAAGJ,UAAU,GAAG,CAAC;IACpDT,cAAc,GAAGF,cAAc,GAAGgB,YAAY,GAAGvB,WAAW,GAAG,CAAC;EAClE;EAEAQ,MAAM,CAACN,gBAAgB,CAAC,GAAGO,cAAc;EACzC,OAAOD,MAAM;AACf,CAAC;AAED,IAAMgB,wCAAwC,GAAG,SAA3CA,wCAAwCA,CAC5CC,iCAAiC,EACjCC,8BAA8B,EAC9BC,0CAA0C,EAC1CC,YAAY,EACZC,WAAW,EACXpC,gCAAgC,EAChCN,aAAa,EACbC,kCAAkC,EAClCgB,iBAAiB,EACjBC,QAAQ,EACRC,QAAQ,EACRC,cAAc,EACX;EACH,IAAMC,MAAM,GAAG;IACbnC,MAAM,EAAE,CAAC;IACTJ,QAAQ,EAAE;EACZ,CAAC;EACD,IAAI2D,YAAY,EAAE;IAChBpB,MAAM,CAACjB,UAAU,GAAGE,gCAAgC,GAAG,QAAQ,GAAG,SAAS;EAC7E,CAAC,MAAM,IAAIoC,WAAW,EAAE;IACtBrB,MAAM,CAACjB,UAAU,GAAGE,gCAAgC,GAAG,SAAS,GAAG,QAAQ;EAC7E,CAAC,MAAM;IACLe,MAAM,CAACjB,UAAU,GAAG,SAAS;EAC/B;EAEA,OAAAuC,MAAA,CAAAC,MAAA,KACKvB,MAAM,EACNX,iCAAiC,CAAC;IACnCE,eAAe,EAAE2B,8BAA8B;IAC/C1B,WAAW,EAAEyB,iCAAiC;IAC9CvB,gBAAgB,EAAEV,0BAA0B,CAACC,gCAAgC,CAAC;IAC9EU,0BAA0B,EAAEwB,0CAA0C;IACtExC,aAAa,EAAbA,aAAa;IACbC,kCAAkC,EAAlCA,kCAAkC;IAClCgB,iBAAiB,EAAjBA,iBAAiB;IACjBC,QAAQ,EAARA,QAAQ;IACRC,QAAQ,EAARA,QAAQ;IACRC,cAAc,EAAdA;EACF,CAAC,CAAC;AAEN,CAAC;AAED,IAAMS,eAAe,GAAG,SAAlBA,eAAeA,CAAIX,QAAQ,EAAK;EACpC,IAAIA,QAAQ,KAAK,IAAI,IAAIA,QAAQ,KAAK,IAAI,IAAIA,QAAQ,KAAK,IAAI,EAAE;IAC/D,OAAO;MACL2B,iBAAiB,EAAE,EAAE;MACrBd,UAAU,EAAE,EAAE;MACde,gBAAgB,EAAE,EAAE;MACpBC,iBAAiB,EAAE,EAAE;MACrBC,kBAAkB,EAAE,EAAE;MACtBlB,kBAAkB,EAAE;IACtB,CAAC;EACH;EACA,OAAO;IACLe,iBAAiB,EAAE,EAAE;IACrBd,UAAU,EAAE,EAAE;IACde,gBAAgB,EAAE,EAAE;IACpBC,iBAAiB,EAAE,EAAE;IACrBC,kBAAkB,EAAE,EAAE;IACtBlB,kBAAkB,EAAE;EACtB,CAAC;AACH,CAAC;AAED,IAAMmB,aAAa,GAAG,SAAhBA,aAAaA,CAAIhD,kCAAkC,EAAEiD,aAAa,EAAEhC,QAAQ,EAAK;EACrF,IAAIjB,kCAAkC,EAAE;IACtC,QAAQiB,QAAQ;MACd,KAAK,IAAI;MACT,KAAK,IAAI;QACP,OAAOgC,aAAa,CAACC,MAAM;MAC7B,KAAK,IAAI;QACP,OAAOlB,IAAI,CAACmB,IAAI,CAACF,aAAa,CAACC,MAAM,GAAGE,gCAAqB,CAAC;MAChE,KAAK,IAAI;MACT,KAAK,IAAI;QACP,OAAOpB,IAAI,CAACmB,IAAI,CAACF,aAAa,CAACC,MAAM,GAAGG,mCAAwB,CAAC;MACnE;QACE;IACJ;EACF;EACA,OAAOJ,aAAa,CAACC,MAAM;AAC7B,CAAC;AASD,IAAMI,uBAAuB,GAAG,SAA1BA,uBAAuBA,CAAItD,kCAAkC,EAAEiB,QAAQ,EAAK;EAChF,IAAIjB,kCAAkC,EAAE;IACtC,QAAQiB,QAAQ;MACd,KAAK,IAAI;MACT,KAAK,IAAI;QACP,OAAOsC,mCAAwB;MACjC,KAAK,IAAI;QACP,OAAOH,gCAAqB;MAC9B,KAAK,IAAI;MACT,KAAK,IAAI;QACP,OAAOC,mCAAwB;MACjC;QACE,OAAOE,mCAAwB;IACnC;EACF;EACA,OAAOA,mCAAwB;AACjC,CAAC;AAED,IAAMC,yBAAyB,GAAG,SAA5BA,yBAAyBA,CAAIC,UAAU,EAAExC,QAAQ,EAAElB,aAAa,EAAK;EACzE,IAAI0D,UAAU,IAAIxC,QAAQ,KAAK,IAAI,IAAI9B,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;IAC5D,OAAO;MACLR,UAAU,EAAE;IACd,CAAC;EACH;EACA,IAAI6E,UAAU,EAAE;IACd,OAAO;MACLC,iBAAiB,EAAE;IACrB,CAAC;EACH;EACA,IAAI3D,aAAa,EAAE;IACjB,OAAO;MACLH,KAAK,EAAE;IACT,CAAC;EACH;EACA,OAAO,CAAC,CAAC;AACX,CAAC;AAED,IAAM+D,yBAAyB,GAAG,SAA5BA,yBAAyBA,CAAIF,UAAU,EAAExC,QAAQ,EAAEC,QAAQ,EAAEnB,aAAa,EAAK;EACnF,IAAI0D,UAAU,IAAIxC,QAAQ,KAAK,IAAI,IAAI9B,qBAAQ,CAACC,EAAE,KAAK,KAAK,IAAI,CAACW,aAAa,EAAE;IAC9E,OAAO;MACLH,KAAK,EAAE,MAAM;MACbsB,QAAQ,EAAEA,QAAQ,IAAI;IACxB,CAAC;EACH;EACA,IAAInB,aAAa,EAAE;IACjB,OAAO;MACLH,KAAK,EAAE;IACT,CAAC;EACH;EACA,IAAIsB,QAAQ,KAAK,IAAI,IAAIA,QAAQ,KAAK7B,SAAS,EAAE;IAC/C,OAAO;MACL6B,QAAQ,EAARA,QAAQ;MACR0C,SAAS,EAAE,QAAQ;MACnBhE,KAAK,EAAE;IACT,CAAC;EACH;EACA,OAAO,CAAC,CAAC;AACX,CAAC;AAED,IAAMiE,sBAAsB,GAAG,SAAzBA,sBAAsBA,CAAIC,IAAI,EAAEL,UAAU,EAAExC,QAAQ,EAAElB,aAAa,EAAEmB,QAAQ,EAAK;EACtF,IAAI6C,gBAAgB,GAAG,CAAC;EAExB,IAAIN,UAAU,IAAIK,IAAI,EAAE;IACtBC,gBAAgB,GAAG9C,QAAQ,KAAK,IAAI,GAAG+C,gCAAqB,GAAGC,kCAAuB;EACxF;EAEA,IAAM7C,MAAM,GAAG;IACb2C,gBAAgB,EAAhBA;EACF,CAAC;EAED,IAAIhE,aAAa,IAAImB,QAAQ,EAAE;IAC7BE,MAAM,CAACF,QAAQ,GAAGA,QAAQ;IAC1BE,MAAM,CAACwC,SAAS,GAAG,QAAQ;IAC3BxC,MAAM,CAACxB,KAAK,GAAG,MAAM;EACvB;EAEA,OAAOwB,MAAM;AACf,CAAC;AAWD,IAAM8C,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAI/C,cAAc,EAAEpB,aAAa,EAAEkB,QAAQ,EAAEC,QAAQ,EAAK;EACjF,IAAIiD,UAAU,GAAGhD,cAAc;EAE/B,IAAIpB,aAAa,EAAE;IACjB,IAAAqE,iBAAA,GAA2CxC,eAAe,CAACX,QAAQ,CAAC;MAA5Da,UAAU,GAAAsC,iBAAA,CAAVtC,UAAU;MAAED,kBAAkB,GAAAuC,iBAAA,CAAlBvC,kBAAkB;IACtC,IAAMwC,SAAS,GAAGrC,IAAI,CAACC,GAAG,CAACf,QAAQ,IAAIC,cAAc,EAAEA,cAAc,CAAC;IACtEgD,UAAU,GAAGE,SAAS,GAAGxC,kBAAkB,GAAGyC,6BAAkB,GAAGxC,UAAU;EAC/E;EAEA,OAAOqC,UAAU;AACnB,CAAC;AAED,IAAMI,gBAAgB,GAAG,SAAnBA,gBAAgBA,CAAAC,KAAA;EAAA,IAAMC,mBAAmB,GAAAD,KAAA,CAAnBC,mBAAmB;EAAA,OAAQ;IAAE/F,eAAe,EAAE+F;EAAoB,CAAC;AAAA,CAAC;AAEhG,IAAAC,kBAAA,GAA+C,IAAAC,qCAAiB,EAAC,CAACC,oBAAS,EAAEC,oBAAS,CAAC,CAAC;EAAAC,mBAAA,OAAAC,eAAA,CAAAC,OAAA,EAAAN,kBAAA;EAAjFO,WAAW,GAAAH,mBAAA;EAAEI,uBAAuB,GAAAJ,mBAAA;AAwDpC,IAAMK,QAAQ,GAAAC,OAAA,CAAAD,QAAA,GAAGE,cAAK,CAACC,UAAU,CACtC,UAAAC,KAAA,EA+CEC,GAAG,EACA;EAAA,IAAAC,qBAAA;EAAA,IA9CDC,MAAM,GAAAH,KAAA,CAANG,MAAM;IACNC,OAAO,GAAAJ,KAAA,CAAPI,OAAO;IACPC,QAAQ,GAAAL,KAAA,CAARK,QAAQ;IAAAC,eAAA,GAAAN,KAAA,CACRO,SAAS;IAATA,SAAS,GAAAD,eAAA,cAAG,MAAM,GAAAA,eAAA;IAAAE,qBAAA,GAAAR,KAAA,CAClBjD,8BAA8B;IAA9BA,8BAA8B,GAAAyD,qBAAA,cAAG,QAAQ,GAAAA,qBAAA;IACzCC,kBAAkB,GAAAT,KAAA,CAAlBS,kBAAkB;IAAAC,qBAAA,GAAAV,KAAA,CAClBW,kBAAkB;IAAlBA,kBAAkB,GAAAD,qBAAA,cAAG;MAAEE,KAAK,EAAE;IAAS,CAAC,GAAAF,qBAAA;IAAAG,qBAAA,GAAAb,KAAA,CACxCc,oBAAoB;IAApBA,oBAAoB,GAAAD,qBAAA,cAAG,SAAS,GAAAA,qBAAA;IAAAE,qBAAA,GAAAf,KAAA,CAChCgB,oBAAoB;IAApBA,oBAAoB,GAAAD,qBAAA,cAAG,CAAC,GAAAA,qBAAA;IAAAE,qBAAA,GAAAjB,KAAA,CACxBkB,oBAAoB;IAApBA,oBAAoB,GAAAD,qBAAA,cAAG,GAAG,GAAAA,qBAAA;IAC1BE,gBAAgB,GAAAnB,KAAA,CAAhBmB,gBAAgB;IAChBC,cAAc,GAAApB,KAAA,CAAdoB,cAAc;IACdC,cAAc,GAAArB,KAAA,CAAdqB,cAAc;IACdC,YAAY,GAAAtB,KAAA,CAAZsB,YAAY;IACZ/C,IAAI,GAAAyB,KAAA,CAAJzB,IAAI;IAAAgD,aAAA,GAAAvB,KAAA,CACJwB,OAAO;IAAPA,OAAO,GAAAD,aAAA,cAAGE,OAAO,CAAClD,IAAI,CAAC,GAAAgD,aAAA;IAAAG,WAAA,GAAA1B,KAAA,CACvB2B,KAAK;IAALA,KAAK,GAAAD,WAAA,cAAG,UAAU,GAAAA,WAAA;IAAAE,kBAAA,GAAA5B,KAAA,CAClB6B,YAAY;IAAZA,YAAY,GAAAD,kBAAA,cAAG9H,SAAS,GAAA8H,kBAAA;IAAAE,gBAAA,GAAA9B,KAAA,CACxB+B,UAAU;IAAVA,UAAU,GAAAD,gBAAA,cAAGhI,SAAS,GAAAgI,gBAAA;IAAAE,qBAAA,GAAAhC,KAAA,CACtBvF,kCAAkC;IAAlCA,kCAAkC,GAAAuH,qBAAA,cAAG,KAAK,GAAAA,qBAAA;IAAAC,gBAAA,GAAAjC,KAAA,CAC1C9B,UAAU;IAAVA,UAAU,GAAA+D,gBAAA,cAAG,KAAK,GAAAA,gBAAA;IAAAC,qBAAA,GAAAlC,KAAA,CAClBmC,eAAe;IAAfA,eAAe,GAAAD,qBAAA,cAAGH,UAAU,GAC1B,IAAAlJ,WAAA,CAAAuJ,GAAA,EAAC7J,4BAAA,CAAA8J,2BAA2B;MAACN,UAAU,EAAEA;IAAW,CAAE,CAAC,GAEvD,IAAAlJ,WAAA,CAAAuJ,GAAA,EAAC9J,oBAAA,CAAAgK,mBAAmB;MAClB7B,kBAAkB,EAAEA,kBAAmB;MACvCE,kBAAkB,EAAEA,kBAAmB;MACvClG,kCAAkC,EAAEA;IAAmC,CACxE,CACF,GAAAyH,qBAAA;IAAAK,SAAA,GAAAvC,KAAA,CACDwC,GAAG;IAAHA,GAAG,GAAAD,SAAA,cAAG,IAAI,GAAAA,SAAA;IACVE,iBAAiB,GAAAzC,KAAA,CAAjByC,iBAAiB;IACjBC,kBAAkB,GAAA1C,KAAA,CAAlB0C,kBAAkB;IAAAC,qBAAA,GAAA3C,KAAA,CAClB4C,uBAAuB;IAAvBA,uBAAuB,GAAAD,qBAAA,cAAG,QAAQ,GAAAA,qBAAA;IAClCE,IAAI,GAAA7C,KAAA,CAAJ6C,IAAI;IAAAC,mBAAA,GAAA9C,KAAA,CACJ+C,aAAa;IAAbA,aAAa,GAAAD,mBAAA,cAAG,CAAC,GAAAA,mBAAA;IAAAE,qBAAA,GAAAhD,KAAA,CACjBiD,kBAAkB;IAAlBA,kBAAkB,GAAAD,qBAAA,cAAG,CAAC,GAAAA,qBAAA;IAAAE,kBAAA,GAAAlD,KAAA,CACtBmD,YAAY;IAAZA,YAAY,GAAAD,kBAAA,cAAGD,kBAAkB,GAAAC,kBAAA;IAAAE,cAAA,GAAApD,KAAA,CACjCqD,QAAQ;IAARA,QAAQ,GAAAD,cAAA,cAAG,KAAK,GAAAA,cAAA;IAAAE,mBAAA,GAAAtD,KAAA,CAChBxF,aAAa;IAAbA,aAAa,GAAA8I,mBAAA,cAAG,KAAK,GAAAA,mBAAA;IACrBC,eAAe,GAAAvD,KAAA,CAAfuD,eAAe;IAAAC,qBAAA,GAAAxD,KAAA,CACfyD,iBAAiB;IAAjBA,iBAAiB,GAAAD,qBAAA,cAAGE,+BAAoB,CAACC,OAAO,GAAAH,qBAAA;IAAAI,qBAAA,GAAA5D,KAAA,CAChD6D,oBAAoB;IAApBA,oBAAoB,GAAAD,qBAAA,cAAGE,yCAA8B,GAAAF,qBAAA;IAClDG,IAAI,OAAAC,yBAAA,CAAAvE,OAAA,EAAAO,KAAA,EAAAlH,SAAA;EAIT,IAAI4E,aAAa,GAAG,IAAAuG,wBAAc,EAAC5D,QAAQ,CAAC;EAC5C,IAAM6D,kBAAkB,GAAGpE,cAAK,CAACqE,MAAM,CAAC,KAAK,CAAC;EAC9C,IAAMzI,QAAQ,GAAG,IAAA0I,wBAAW,EAAC,CAAC;EAC9B,IAAAC,SAAA,GAAyB,IAAAC,mBAAQ,EAAC,CAAC;IAA3BC,YAAY,GAAAF,SAAA,CAAZE,YAAY;EAEpB,IAAMC,oBAAoB,GAAG,IAAAC,oCAAiB,EAAClB,eAAe,CAAC;EAC/D,IAAMmB,eAAe,GAAG,IAAAD,oCAAiB,EAACF,YAAY,oBAAZA,YAAY,CAAEhB,eAAe,CAAC;EAExE,IAAI5H,QAAQ,GAAG,IAAI;EACnB,IAAInB,aAAa,IAAI+I,eAAe,KAAKzJ,SAAS,EAAE;IAClD6B,QAAQ,GACN6I,oBAAoB,KAAK1K,SAAS,GAC9B4K,eAAe,GACf,IAAAC,8CAAsB,EAACH,oBAAoB,EAAEE,eAAe,CAAC;EACrE;EAEA,IAAME,UAAU,GAAGnH,aAAa,CAAChD,kCAAkC,EAAEiD,aAAa,EAAEhC,QAAQ,CAAC;EAC7F,IAAMmJ,sBAAsB,GAC1BxB,QAAQ,IAAIN,aAAa,GAAG,CAAC,IAAIE,kBAAkB,GAAG,CAAC,IAAI2B,UAAU,GAAG,CAAC;EAE3E,IAAI,CAACE,KAAK,CAACC,OAAO,CAACrH,aAAa,CAAC,EAAE;IACjCA,aAAa,GAAG,CAACA,aAAa,CAAC;EACjC;EACA,IAAMsH,OAAO,GAAG,IAAAC,gBAAO,EAAC;IAAEC,UAAU,EAAVA,sBAAU;IAAErC,IAAI,EAAJA;EAAK,CAAC,CAAC;EAE7C,IAAMsC,WAAW,GAAG,IAAAC,8BAAc,EAAC,UAAU,EAAEjF,MAAM,EAAEC,OAAO,EAAE;IAC9D1E,QAAQ,EAARA;EACF,CAAC,CAAC;EACF,IACE2J,YAAY,GAQVF,WAAW,CARbE,YAAY;IACZC,QAAQ,GAONH,WAAW,CAPbG,QAAQ;IACRC,QAAQ,GAMNJ,WAAW,CANbI,QAAQ;IACRC,SAAS,GAKPL,WAAW,CALbK,SAAS;IACTC,0BAA0B,GAIxBN,WAAW,CAJbM,0BAA0B;IAC1BC,mBAAmB,GAGjBP,WAAW,CAHbO,mBAAmB;IACnBC,aAAa,GAEXR,WAAW,CAFbQ,aAAa;IACb3I,0CAA0C,GACxCmI,WAAW,CADbnI,0CAA0C;EAE5C,IAAA4I,eAAA,GAAsC9F,cAAK,CAAC+F,QAAQ,CAAC,CAAC,CAAC;IAAAC,gBAAA,OAAAtG,eAAA,CAAAC,OAAA,EAAAmG,eAAA;IAAhDG,WAAW,GAAAD,gBAAA;IAAEE,cAAc,GAAAF,gBAAA;EAClC,IAAMG,cAAc,GAAGnG,cAAK,CAACqE,MAAM,CAAC4B,WAAW,CAAC;EAChD,IAAAG,YAAA,GAAgC,IAAAC,6BAAW,EAAC,CAAC;IAArCC,mBAAmB,GAAAF,YAAA,CAAnBE,mBAAmB;EAC3B,IAAMC,eAAe,GAAGvG,cAAK,CAACqE,MAAM,CAACiC,mBAAmB,CAAC;EACzD,IAAAE,gBAAA,GAA8CxG,cAAK,CAAC+F,QAAQ,CAAC;MAC3DU,CAAC,EAAE,CAAC;MACJC,CAAC,EAAE,CAAC;MACJnM,KAAK,EAAE,CAAC;MACRoM,MAAM,EAAE;IACV,CAAC,CAAC;IAAAC,gBAAA,OAAAlH,eAAA,CAAAC,OAAA,EAAA6G,gBAAA;IALKK,eAAe,GAAAD,gBAAA;IAAEE,kBAAkB,GAAAF,gBAAA;EAM1C,IAAMG,kBAAkB,GAAG/G,cAAK,CAACqE,MAAM,CAACwC,eAAe,CAAC;EACxD,IAAAG,gBAAA,GAAsDhH,cAAK,CAAC+F,QAAQ,CAAC;MACnEU,CAAC,EAAE,CAAC;MACJC,CAAC,EAAE,CAAC;MACJnM,KAAK,EAAE,CAAC;MACRoM,MAAM,EAAE;IACV,CAAC,CAAC;IAAAM,gBAAA,OAAAvH,eAAA,CAAAC,OAAA,EAAAqH,gBAAA;IALKE,mBAAmB,GAAAD,gBAAA;IAAEE,sBAAsB,GAAAF,gBAAA;EAMlD,IAAMG,sBAAsB,GAAGpH,cAAK,CAACqE,MAAM,CAAC6C,mBAAmB,CAAC;EAEhE,IAAAG,gBAAA,GACErH,cAAK,CAAC+F,QAAQ,CAAC,CAAC,CAAC;IAAAuB,gBAAA,OAAA5H,eAAA,CAAAC,OAAA,EAAA0H,gBAAA;IADZrK,iCAAiC,GAAAsK,gBAAA;IAAEC,oCAAoC,GAAAD,gBAAA;EAE9E,IAAME,aAAa,GAAGxH,cAAK,CAACqE,MAAM,CAAC,IAAI,CAAC;EACxC,IAAMoD,GAAG,GAAGzH,cAAK,CAACqE,MAAM,CAAC,IAAIqD,qBAAQ,CAACC,OAAO,CAAC,CAAC,CAAC,CAACC,OAAO;EACxD,IAAMC,SAAS,GAAG7H,cAAK,CAACqE,MAAM,CAAC,CAAC,CAAC;EACjC,IAAMyD,SAAS,GAAG9H,cAAK,CAACqE,MAAM,CAAC,CAAC,CAAC;EACjC,IAAM0D,OAAO,GAAG/H,cAAK,CAACqE,MAAM,CAAC,IAAIqD,qBAAQ,CAACC,OAAO,CAAC,CAAC,CAAC,CAACC,OAAO;EAC5D,IAAMI,aAAa,GAAGhI,cAAK,CAACqE,MAAM,CAAC,CAAC,CAAC;EACrC,IAAM4D,aAAa,GAAGjI,cAAK,CAACqE,MAAM,CAAC,CAAC,CAAC;EACrC,IAAA6D,gBAAA,GAAsClI,cAAK,CAAC+F,QAAQ,CAAC,KAAK,CAAC;IAAAoC,gBAAA,OAAAzI,eAAA,CAAAC,OAAA,EAAAuI,gBAAA;IAApDE,WAAW,GAAAD,gBAAA;IAAEE,cAAc,GAAAF,gBAAA;EAOlC,IAAAG,gBAAA,GAAkDtI,cAAK,CAAC+F,QAAQ,CAAChB,sBAAsB,CAAC;IAAAwD,iBAAA,OAAA7I,eAAA,CAAAC,OAAA,EAAA2I,gBAAA;IAAjF3M,iBAAiB,GAAA4M,iBAAA;IAAEC,oBAAoB,GAAAD,iBAAA;EAC9C,IAAAE,iBAAA,GAAkDzI,cAAK,CAAC+F,QAAQ,CAAChB,sBAAsB,CAAC;IAAA2D,iBAAA,OAAAhJ,eAAA,CAAAC,OAAA,EAAA8I,iBAAA;IAAjFE,iBAAiB,GAAAD,iBAAA;IAAEE,oBAAoB,GAAAF,iBAAA;EAC9C,IAAMG,SAAS,GAAG7I,cAAK,CAACqE,MAAM,CAAC,KAAK,CAAC;EACrC,IAAMyE,WAAW,GAAG9I,cAAK,CAACqE,MAAM,CAAC,IAAI,CAAC;EAEtC,IAAA0E,iBAAA,GAAsD/I,cAAK,CAAC+F,QAAQ,CAAC;MACnEU,CAAC,EAAE,CAAC;MACJC,CAAC,EAAE,CAAC;MACJnM,KAAK,EAAE,CAAC;MACRoM,MAAM,EAAE;IACV,CAAC,CAAC;IAAAqC,iBAAA,OAAAtJ,eAAA,CAAAC,OAAA,EAAAoJ,iBAAA;IALKE,mBAAmB,GAAAD,iBAAA;IAAEE,sBAAsB,GAAAF,iBAAA;EAMlD,IAAMG,sBAAsB,GAAGnJ,cAAK,CAACqE,MAAM,CAAC4E,mBAAmB,CAAC;EAEhE,IAAM9L,YAAY,GAAG,CAAC8I,WAAW;EACjC,IAAM7I,WAAW,GAAG6I,WAAW,GAAG,CAAC,IAAInB,UAAU;EACjD,IAAMsE,oBAAoB,GAAGH,mBAAmB,CAAC1O,KAAK;EAEtD,IAAM8O,oBAAoB,GAAGrJ,cAAK,CAACsJ,WAAW,CAC5C,YAAa;IACX,IAAI,OAAOjI,gBAAgB,KAAK,UAAU,EAAEA,gBAAgB,CAAAkI,KAAA,SAAAC,SAAQ,CAAC;IACrEnB,cAAc,CAAC,IAAI,CAAC;EACtB,CAAC,EACD,CAAChH,gBAAgB,CACnB,CAAC;EACD,IAAMoI,kBAAkB,GAAGzJ,cAAK,CAACsJ,WAAW,CAC1C,YAAa;IAAA,IAAAI,KAAA;IACX,IAAMC,MAAM,IAAAD,KAAA,GAAQF,SAAA,CAAK3L,MAAM,GAAG,CAAC,EAAA6L,KAAA,QAAAF,SAAA,CAAA3L,MAAA,IAAA6L,KAAA,GAAA1P,SAAA,GAAAwP,SAAA,CAAAE,KAAA,EAAC;IACpC,IAAIC,MAAM,YAANA,MAAM,CAAEC,QAAQ,EAAE;MACpB,IAAI,OAAOtI,cAAc,KAAK,UAAU,EAAEA,cAAc,CAAAiI,KAAA,SAAAC,SAAQ,CAAC;MACjEnB,cAAc,CAAC,KAAK,CAAC;MACrBjE,kBAAkB,CAACwD,OAAO,GAAG,KAAK;IACpC;EACF,CAAC,EACD,CAACtG,cAAc,EAAE8C,kBAAkB,CACrC,CAAC;EAED,IAAMyF,YAAY,GAAG7J,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC3C,IAAI5O,aAAa,EAAE;MACjB,IAAAoP,iBAAA,GAA2CvN,eAAe,CAACX,QAAQ,CAAC;QAA5Da,UAAU,GAAAqN,iBAAA,CAAVrN,UAAU;QAAED,kBAAkB,GAAAsN,iBAAA,CAAlBtN,kBAAkB;MAEtC,IAAIsC,UAAU;MACd,IAAME,SAAS,GAAGrC,IAAI,CAACC,GAAG,CACxBf,QAAQ,IAAIkL,kBAAkB,CAACa,OAAO,CAACrN,KAAK,EAC5CwM,kBAAkB,CAACa,OAAO,CAACrN,KAC7B,CAAC;MACD,IAAMwP,SAAS,GAAG/K,SAAS,GAAGxC,kBAAkB,GAAGyC,6BAAkB;MAErE,IAAIkH,cAAc,CAACyB,OAAO,KAAK,CAAC,EAAE;QAChC9I,UAAU,GAAG,CAAC;MAChB,CAAC,MAAM;QACLA,UAAU,GAAG,CAACiL,SAAS,GAAGtN,UAAU,IAAI0J,cAAc,CAACyB,OAAO;MAChE;MAEAC,SAAS,CAACD,OAAO,GAAG9I,UAAU,GAAGkL,8BAAmB;IACtD,CAAC,MAAM;MACLnC,SAAS,CAACD,OAAO,GACfb,kBAAkB,CAACa,OAAO,CAACrN,KAAK,GAAG4L,cAAc,CAACyB,OAAO,GAAGoC,8BAAmB;IACnF;IAEAlC,SAAS,CAACF,OAAO,GAAG,CAAC;IACrBH,GAAG,CAACwC,SAAS,CAAC;MACZxD,CAAC,EAAEoB,SAAS,CAACD,OAAO;MACpBlB,CAAC,EAAEoB,SAAS,CAACF;IACf,CAAC,CAAC;IACFH,GAAG,CAACyC,QAAQ,CAAC;MAAEzD,CAAC,EAAE,CAAC;MAAEC,CAAC,EAAE;IAAE,CAAC,CAAC;IAE5B,IAAItI,UAAU,EAAE;MACd4J,aAAa,CAACJ,OAAO,GACnBR,sBAAsB,CAACQ,OAAO,CAACrN,KAAK,GAAG4L,cAAc,CAACyB,OAAO,GAAGoC,8BAAmB;MACrF/B,aAAa,CAACL,OAAO,GAAG,CAAC;MACzBG,OAAO,CAACkC,SAAS,CAAC;QAChBxD,CAAC,EAAEuB,aAAa,CAACJ,OAAO;QACxBlB,CAAC,EAAEuB,aAAa,CAACL;MACnB,CAAC,CAAC;MACFG,OAAO,CAACmC,QAAQ,CAAC;QAAEzD,CAAC,EAAE,CAAC;QAAEC,CAAC,EAAE;MAAE,CAAC,CAAC;IAClC;EACF,CAAC,EAAE,CAACe,GAAG,EAAEI,SAAS,EAAEE,OAAO,EAAEC,aAAa,EAAE5J,UAAU,EAAExC,QAAQ,EAAElB,aAAa,EAAEmB,QAAQ,CAAC,CAAC;EAE3F,IAAMsO,OAAO,GAAGnK,cAAK,CAACsJ,WAAW,CAC/B,UAACc,YAAY,EAAEC,OAAO,EAAEC,OAAO,EAA6B;IAAA,IAA3BC,cAAc,GAAAf,SAAA,CAAA3L,MAAA,QAAA2L,SAAA,QAAAxP,SAAA,GAAAwP,SAAA,MAAG,KAAK;IACrD,IAAMgB,4BAA4B,GAChCpN,WAAW,IAAIkN,OAAO,KAAK,CAAC,GAAGjH,YAAY,GAAGF,kBAAkB;IAClE,IAAMsH,yBAAyB,GAAG,SAA5BA,yBAAyBA,CAAA;MAAA,SAAAC,IAAA,GAAAlB,SAAA,CAAA3L,MAAA,EAAO8M,IAAI,OAAA3F,KAAA,CAAA0F,IAAA,GAAAE,IAAA,MAAAA,IAAA,GAAAF,IAAA,EAAAE,IAAA;QAAJD,IAAI,CAAAC,IAAA,IAAApB,SAAA,CAAAoB,IAAA;MAAA;MAAA,OAAKnB,kBAAkB,CAAAF,KAAA,UAACe,OAAO,EAAAO,MAAA,CAAKF,IAAI,EAAC;IAAA;IACnF,IAAIpE,eAAe,CAACqB,OAAO,EAAE;MAC3BF,qBAAQ,CAACoD,MAAM,CAACV,YAAY,EAAE;QAC5BC,OAAO,EAAPA,OAAO;QACPU,QAAQ,EAAEC,qCAA0B;QACpCC,eAAe,EAAE;MACnB,CAAC,CAAC,CAACC,KAAK,CAACT,yBAAyB,CAAC;IACrC,CAAC,MAAM,IAAIF,cAAc,IAAI5G,iBAAiB,KAAKC,+BAAoB,CAACuH,QAAQ,EAAE;MAChFzD,qBAAQ,CAACoD,MAAM,CAACV,YAAY,EAAE;QAC5BC,OAAO,EAAPA,OAAO;QACPU,QAAQ,EAAEhH,oBAAoB;QAC9BqH,MAAM,EAAEC,mBAAM,CAACC,GAAG,CAACD,mBAAM,CAACE,KAAK,CAAC;QAChCN,eAAe,EAAE;MACnB,CAAC,CAAC,CAACC,KAAK,CAACT,yBAAyB,CAAC;IACrC,CAAC,MAAM,IAAI5B,SAAS,CAACjB,OAAO,IAAI2C,cAAc,EAAE;MAC9C7C,qBAAQ,CAACoD,MAAM,CAACV,YAAY,EAAE;QAC5BC,OAAO,EAAPA,OAAO;QACPU,QAAQ,EAAEC,qCAA0B;QACpCC,eAAe,EAAE;MACnB,CAAC,CAAC,CAACC,KAAK,CAACT,yBAAyB,CAAC;IACrC,CAAC,MAAM,IAAI9O,iBAAiB,EAAE;MAC5B+L,qBAAQ,CAACoD,MAAM,CAACV,YAAY,EAAA/M,MAAA,CAAAC,MAAA,KACvByE,YAAY;QACfsI,OAAO,EAAPA,OAAO;QACPY,eAAe,EAAE,KAAK;QACtBF,QAAQ,EAAEP,4BAA4B,GAAG;MAAI,EAC9C,CAAC,CAACU,KAAK,CAACT,yBAAyB,CAAC;IACrC,CAAC,MAAM,IAAI/P,aAAa,IAAIC,kCAAkC,EAAE;MAC9D+M,qBAAQ,CAACoD,MAAM,CAACV,YAAY,EAAA/M,MAAA,CAAAC,MAAA,KACvByE,YAAY;QACfsI,OAAO,EAAPA,OAAO;QACPY,eAAe,EAAE,KAAK;QACtBF,QAAQ,EAAEP,4BAA4B,GAAGA,4BAA4B,GAAG,IAAI,GAAG;MAAI,EACpF,CAAC,CAACU,KAAK,CAACT,yBAAyB,CAAC;IACrC,CAAC,MAAM;MACL/C,qBAAQ,CAAC8D,MAAM,CAACpB,YAAY,EAAA/M,MAAA,CAAAC,MAAA,KACvByE,YAAY;QACfsI,OAAO,EAAPA,OAAO;QACPY,eAAe,EAAE;MAAK,EACvB,CAAC,CAACC,KAAK,CAACT,yBAAyB,CAAC;IACrC;EACF,CAAC,EACD,CACE1I,YAAY,EACZ0H,kBAAkB,EAClBtG,kBAAkB,EAClBE,YAAY,EACZjG,WAAW,EACXzB,iBAAiB,EACjBjB,aAAa,EACbC,kCAAkC,EAClCgJ,iBAAiB,EACjBI,oBAAoB,CAExB,CAAC;EAED,IAAM0H,YAAY,GAAGzL,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC3C,IAAIR,WAAW,YAAXA,WAAW,CAAElB,OAAO,EAAE;MACxB8D,YAAY,CAAC5C,WAAW,oBAAXA,WAAW,CAAElB,OAAO,CAAC;IACpC;EACF,CAAC,EAAE,EAAE,CAAC;EAEN,IAAM+D,cAAc,GAAG3L,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC7C,IAAI5H,OAAO,IAAI5H,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MAAA,IAAA6R,qBAAA;MACpC,CAAAA,qBAAA,GAAApE,aAAa,CAACI,OAAO,aAArBgE,qBAAA,CAAuBC,KAAK,CAAC;QAAEC,aAAa,EAAE,IAAI;QAAEC,YAAY,EAAE;MAAM,CAAC,CAAC;IAC5E;EACF,CAAC,EAAE,CAACrK,OAAO,EAAE8F,aAAa,CAAC,CAAC;EAE5B,IAAMwE,WAAW,GAAGhM,cAAK,CAACsJ,WAAW,CACnC,YAA+B;IAAA,IAA9B2C,KAAK,GAAAzC,SAAA,CAAA3L,MAAA,QAAA2L,SAAA,QAAAxP,SAAA,GAAAwP,SAAA,MAAG,CAAC;IAAA,IAAE0C,cAAc,GAAA1C,SAAA,CAAA3L,MAAA,OAAA2L,SAAA,MAAAxP,SAAA;IACxB,IAAMqQ,OAAO,GAAG;MAAE5D,CAAC,EAAE,CAAC;MAAEC,CAAC,EAAE;IAAE,CAAC;IAC9B,IAAIyF,WAAW,GAAG,CAACF,KAAK;IACxB,IAAIG,SAAS,GAAGH,KAAK;IACrB,IAAM1B,cAAc,GAAG2B,cAAc,KAAKG,2BAAgB,CAACC,KAAK;IAChE,IAAInG,cAAc,CAACyB,OAAO,IAAI,CAAC,IAAIqE,KAAK,GAAG,CAAC,EAAE;MAC5CE,WAAW,GAAGD,cAAc,KAAKG,2BAAgB,CAACE,SAAS;MAC3DH,SAAS,GAAGtH,UAAU,GAAGmH,KAAK;IAChC,CAAC,MAAM,IAAI9F,cAAc,CAACyB,OAAO,GAAG,CAAC,IAAI9C,UAAU,IAAImH,KAAK,GAAG,CAAC,EAAE;MAChEE,WAAW,GAAGD,cAAc,KAAKG,2BAAgB,CAACE,SAAS;MAC3DH,SAAS,GAAG,CAAC,CAAC,GAAGjG,cAAc,CAACyB,OAAO,GAAGqE,KAAK,GAAG,CAAC;IACrD;IAEA,IAAMO,KAAK,GAAGrG,cAAc,CAACyB,OAAO,GAAGwE,SAAS;IAChD,IAAID,WAAW,EAAE;MACf/H,kBAAkB,CAACwD,OAAO,GAAG,IAAI;MACjCuC,OAAO,CAAC1C,GAAG,EAAE4C,OAAO,EAAEmC,KAAK,EAAEjC,cAAc,CAAC;MAE5C,IAAInM,UAAU,EAAE;QACd+L,OAAO,CAACpC,OAAO,EAAEsC,OAAO,EAAEmC,KAAK,EAAEjC,cAAc,CAAC;MAClD;MACA,OAAO6B,SAAS;IAClB;IAEAX,YAAY,CAAC,CAAC;IACdvF,cAAc,CAACsG,KAAK,CAAC;IAErB,IAAM1N,UAAU,GAAGD,mBAAmB,CACpCkI,kBAAkB,CAACa,OAAO,CAACrN,KAAK,EAChCG,aAAa,EACbkB,QAAQ,EACRC,QACF,CAAC;IAEDwO,OAAO,CAAC5D,CAAC,GAAG3H,UAAU,GAAG,CAAC,CAAC,GAAGsN,SAAS;IACvC,IAAMK,WAAW,GAAG;MAAEhG,CAAC,EAAE,CAAC;MAAEC,CAAC,EAAE;IAAE,CAAC;IAClC+F,WAAW,CAAChG,CAAC,GAAGW,sBAAsB,CAACQ,OAAO,CAACrN,KAAK,GAAG,CAAC,CAAC,GAAG6R,SAAS;IACrEhI,kBAAkB,CAACwD,OAAO,GAAG,IAAI;IACjCuC,OAAO,CAAC1C,GAAG,EAAE4C,OAAO,EAAEmC,KAAK,EAAEjC,cAAc,CAAC;IAC5C,IAAInM,UAAU,EAAE;MACd+L,OAAO,CAACpC,OAAO,EAAE0E,WAAW,EAAED,KAAK,EAAEjC,cAAc,CAAC;IACtD;IACA,IAAI5B,iBAAiB,EAAE;MACrB8C,YAAY,CAAC,CAAC;MACd,IACEe,KAAK,KAAK,CAAC,IACXrG,cAAc,CAACyB,OAAO,GAAG,CAAC,KAAK9C,UAAU,IACzCoH,cAAc,KAAKG,2BAAgB,CAACE,SAAS,EAC7C;QACA3D,oBAAoB,CAAC,KAAK,CAAC;MAC7B,CAAC,MAAM,IAAIjN,iBAAiB,EAAE;QAC5BmN,WAAW,CAAClB,OAAO,GAAG8E,UAAU,CAAC,YAAM;UACrC7C,YAAY,CAAC,CAAC;UACdR,oBAAoB,CAAClD,cAAc,CAACyB,OAAO,CAAC;UAC5CoE,WAAW,CAAC/I,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAEoJ,2BAAgB,CAACE,SAAS,CAAC;UACnEZ,cAAc,CAAC,CAAC;QAClB,CAAC,EAAEhP,IAAI,CAACgQ,GAAG,CAAC1J,aAAa,CAAC,GAAG,IAAI,CAAC;MACpC;IACF;IACA,IAAI1B,cAAc,EAAEA,cAAc,CAAC6K,SAAS,EAAEI,KAAK,CAAC;IACpD,OAAOJ,SAAS;EAClB,CAAC,EACD,CACE/C,oBAAoB,EACpBsC,cAAc,EACd1I,aAAa,EACb4G,YAAY,EACZM,OAAO,EACPrF,UAAU,EACVvD,cAAc,EACdoH,iBAAiB,EACjB8C,YAAY,EACZ9P,iBAAiB,EACjBC,QAAQ,EACRlB,aAAa,EACb+M,GAAG,EACHM,OAAO,EACP3J,UAAU,EACVvC,QAAQ,CAEZ,CAAC;EAED,IAAM+Q,aAAa,GAAG5M,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC5CmC,YAAY,CAAC,CAAC;IACd,IAAI9P,iBAAiB,EAAE;MACrBmN,WAAW,CAAClB,OAAO,GAAG8E,UAAU,CAAC,YAAM;QACrC7C,YAAY,CAAC,CAAC;QACdR,oBAAoB,CAAClD,cAAc,CAACyB,OAAO,CAAC;QAC5CoE,WAAW,CAAC/I,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAEoJ,2BAAgB,CAACE,SAAS,CAAC;QACnEZ,cAAc,CAAC,CAAC;MAClB,CAAC,EAAEhP,IAAI,CAACgQ,GAAG,CAAC1J,aAAa,CAAC,GAAG,IAAI,CAAC;IACpC;EACF,CAAC,EAAE,CACDoG,oBAAoB,EACpBsC,cAAc,EACdK,WAAW,EACXnC,YAAY,EACZ5G,aAAa,EACbwI,YAAY,EACZ9P,iBAAiB,CAClB,CAAC;EAEF,IAAMkR,cAAc,GAAG7M,cAAK,CAACsJ,WAAW,CACtC,UAAC2C,KAAK,EAAEC,cAAc,EAAK;IACzBrC,YAAY,CAAC,CAAC;IACdR,oBAAoB,CAAClD,cAAc,CAACyB,OAAO,CAAC;IAC5CoE,WAAW,CAACC,KAAK,EAAEC,cAAc,CAAC;IAClCP,cAAc,CAAC,CAAC;EAClB,CAAC,EACD,CAACK,WAAW,EAAEnC,YAAY,EAAER,oBAAoB,EAAEsC,cAAc,CAClE,CAAC;EAED,IAAMmB,eAAe,GAAG9M,cAAK,CAACsJ,WAAW,CACvC,YAA8D;IAAA,IAA7DyD,MAAM,GAAAvD,SAAA,CAAA3L,MAAA,QAAA2L,SAAA,QAAAxP,SAAA,GAAAwP,SAAA,MAAG,KAAK;IAAA,IAAE0C,cAAc,GAAA1C,SAAA,CAAA3L,MAAA,QAAA2L,SAAA,QAAAxP,SAAA,GAAAwP,SAAA,MAAG6C,2BAAgB,CAACW,MAAM;IACvDH,cAAc,CAACE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,EAAEb,cAAc,CAAC;EACjD,CAAC,EACD,CAACW,cAAc,CACjB,CAAC;EAED7M,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB9G,cAAc,CAACyB,OAAO,GAAG3B,WAAW;EACtC,CAAC,EAAE,CAACA,WAAW,CAAC,CAAC;EAEjBjG,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB1G,eAAe,CAACqB,OAAO,GAAGtB,mBAAmB;EAC/C,CAAC,EAAE,CAACA,mBAAmB,CAAC,CAAC;EAEzBtG,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpBlG,kBAAkB,CAACa,OAAO,GAAGf,eAAe;EAC9C,CAAC,EAAE,CAACA,eAAe,CAAC,CAAC;EAErB7G,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB7F,sBAAsB,CAACQ,OAAO,GAAGV,mBAAmB;EACtD,CAAC,EAAE,CAACA,mBAAmB,CAAC,CAAC;EAEzBlH,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB9D,sBAAsB,CAACvB,OAAO,GAAGqB,mBAAmB;EACtD,CAAC,EAAE,CAACA,mBAAmB,CAAC,CAAC;EAEzBjJ,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpBxF,GAAG,CAAChB,CAAC,CAACyG,WAAW,CAAC,UAAAC,KAAA,EAAe;MAAA,IAAZC,KAAK,GAAAD,KAAA,CAALC,KAAK;MACxBvF,SAAS,CAACD,OAAO,GAAGwF,KAAK;IAC3B,CAAC,CAAC;IACF3F,GAAG,CAACf,CAAC,CAACwG,WAAW,CAAC,UAAAG,KAAA,EAAe;MAAA,IAAZD,KAAK,GAAAC,KAAA,CAALD,KAAK;MACxBtF,SAAS,CAACF,OAAO,GAAGwF,KAAK;IAC3B,CAAC,CAAC;IACF,IAAIhP,UAAU,EAAE;MACd2J,OAAO,CAACtB,CAAC,CAACyG,WAAW,CAAC,UAAAI,KAAA,EAAe;QAAA,IAAZF,KAAK,GAAAE,KAAA,CAALF,KAAK;QAC5BpF,aAAa,CAACJ,OAAO,GAAGwF,KAAK;MAC/B,CAAC,CAAC;MACFrF,OAAO,CAACrB,CAAC,CAACwG,WAAW,CAAC,UAAAK,KAAA,EAAe;QAAA,IAAZH,KAAK,GAAAG,KAAA,CAALH,KAAK;QAC5BnF,aAAa,CAACL,OAAO,GAAGwF,KAAK;MAC/B,CAAC,CAAC;IACJ;IACA,IAAIzE,iBAAiB,EAAE;MACrBiE,aAAa,CAAC,CAAC;IACjB;IACA,OAAO,YAAM;MACXnB,YAAY,CAAC,CAAC;MACdhE,GAAG,CAAChB,CAAC,CAAC+G,kBAAkB,CAAC,CAAC;MAC1B/F,GAAG,CAACf,CAAC,CAAC8G,kBAAkB,CAAC,CAAC;MAC1B,IAAIpP,UAAU,EAAE;QACd2J,OAAO,CAACtB,CAAC,CAAC+G,kBAAkB,CAAC,CAAC;QAC9BzF,OAAO,CAACrB,CAAC,CAAC8G,kBAAkB,CAAC,CAAC;MAChC;IACF,CAAC;EACH,CAAC,EAAE,CACD/F,GAAG,CAAChB,CAAC,EACLgB,GAAG,CAACf,CAAC,EACLqB,OAAO,CAACtB,CAAC,EACTsB,OAAO,CAACrB,CAAC,EACTkG,aAAa,EACbnB,YAAY,EACZ9C,iBAAiB,EACjBvK,UAAU,CACX,CAAC;EAEF4B,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB,IAAMQ,YAAY,GAAGC,uBAAU,CAACC,gBAAgB,CAAC,QAAQ,EAAE,YAAM;MAC/D9D,YAAY,CAAC,CAAC;IAChB,CAAC,CAAC;IAEF,OAAO,YAAM;MACX,IAAI4D,YAAY,CAACG,MAAM,EAAE;QACvBH,YAAY,CAACG,MAAM,CAAC,CAAC;MACvB,CAAC,MAAM;QACLF,uBAAU,CAACG,mBAAmB,CAAC,QAAQ,EAAEhE,YAAY,CAAC;MACxD;IACF,CAAC;EACH,CAAC,EAAE,CAACA,YAAY,CAAC,CAAC;EAElB7J,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpBzE,oBAAoB,CAClBjF,QAAQ,IAAIN,aAAa,GAAG,CAAC,IAAIE,kBAAkB,GAAG,CAAC,IAAI2B,UAAU,GAAG,CAC1E,CAAC;EACH,CAAC,EAAE,CAACvB,QAAQ,EAAEN,aAAa,EAAEE,kBAAkB,EAAE2B,UAAU,CAAC,CAAC;EAE7D9E,cAAK,CAACiN,SAAS,CAAC,YAAM;IACpB,OAAO,YAAM;MACXxB,YAAY,CAAC,CAAC;IAChB,CAAC;EACH,CAAC,EAAE,CAACA,YAAY,CAAC,CAAC;EAElB,IAAMqC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAAAC,KAAA;IAAA,IAAAC,qBAAA,GAAAD,KAAA,CACrBE,WAAW,CACTC,MAAM;MAAIzH,CAAC,GAAAuH,qBAAA,CAADvH,CAAC;MAAEC,CAAC,GAAAsH,qBAAA,CAADtH,CAAC;MAAEnM,KAAK,GAAAyT,qBAAA,CAALzT,KAAK;MAAEoM,MAAM,GAAAqH,qBAAA,CAANrH,MAAM;IAAA,OAE3BG,kBAAkB,CAAC,UAACqH,SAAS;MAAA,OAAA9Q,MAAA,CAAAC,MAAA,KAAW6Q,SAAS;QAAE1H,CAAC,EAADA,CAAC;QAAEC,CAAC,EAADA,CAAC;QAAEnM,KAAK,EAALA,KAAK;QAAEoM,MAAM,EAANA;MAAM;IAAA,CAAG,CAAC;EAAA;EAEhF,IAAMyH,qBAAqB,GAAG,SAAxBA,qBAAqBA,CAAAC,KAAA;IAAA,IAAAC,qBAAA,GAAAD,KAAA,CACzBJ,WAAW,CACTC,MAAM;MAAIzH,CAAC,GAAA6H,qBAAA,CAAD7H,CAAC;MAAEC,CAAC,GAAA4H,qBAAA,CAAD5H,CAAC;MAAEnM,KAAK,GAAA+T,qBAAA,CAAL/T,KAAK;MAAEoM,MAAM,GAAA2H,qBAAA,CAAN3H,MAAM;IAAA,OAE3BQ,sBAAsB,CAAC,UAACgH,SAAS;MAAA,OAAA9Q,MAAA,CAAAC,MAAA,KAAW6Q,SAAS;QAAE1H,CAAC,EAADA,CAAC;QAAEC,CAAC,EAADA,CAAC;QAAEnM,KAAK,EAALA,KAAK;QAAEoM,MAAM,EAANA;MAAM;IAAA,CAAG,CAAC;EAAA;EAEpF,IAAM4H,oCAAoC,GAAG,SAAvCA,oCAAoCA,CAAAC,KAAA;IAAA,IAE5BjU,KAAK,GAAAiU,KAAA,CADjBP,WAAW,CACTC,MAAM,CAAI3T,KAAK;IAAA,OAEbgN,oCAAoC,CAAChN,KAAK,CAAC;EAAA;EAEjD,IAAMkU,qBAAqB,GAAG,SAAxBA,qBAAqBA,CAAAC,MAAA;IAAA,IAAAC,qBAAA,GAAAD,MAAA,CACzBT,WAAW,CACTC,MAAM;MAAIzH,CAAC,GAAAkI,qBAAA,CAADlI,CAAC;MAAEC,CAAC,GAAAiI,qBAAA,CAADjI,CAAC;MAAEnM,KAAK,GAAAoU,qBAAA,CAALpU,KAAK;MAAEoM,MAAM,GAAAgI,qBAAA,CAANhI,MAAM;IAAA,OAE3BuC,sBAAsB,CAAC,UAACiF,SAAS;MAAA,OAAA9Q,MAAA,CAAAC,MAAA,KAAW6Q,SAAS;QAAE1H,CAAC,EAADA,CAAC;QAAEC,CAAC,EAADA,CAAC;QAAEnM,KAAK,EAALA,KAAK;QAAEoM,MAAM,EAANA;MAAM;IAAA,CAAG,CAAC;EAAA;EAEpF,IAAMiI,cAAc,GAAG5O,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC7C,IAAIxE,UAAU,KAAK,CAAC,EAAE;MACpB,OAAO,KAAK;IACd;IACA,IAAIhL,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzB,OAAO,CAAC,EAAE6B,QAAQ,KAAK,IAAI,IAAIA,QAAQ,KAAK,IAAI,IAAKA,QAAQ,KAAK,IAAI,IAAI,IAAAiT,4BAAa,EAAC,CAAE,CAAC;IAC7F;IACA,OAAO,IAAI;EACb,CAAC,EAAE,CAACjT,QAAQ,EAAEkJ,UAAU,CAAC,CAAC;EAE1B,IAAMgK,YAAY,GAAG9O,cAAK,CAAC+O,OAAO,CAChC;IAAA,OACEC,yBAAY,CAAC7V,MAAM,CAAC;MAClB8V,gCAAgC,EAAE,SAAlCA,gCAAgCA,CAAA;QAAA,OAAQ,KAAK;MAAA;MAC7CC,+BAA+B,EAAE,SAAjCA,+BAA+BA,CAAA;QAAA,OAAQ,IAAI;MAAA;MAC3CC,kCAAkC,EAAE,SAApCA,kCAAkCA,CAAGC,CAAC,EAAEC,YAAY,EAAK;QACvD,IAAI,CAACT,cAAc,CAAC,CAAC,EAAE;UACrB,OAAO,KAAK;QACd;QAEAvF,oBAAoB,CAAClD,cAAc,CAACyB,OAAO,CAAC;QAE5C,IAAM0H,KAAK,GAAG3S,IAAI,CAACgQ,GAAG,CAAC0C,YAAY,CAACE,EAAE,CAAC,GAAGrO,oBAAoB;QAE9D,IAAIoO,KAAK,EAAE;UACTzG,SAAS,CAACjB,OAAO,GAAG,IAAI;UACxB6D,YAAY,CAAC,CAAC;QAChB;QAEA,OAAO6D,KAAK;MACd,CAAC;MACDE,mBAAmB,EAAE,SAArBA,mBAAmBA,CAAA,EAAQ;QACzB3F,YAAY,CAAC,CAAC;MAChB,CAAC;MACD4F,kBAAkB,EAAE/H,qBAAQ,CAACgI,KAAK,CAAC,CAAC,IAAI,EAAE;QAAEH,EAAE,EAAE9H,GAAG,CAAChB;MAAE,CAAC,CAAC,EAAE;QACxDwE,eAAe,EAAE;MACnB,CAAC,CAAC;MACF0E,qBAAqB,EAAE,SAAvBA,qBAAqBA,CAAGP,CAAC,EAAEQ,OAAO,EAAK;QACrC,IAAIjH,iBAAiB,EAAE;UACrBiE,aAAa,CAAC,CAAC;QACjB;QACA,IAAMiD,UAAU,GAAGD,OAAO,CAACE,KAAK,GAAGF,OAAO,CAACG,EAAE;QAE7ClH,SAAS,CAACjB,OAAO,GAAG,KAAK;QAEzB,IAAIjL,IAAI,CAACgQ,GAAG,CAACkD,UAAU,CAAC,GAAG9I,kBAAkB,CAACa,OAAO,CAACrN,KAAK,GAAG6G,oBAAoB,EAAE;UAClF+I,OAAO,CAAC1C,GAAG,EAAE;YAAEhB,CAAC,EAAE,CAAC;YAAEC,CAAC,EAAE;UAAE,CAAC,EAAEP,cAAc,CAACyB,OAAO,EAAE,IAAI,CAAC;QAC5D,CAAC,MAAM;UACL,IAAMqE,KAAK,GAAG4D,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;UACrC7D,WAAW,CAACC,KAAK,EAAEI,2BAAgB,CAACC,KAAK,CAAC;QAC5C;MACF;IACF,CAAC,CAAC;EAAA,GACJ,CACE7E,GAAG,EACHuE,WAAW,EACXnC,YAAY,EACZM,OAAO,EACPyE,cAAc,EACdxN,oBAAoB,EACpBiI,oBAAoB,EACpBnI,oBAAoB,EACpB0L,aAAa,EACbnB,YAAY,EACZ9C,iBAAiB,CAErB,CAAC;EAED,IAAMqH,gBAAgB,GAAGhQ,cAAK,CAAC+O,OAAO,CACpC;IAAA,OACEC,yBAAY,CAAC7V,MAAM,CAAC;MAClB8V,gCAAgC,EAAE,SAAlCA,gCAAgCA,CAAA;QAAA,OAAQ,KAAK;MAAA;MAC7CC,+BAA+B,EAAE,SAAjCA,+BAA+BA,CAAA;QAAA,OAAQ,IAAI;MAAA;MAC3CC,kCAAkC,EAAE,SAApCA,kCAAkCA,CAAGC,CAAC,EAAEC,YAAY,EAAK;QACvD,IAAI,CAACT,cAAc,CAAC,CAAC,EAAE;UACrB,OAAO,KAAK;QACd;QAEAvF,oBAAoB,CAAClD,cAAc,CAACyB,OAAO,CAAC;QAE5C,IAAM0H,KAAK,GAAG3S,IAAI,CAACgQ,GAAG,CAAC0C,YAAY,CAACE,EAAE,CAAC,GAAGrO,oBAAoB;QAE9D,IAAIoO,KAAK,EAAE;UACTzG,SAAS,CAACjB,OAAO,GAAG,IAAI;UACxB6D,YAAY,CAAC,CAAC;QAChB;QAEA,OAAO6D,KAAK;MACd,CAAC;MACDE,mBAAmB,EAAE,SAArBA,mBAAmBA,CAAA,EAAQ;QACzB3F,YAAY,CAAC,CAAC;MAChB,CAAC;MACD4F,kBAAkB,EAAE/H,qBAAQ,CAACgI,KAAK,CAAC,CAAC,IAAI,EAAE;QAAEH,EAAE,EAAExH,OAAO,CAACtB;MAAE,CAAC,CAAC,EAAE;QAC5DwE,eAAe,EAAE;MACnB,CAAC,CAAC;MACF0E,qBAAqB,EAAE,SAAvBA,qBAAqBA,CAAGP,CAAC,EAAEQ,OAAO,EAAK;QACrC,IAAIjH,iBAAiB,EAAE;UACrBiE,aAAa,CAAC,CAAC;QACjB;QACA,IAAMiD,UAAU,GAAGD,OAAO,CAACE,KAAK,GAAGF,OAAO,CAACG,EAAE;QAE7ClH,SAAS,CAACjB,OAAO,GAAG,KAAK;QAEzB,IAAIjL,IAAI,CAACgQ,GAAG,CAACkD,UAAU,CAAC,GAAG9I,kBAAkB,CAACa,OAAO,CAACrN,KAAK,GAAG6G,oBAAoB,EAAE;UAClF+I,OAAO,CAACpC,OAAO,EAAE;YAAEtB,CAAC,EAAE,CAAC;YAAEC,CAAC,EAAE;UAAE,CAAC,EAAEP,cAAc,CAACyB,OAAO,EAAE,IAAI,CAAC;QAChE,CAAC,MAAM;UACL,IAAMqE,KAAK,GAAG4D,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;UACrC7D,WAAW,CAACC,KAAK,EAAEI,2BAAgB,CAACC,KAAK,CAAC;QAC5C;MACF;IACF,CAAC,CAAC;EAAA,GACJ,CACEvE,OAAO,EACPiE,WAAW,EACXnC,YAAY,EACZM,OAAO,EACPyE,cAAc,EACdxN,oBAAoB,EACpBiI,oBAAoB,EACpBnI,oBAAoB,EACpB0L,aAAa,EACbnB,YAAY,EACZ9C,iBAAiB,CAErB,CAAC;EAED,IAAMsH,QAAQ,GAAGjQ,cAAK,CAACsJ,WAAW,CAAC,YAAM;IACvCwD,eAAe,CAAC,CAAC;EACnB,CAAC,EAAE,CAACA,eAAe,CAAC,CAAC;EAErB,IAAMoD,QAAQ,GAAGlQ,cAAK,CAACsJ,WAAW,CAAC,YAAM;IACvCwD,eAAe,CAAC,IAAI,CAAC;EACvB,CAAC,EAAE,CAACA,eAAe,CAAC,CAAC;EAErB,IAAMqD,IAAI,GAAGnQ,cAAK,CAACsJ,WAAW,CAC5B,YAAe;IAAA,IAAdkD,KAAK,GAAAhD,SAAA,CAAA3L,MAAA,QAAA2L,SAAA,QAAAxP,SAAA,GAAAwP,SAAA,MAAG,CAAC;IACR,IAAMyC,KAAK,GAAGO,KAAK,GAAGrG,cAAc,CAACyB,OAAO;IAC5C,IAAIqE,KAAK,EAAE;MACTY,cAAc,CAACZ,KAAK,EAAEI,2BAAgB,CAACW,MAAM,CAAC;IAChD;EACF,CAAC,EACD,CAACH,cAAc,CACjB,CAAC;EAKD,IAAMuD,8BAA8B,GAAG;IACrCC,IAAI,EAAErP,oBAAoB;IAC1BsP,MAAM,EAAE;EACV,CAAC;EAED,IAAMC,uBAAuB,GAAGvQ,cAAK,CAACsJ,WAAW,CAC/C,UAACkH,OAAO,EAAK;IACX,IAAMC,QAAQ,GAAGvL,OAAO,CAACsL,OAAO,CAAC,CAC9BE,OAAO,CAAC,aAAa,EAAE7O,KAAK,CAAC,CAC7B6O,OAAO,CAAC,iBAAiB,EAAEjQ,SAAS,CAAC,CACrCiQ,OAAO,CAAC,kBAAkB,EAAEzK,WAAW,GAAG,CAAC,CAAC,CAC5CyK,OAAO,CAAC,iBAAiB,EAAE5L,UAAU,CAAC;IAGzC,OAAO,GAAG2L,QAAQ,CAAC,CAAC,CAAC,CAACE,WAAW,CAAC,CAAC,GAAGF,QAAQ,CAACG,KAAK,CAAC,CAAC,CAAC,EAAE;EAC3D,CAAC,EACD,CAAC3K,WAAW,EAAExF,SAAS,EAAEyE,OAAO,EAAErD,KAAK,EAAEiD,UAAU,CACrD,CAAC;EAED,IAAM+L,qBAAqB,GACzBpS,IAAI,IAAIoH,aAAa,GAAG,IAAA9M,WAAA,CAAAuJ,GAAA,EAAC5J,kBAAA,CAAAoY,iBAAiB;IAACC,KAAK,EAAEtS;EAAK,CAAE,CAAC,GAAG4D,eAAe;EAE9E,IAAM2O,qBAAqB,GAAGrP,OAAO,CAACD,OAAO,IAAI,CAACF,YAAY,CAAC;EAC/D,IAAMyP,YAAY,GAAG,SAAfA,YAAYA,CAAIC,OAAO,EAAK;IAEhC1J,aAAa,CAACI,OAAO,GAAGsJ,OAAO;IAE/B,IAAI/Q,GAAG,EAAE;MACP,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;QAE3BA,GAAG,CAACyH,OAAO,GAAGsJ,OAAO;MACvB,CAAC,MAAM,IAAI,OAAO/Q,GAAG,KAAK,UAAU,EAAE;QACpCA,GAAG,CAAC+Q,OAAO,CAAC;MACd;IACF;EACF,CAAC;EAED,IAAMC,WAAW,GAAGvR,WAAW,CAAAvC,MAAA,CAAAC,MAAA,KAC1B2G,IAAI;IACPtB,iBAAiB,EAAjBA,iBAAiB;IACjBC,kBAAkB,EAAlBA;EAAkB,EACnB,CAAC;EAIF,IAAMwO,2BAA2B,GAC/B,EAAAhR,qBAAA,GAAA+Q,WAAW,CAACvO,kBAAkB,YAAAxC,qBAAA,GAAI4Q,qBAAqB,IACnD,GAAGnP,KAAK,GAAG,GAAGA,KAAK,GAAG,GAAG,EAAE,GAAG0O,uBAAuB,CAAC,kBAAkB,CAAC,EAAE,GAC3E1O,KAAK;EACX,IAAMwP,cAAc,GAAAhU,MAAA,CAAAC,MAAA;IAClBsF,kBAAkB,EAAEwO;EAA2B,GAE3CJ,qBAAqB,IAAI;IAAE7Q,GAAG,EAAE8Q,YAAY;IAAEK,SAAS,EAAE;EAAK,CAAC,CACpE;EAED,IAAMC,6BAA6B,GAAGvR,cAAK,CAACsJ,WAAW,CAAC,YAAM;IAC5D,IAAIX,iBAAiB,EAAE;MACrB8C,YAAY,CAAC,CAAC;IAChB,CAAC,MAAM;MACLmB,aAAa,CAAC,CAAC;IACjB;IACAhE,oBAAoB,CAAC,UAACuF,SAAS;MAAA,OAAK,CAACA,SAAS;IAAA,EAAC;EACjD,CAAC,EAAE,CAACxF,iBAAiB,EAAE8C,YAAY,EAAEmB,aAAa,CAAC,CAAC;EAEpD,IAAM4E,aAAa,GAAGxR,cAAK,CAACsJ,WAAW,CACrC,UAACoG,KAAK,EAAK;IACT,IAAItL,kBAAkB,CAACwD,OAAO,IAAI8H,KAAK,CAAC+B,GAAG,KAAK,KAAK,EAAE;MACrD/B,KAAK,CAACgC,cAAc,CAAC,CAAC;IACxB;EACF,CAAC,EACD,CAACtN,kBAAkB,CACrB,CAAC;EAED,OACE,IAAArL,WAAA,CAAA4Y,IAAA,EAACxa,YAAA,CAAAya,IAAI;IACH9Q,KAAK,EAAE3C,yBAAyB,CAACC,UAAU,EAAExC,QAAQ,EAAElB,aAAa,CAAE;IACtEmX,QAAQ,EAAEpD,qBAAsB;IAAAlO,QAAA,GAEhC,IAAAxH,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;MAAC9Q,KAAK,EAAExC,yBAAyB,CAACF,UAAU,EAAExC,QAAQ,EAAEC,QAAQ,EAAEnB,aAAa,CAAE;MAAA6F,QAAA,EACpF,IAAAxH,WAAA,CAAA4Y,IAAA,EAACvZ,gBAAA,CAAA0Z,gBAAgB;QACf7L,WAAW,EAAEA,WAAY;QACzBkK,IAAI,EAAEA,IAAK;QACXI,uBAAuB,EAAEA,uBAAwB;QACjD9P,SAAS,EAAEA,SAAU;QACrBqE,UAAU,EAAEA,UAAW;QACvBO,WAAW,EAAEA,WAAY;QACzBmC,aAAa,EAAEA,aAAc;QAC7B9F,OAAO,EAAEA,OAAQ;QACjBnH,KAAK,EAAEsM,eAAe,CAACtM,KAAM;QAC7BwX,oBAAoB,EAAE9T,uBAAuB,CAC3CtD,kCAAkC,EAClCiB,QACF,CAAE;QACFC,QAAQ,EAAEA,QAAS;QACnBmW,aAAa,EAAE5I,oBAAqB;QAAA7I,QAAA,GAEpC,IAAAxH,WAAA,CAAA4Y,IAAA,EAACxa,YAAA,CAAAya,IAAI,EAAAvU,MAAA,CAAAC,MAAA;UACHwD,KAAK,EAAE,CACL7H,YAAY,CAACG,IAAI,EAAAiE,MAAA,CAAAC,MAAA,KAEXxD,qBAAQ,CAACC,EAAE,KAAK,KAAK,GAAG;YAAEkY,OAAO,EAAE;UAAO,CAAC,GAAG,CAAC,CAAC,EAEtD;UACFJ,QAAQ,EAAE/D,iBAAkB;UAC5B3N,GAAG,EAAEA;QAAI,GACLgR,WAAW,EACXE,cAAc,EACbvX,qBAAQ,CAACC,EAAE,KAAK,KAAK,GAAG;UAAEmY,SAAS,EAAEV;QAAc,CAAC,GAAG,CAAC,CAAC;UAAAjR,QAAA,GAE7D5E,iBAAiB,GAChB,IAAA5C,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;YACH9Q,KAAK,EAAE,CACL7H,YAAY,CAACU,sBAAsB,EACnCyB,iCAAiC,CAAC;cAChCE,eAAe,EAAE2B,8BAA8B;cAC/C1B,WAAW,EAAEyB,iCAAiC;cAC9CvB,gBAAgB,EAAEV,0BAA0B,CAAC,CAAC;cAC9CW,0BAA0B,EAAEwB,0CAA0C;cACtExC,aAAa,EAAbA,aAAa;cACbC,kCAAkC,EAAlCA,kCAAkC;cAClCgB,iBAAiB,EAAjBA,iBAAiB;cACjBC,QAAQ,EAARA,QAAQ;cACRC,QAAQ,EAARA,QAAQ;cACRC,cAAc,EAAE+K,eAAe,CAACtM;YAClC,CAAC,CAAC,CACF;YAAAgG,QAAA,EAEF,IAAAxH,WAAA,CAAAuJ,GAAA,EAACjK,WAAA,CAAA8Z,UAAU;cACTC,IAAI,EAAEzJ,iBAAiB,GAAGjD,SAAS,GAAGD,QAAS;cAC/C7C,kBAAkB,EAChB+F,iBAAiB,GAAGzD,OAAO,CAAC,kBAAkB,CAAC,GAAGA,OAAO,CAAC,iBAAiB,CAC5E;cACD5E,OAAO,EAAE8P,8BAA+B;cACxCiC,OAAO,EAAEd;YAA8B,CACxC;UAAC,CACE,CAAC,GACL,IAAI,EACP5L,0BAA0B,IAAIb,UAAU,GAAG,CAAC,GAC3C,IAAA/L,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;YACH9Q,KAAK,EAAE/D,wCAAwC,CAC7CC,iCAAiC,EACjCC,8BAA8B,EAC9BC,0CAA0C,EAC1CC,YAAY,EACZC,WAAW,EACX,IAAI,EACJ1C,aAAa,EACbC,kCAAkC,EAClCgB,iBAAiB,EACjBC,QAAQ,EACRC,QAAQ,EACRgL,eAAe,CAACtM,KAClB,CAAE;YACF+X,MAAM,EAAC,2BAA2B;YAAA/R,QAAA,EAElC,IAAAxH,WAAA,CAAAuJ,GAAA,EAACjK,WAAA,CAAA8Z,UAAU;cACTN,QAAQ,EAAEtD,oCAAqC;cAC/C6D,IAAI,EAAE7M,YAAa;cACnB8M,OAAO,EAAEnC,QAAS;cAClB5P,OAAO,EAAE8P,8BAA+B;cACxCxN,kBAAkB,EAAE2N,uBAAuB,CAAC,iBAAiB,CAAC,CAACG,OAAO,CACpE,eAAe,EACfzK,WACF,CAAE;cACF5F,MAAM,EAAEnB,gBAAgB,CAACmG,WAAW;YAAE,CACvC;UAAC,CACE,CAAC,GACL,IAAI,EACP1D,OAAO,CAACH,YAAY,CAAC,IACpB,IAAAzI,WAAA,CAAAuJ,GAAA,EAAChK,SAAA,CAAAia,QAAQ;YAACpS,GAAG,EAAEqH,aAAc;YAACgL,IAAI,EAAEhR,YAAa;YAAAjB,QAAA,EAC9CgQ,uBAAuB,CAAC,UAAU;UAAC,CAC5B,CACX,EACA,CAACS,qBAAqB,IACrB,IAAAjY,WAAA,CAAAuJ,GAAA,EAAC/J,SAAA,CAAAka,QAAQ;YAGP3P,uBAAuB,EAAE,CAACtB,YAAY,IAAIE,OAAO,GAAG1H,SAAS,GAAG,QAAS;YACzE0Y,IAAI,EAAEnC,uBAAuB,CAAC,kBAAkB;UAAE,CACnD,CACF,EACD,IAAAxX,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;YAAC9Q,KAAK,EAAExG,qBAAqB,CAACuM,eAAe,CAACtM,KAAK,CAAE;YAAAgG,QAAA,EACxD,IAAAxH,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAuQ,QAAQ,CAACkK,IAAI,EAAAvU,MAAA,CAAAC,MAAA;cACZwD,KAAK,EAAE5H,uBAAU,CAACyZ,OAAO,CAAC,CACxBnY,qBAAqB,CACnBsK,UAAU,EACV+B,eAAe,CAACtM,KAAK,EACrBG,aAAa,EACbC,kCACF,CAAC,EACD;gBACEiY,SAAS,EAAE,CAAC;kBAAEC,UAAU,EAAEpL,GAAG,CAAChB;gBAAE,CAAC,EAAE;kBAAEqM,UAAU,EAAErL,GAAG,CAACf;gBAAE,CAAC;cAC1D,CAAC,CACF;YAAE,GACCoI,YAAY,CAACiE,WAAW,EACxB,IAAAC,kCAAuB,EAACtQ,GAAG,CAAC;cAGhCI,uBAAuB,EAAEA,uBAAwB;cAAAvC,QAAA,EAEhD3C,aAAa,CAACqV,GAAG,CAAC,UAAC/B,OAAO,EAAE1E,KAAK,EAAK;gBACrC,IAAI3R,MAAM,GAAG,CAACuN,WAAW,IAAIoE,KAAK,KAAKvG,WAAW;gBAElD,IAAIvL,aAAa,IAAI,CAAC0N,WAAW,EAAE;kBACjCvN,MAAM,GAAG,KAAK;gBAChB,CAAC,MAAM,IACL,CAACH,aAAa,IACdC,kCAAkC,IAClC,CAACyN,WAAW,EACZ;kBACA,IAAM8K,gBAAgB,GAAGjV,uBAAuB,CAC9CtD,kCAAkC,EAClCiB,QACF,CAAC;kBACD,IACE4Q,KAAK,IAAIvG,WAAW,GAAGiN,gBAAgB,IACvC1G,KAAK,GAAGvG,WAAW,GAAGiN,gBAAgB,GAAGA,gBAAgB,EACzD;oBACArY,MAAM,GAAG,KAAK;kBAChB;gBACF;gBAEA,IAAMsY,aAAa,GAAGnT,cAAK,CAACoT,YAAY,CAAClC,OAAO,EAAE;kBAChDmC,YAAY,EAAE7G,KAAK;kBACnB3R,MAAM,EAANA,MAAM;kBACNH,aAAa,EAAbA,aAAa;kBACb4Y,YAAY,EAAE/W,eAAe,CAACX,QAAQ,CAAC;kBACvCjB,kCAAkC,EAAlCA,kCAAkC;kBAClCiB,QAAQ,EAARA,QAAQ;kBACRvC,eAAe,EAAE6X,OAAO,CAACqC,KAAK,CAACla;gBACjC,CAAC,CAAC;gBACF,OAAO,IAAAN,WAAA,CAAAuJ,GAAA,EAACtL,MAAA,CAAA2I,OAAK,CAAC6T,QAAQ;kBAAAjT,QAAA,EAAyB4S;gBAAa,GAAhC3G,KAAK,CAACiH,OAAO,CAAC,CAAC,CAAkC,CAAC;cAChF,CAAC;YAAC,EACW;UAAC,CACZ,CAAC,EACN9N,0BAA0B,IAAIb,UAAU,GAAG,CAAC,GAC3C,IAAA/L,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;YACH9Q,KAAK,EAAE/D,wCAAwC,CAC7CC,iCAAiC,EACjCC,8BAA8B,EAC9BC,0CAA0C,EAC1CC,YAAY,EACZC,WAAW,EACX,KAAK,EACL1C,aAAa,EACbC,kCAAkC,EAClCgB,iBAAiB,EACjBC,QAAQ,EACRC,QAAQ,EACRgL,eAAe,CAACtM,KAClB,CAAE;YACF+X,MAAM,EAAC,uBAAuB;YAAA/R,QAAA,EAE9B,IAAAxH,WAAA,CAAAuJ,GAAA,EAACjK,WAAA,CAAA8Z,UAAU;cACTN,QAAQ,EAAEtD,oCAAqC;cAC/C6D,IAAI,EAAE5M,QAAS;cACf6M,OAAO,EAAEpC,QAAS;cAClB3P,OAAO,EAAE8P,8BAA+B;cACxCxN,kBAAkB,EAAE2N,uBAAuB,CAAC,iBAAiB,CAAC,CAACG,OAAO,CACpE,eAAe,EACfzK,WAAW,GAAG,CAChB,CAAE;cACF5F,MAAM,EAAEnB,gBAAgB,CAACmG,WAAW;YAAE,CACvC;UAAC,CACE,CAAC,GACL,IAAI;QAAA,EACJ,CAAC,EACP,IAAAtM,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;UACH9Q,KAAK,EAAEtC,sBAAsB,CAACC,IAAI,EAAEL,UAAU,EAAExC,QAAQ,EAAElB,aAAa,EAAEmB,QAAQ,CAAE;UAAA0E,QAAA,EAElFqF,mBAAmB,GAAGiL,qBAAqB,GAAG;QAAI,CAC/C,CAAC;MAAA,CACS;IAAC,CACf,CAAC,EACNzS,UAAU,IACT,IAAArF,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;MAAC9Q,KAAK,EAAE7H,YAAY,CAACgB,iBAAkB;MAAAsG,QAAA,EAC1C,IAAAxH,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAuQ,QAAQ,CAACkK,IAAI,EAAAvU,MAAA,CAAAC,MAAA;QACZwD,KAAK,EAAE5H,uBAAU,CAACyZ,OAAO,CAAC,CACxB1Z,YAAY,CAACmB,aAAa,EAC1B;UACEwY,SAAS,EAAE,CAAC;YAAEC,UAAU,EAAE9K,OAAO,CAACtB;UAAE,CAAC,EAAE;YAAEqM,UAAU,EAAE/K,OAAO,CAACrB;UAAE,CAAC;QAClE,CAAC,CACF,CAAE;QACHmL,QAAQ,EAAEzD;MAAsB,GAC5B4B,gBAAgB,CAAC+C,WAAW,EAC5B,IAAAC,kCAAuB,EAACtQ,GAAG,CAAC;QAChCI,uBAAuB,EAAEA,uBAAwB;QAAAvC,QAAA,EAEhD3C,aAAa,CAACqV,GAAG,CAAC,UAAC/B,OAAO,EAAE1E,KAAK,EAAK;UACrC,IAAM3R,MAAM,GAAG,CAACuN,WAAW,IAAIoE,KAAK,KAAKvG,WAAW;UACpD,OACE,IAAAlN,WAAA,CAAAuJ,GAAA,EAACnL,YAAA,CAAAya,IAAI;YACH9Q,KAAK,EAAElG,yBAAyB,CAACsM,mBAAmB,CAAC3M,KAAK,EAAEM,MAAM,CAAE;YAAA0F,QAAA,EAGpE,IAAAxH,WAAA,CAAAuJ,GAAA,EAACzJ,IAAA,CAAA6a,GAAG;cAACC,IAAI,EAAE,CAAE;cAACrT,OAAO,EAAE;gBAAEsT,UAAU,EAAE1C,OAAO,CAACqC,KAAK,CAACla;cAAgB;YAAE,CAAE;UAAC,GAFnEmT,KAAK,CAACiH,OAAO,CAAC,CAAC,CAGhB,CAAC;QAEX,CAAC;MAAC,EACW;IAAC,CACZ,CACP;EAAA,CACG,CAAC;AAEX,CACF,CAAC;AAED3T,QAAQ,CAAC+T,SAAS,GAAAxW,MAAA,CAAAC,MAAA,KACbuC,uBAAuB;EAC1BQ,MAAM,EAAE,IAAAyT,yBAAiB,EAAC,UAAU,CAAC;EACrCxT,OAAO,EAAEyT,wBAAW,CAACC,QAAQ;EAI7BrT,kBAAkB,EAAEoT,wBAAW,CAACC,QAAQ;EAIxCnT,kBAAkB,EAAEkT,wBAAW,CAACC,QAAQ;EAIxCzT,QAAQ,EAAE0T,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACE,OAAO,CAACF,kBAAS,CAACG,IAAI,CAAC,EAAEH,kBAAS,CAACG,IAAI,CAAC,CAAC,CAACC,UAAU;EAO7F5T,SAAS,EAAEwT,kBAAS,CAACK,MAAM;EAM3BrX,8BAA8B,EAAEgX,kBAAS,CAACM,KAAK,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;EAI9EvT,oBAAoB,EAAEiT,kBAAS,CAACM,KAAK,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;EAIpExS,YAAY,EAAEkS,kBAAS,CAACO,MAAM;EAI9BvS,UAAU,EAAEgS,kBAAS,CAACE,OAAO,CAC3BF,kBAAS,CAACQ,KAAK,CAAC;IAEd7R,kBAAkB,EAAEqR,kBAAS,CAACK,MAAM;IAEpCI,GAAG,EAAET,kBAAS,CAACK,MAAM;IAErBK,OAAO,EAAEV,kBAAS,CAACW,IAAI;IAEvBC,GAAG,EAAEZ,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACK,MAAM,EAAEL,kBAAS,CAACa,MAAM,CAAC;EAC/D,CAAC,CACH,CAAC;EAKD1T,oBAAoB,EAAE6S,kBAAS,CAACa,MAAM;EAItC5T,oBAAoB,EAAE+S,kBAAS,CAACa,MAAM;EAiBtCvT,cAAc,EAAE0S,kBAAS,CAACc,IAAI;EAK9BvT,YAAY,EAAEyS,kBAAS,CAACK,MAAM;EAM9B7V,IAAI,EAAEwV,kBAAS,CAACE,OAAO,CAACF,kBAAS,CAACQ,KAAK,CAACO,4CAAqB,CAACnB,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC;EAQ/EnS,OAAO,EAAEuS,kBAAS,CAACW,IAAI;EAevBvS,eAAe,EAAE4R,kBAAS,CAAC/C,OAAO;EAiBlC7P,gBAAgB,EAAE4S,kBAAS,CAACc,IAAI;EAiBhCzT,cAAc,EAAE2S,kBAAS,CAACc,IAAI;EAI9BE,6BAA6B,EAAEhB,kBAAS,CAACQ,KAAK,CAAC;IAC7CS,EAAE,EAAEjB,kBAAS,CAACQ,KAAK,CAAC;MAAEU,gBAAgB,EAAElB,kBAAS,CAACK,MAAM,CAACD;IAAW,CAAC,CAAC;IACtEe,EAAE,EAAEnB,kBAAS,CAACQ,KAAK,CAAC;MAAEU,gBAAgB,EAAElB,kBAAS,CAACK,MAAM,CAACD;IAAW,CAAC;EACvE,CAAC,CAAC;EAIF1R,iBAAiB,EAAEsR,kBAAS,CAACK,MAAM;EAInC1R,kBAAkB,EAAEqR,kBAAS,CAACK,MAAM;EAQpC5R,GAAG,EAAEuR,kBAAS,CAACM,KAAK,CAACc,qBAAU,CAAC;EAOhC9R,QAAQ,EAAE0Q,kBAAS,CAACW,IAAI;EAMxB3R,aAAa,EAAEgR,kBAAS,CAACa,MAAM;EAM/B3R,kBAAkB,EAAE8Q,kBAAS,CAACa,MAAM;EAMpCzR,YAAY,EAAE4Q,kBAAS,CAACa,MAAM;EAK9Bpa,aAAa,EAAEuZ,kBAAS,CAACW,IAAI;EAK7Bja,kCAAkC,EAAEsZ,kBAAS,CAACW,IAAI;EAWlDnR,eAAe,EAAEwQ,kBAAS,CAACQ,KAAK,CAAC;IAC/Ba,EAAE,EAAErB,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACM,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EAAEN,kBAAS,CAACa,MAAM,CAAC,CAAC;IAC7ES,EAAE,EAAEtB,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACM,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EAAEN,kBAAS,CAACa,MAAM,CAAC,CAAC;IAC7EU,EAAE,EAAEvB,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACM,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EAAEN,kBAAS,CAACa,MAAM,CAAC,CAAC;IAC7EW,EAAE,EAAExB,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACM,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EAAEN,kBAAS,CAACa,MAAM,CAAC,CAAC;IAC7EY,EAAE,EAAEzB,kBAAS,CAACC,SAAS,CAAC,CAACD,kBAAS,CAACM,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EAAEN,kBAAS,CAACa,MAAM,CAAC;EAC9E,CAAC,CAAC;EAUFnR,iBAAiB,EAAEsQ,kBAAS,CAACM,KAAK,CAAC,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;EAM3DxQ,oBAAoB,EAAEkQ,kBAAS,CAACa;AAAM,EACvC;AAEDhV,QAAQ,CAAC6V,WAAW,GAAG,UAAU","ignoreList":[]}