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

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/bc/Scroll_bcff81cf140cf0493527561ec0160395

@@ -0,0 +1,435 @@
+1e2e79b2ee37988843eaa8280eea3b60
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Scroll = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactNative = require("react-native");
+var _useThemeTokens = require("../ThemeProvider/useThemeTokens");
+var _a11yProps = require("../utils/props/a11yProps");
+var _copyPropTypes = require("../utils/props/copyPropTypes");
+var _tokens = require("../utils/props/tokens");
+var _selectSystemProps3 = require("../utils/props/selectSystemProps");
+var _useCopy = require("../utils/useCopy");
+var _useUniqueId = require("../utils/useUniqueId");
+var _variantProp = require("../utils/props/variantProp");
+var _viewProps = require("../utils/props/viewProps");
+var _A11yText = require("../A11yText/A11yText");
+var _ScrollViewEnd = require("../HorizontalScroll/ScrollViewEnd");
+var _dictionary = require("./dictionary");
+var _ScrollProgress = require("./ScrollProgress");
+var _ScrollContext = require("./ScrollContext");
+var _jsxRuntime = require("react/jsx-runtime");
+var _excluded = ["children", "tokens", "variant", "copy", "dictionary", "accessibilityLabel"];
+var _selectSystemProps = (0, _selectSystemProps3.selectSystemProps)([_a11yProps.a11yProps, _viewProps.viewProps]),
+  _selectSystemProps2 = (0, _slicedToArray2.default)(_selectSystemProps, 2),
+  selectProps = _selectSystemProps2[0],
+  selectedSystemPropTypes = _selectSystemProps2[1];
+var SCROLL_DESCRIPTION_PREFIX = 'scroll-description';
+var KEY_ARROW_RIGHT = 'ArrowRight';
+var KEY_ARROW_LEFT = 'ArrowLeft';
+var KEY_SPACE = ' ';
+var MAX_PERCENTAGE = 100;
+var MIN_BAR_PERCENTAGE = 1;
+var ROLE_REGION = 'region';
+var ROLE_NONE = 'none';
+var COMPONENT_NAME = 'Scroll';
+var SCROLL_ITEM_SELECTOR = '[data-scroll-item]';
+var TAB_INDEX = 0;
+var INITIAL_DIMENSION = 0;
+var HALF_DIVISOR = 2;
+var selectPressableStyles = function selectPressableStyles(_ref) {
+  var progressHitAreaHeight = _ref.progressHitAreaHeight,
+    progressSpacing = _ref.progressSpacing;
+  return {
+    height: progressHitAreaHeight,
+    marginTop: progressSpacing
+  };
+};
+var selectThumbWrapperStyles = function selectThumbWrapperStyles(_ref2) {
+  var thumbWidthPercent = _ref2.thumbWidthPercent,
+    thumbPositionPercent = _ref2.thumbPositionPercent;
+  return {
+    width: `${thumbWidthPercent}%`,
+    marginLeft: `${thumbPositionPercent}%`
+  };
+};
+var selectContainerA11yProps = function selectContainerA11yProps(_ref3) {
+  var accessibilityLabel = _ref3.accessibilityLabel,
+    descriptionId = _ref3.descriptionId,
+    handleKeyDown = _ref3.handleKeyDown;
+  return _reactNative.Platform.OS === 'web' ? {
+    role: ROLE_REGION,
+    'aria-label': accessibilityLabel,
+    'aria-describedby': descriptionId,
+    tabIndex: TAB_INDEX,
+    onKeyDown: handleKeyDown
+  } : {
+    accessibilityRole: ROLE_NONE,
+    accessibilityLabel: accessibilityLabel
+  };
+};
+var selectScrollContentStyle = function selectScrollContentStyle(itemGap) {
+  return {
+    columnGap: itemGap
+  };
+};
+var calculateThumbWidth = function calculateThumbWidth(_ref4) {
+  var containerWidth = _ref4.containerWidth,
+    contentWidth = _ref4.contentWidth;
+  if (contentWidth <= INITIAL_DIMENSION) return MAX_PERCENTAGE;
+  return Math.max(MIN_BAR_PERCENTAGE, Math.min(MAX_PERCENTAGE, containerWidth / contentWidth * MAX_PERCENTAGE));
+};
+var calculateThumbPosition = function calculateThumbPosition(_ref5) {
+  var scrollOffset = _ref5.scrollOffset,
+    scrollMax = _ref5.scrollMax,
+    thumbWidthPercent = _ref5.thumbWidthPercent;
+  if (scrollMax <= INITIAL_DIMENSION) return INITIAL_DIMENSION;
+  return scrollOffset / scrollMax * (MAX_PERCENTAGE - thumbWidthPercent);
+};
+var getScrollableNode = function getScrollableNode(ref) {
+  var _ref$current$getScrol, _ref$current;
+  return (_ref$current$getScrol = (_ref$current = ref.current) == null || _ref$current.getScrollableNode == null ? void 0 : _ref$current.getScrollableNode()) != null ? _ref$current$getScrol : null;
+};
+var Scroll = exports.Scroll = _react.default.forwardRef(function (_ref6, ref) {
+  var children = _ref6.children,
+    tokens = _ref6.tokens,
+    variant = _ref6.variant,
+    copy = _ref6.copy,
+    _ref6$dictionary = _ref6.dictionary,
+    customDictionary = _ref6$dictionary === void 0 ? _dictionary.dictionary : _ref6$dictionary,
+    accessibilityLabel = _ref6.accessibilityLabel,
+    rest = (0, _objectWithoutProperties2.default)(_ref6, _excluded);
+  var getCopy = (0, _useCopy.useCopy)({
+    dictionary: customDictionary,
+    copy: copy
+  });
+  var resolvedAccessibilityLabel = accessibilityLabel || getCopy('accessibilityLabel');
+  var getTokens = (0, _useThemeTokens.useThemeTokensCallback)(COMPONENT_NAME, tokens, variant);
+  var defaultTokens = _react.default.useMemo(function () {
+    return getTokens();
+  }, [getTokens]);
+  var descriptionId = (0, _useUniqueId.useUniqueId)(SCROLL_DESCRIPTION_PREFIX);
+  var scrollRef = _react.default.useRef(null);
+  var pressableRef = _react.default.useRef(null);
+  var scrollContainerRef = _react.default.useRef(null);
+  var scrollMaxRef = _react.default.useRef(INITIAL_DIMENSION);
+  var scrollOffsetRef = _react.default.useRef(INITIAL_DIMENSION);
+  var thumbWidthPercentRef = _react.default.useRef(MAX_PERCENTAGE);
+  var thumbRef = _react.default.useRef(null);
+  var isDraggingRef = _react.default.useRef(false);
+  var dragStartRef = _react.default.useRef({
+    mouseX: INITIAL_DIMENSION,
+    scrollOffset: INITIAL_DIMENSION
+  });
+  var _React$useState = _react.default.useState(INITIAL_DIMENSION),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    scrollOffset = _React$useState2[0],
+    setScrollOffset = _React$useState2[1];
+  var _React$useState3 = _react.default.useState(INITIAL_DIMENSION),
+    _React$useState4 = (0, _slicedToArray2.default)(_React$useState3, 2),
+    containerWidth = _React$useState4[0],
+    setContainerWidth = _React$useState4[1];
+  var _React$useState5 = _react.default.useState(INITIAL_DIMENSION),
+    _React$useState6 = (0, _slicedToArray2.default)(_React$useState5, 2),
+    contentWidth = _React$useState6[0],
+    setContentWidth = _React$useState6[1];
+  var _React$useState7 = _react.default.useState(INITIAL_DIMENSION),
+    _React$useState8 = (0, _slicedToArray2.default)(_React$useState7, 2),
+    itemWidth = _React$useState8[0],
+    setItemWidth = _React$useState8[1];
+  var _React$useState9 = _react.default.useState(INITIAL_DIMENSION),
+    _React$useState0 = (0, _slicedToArray2.default)(_React$useState9, 2),
+    itemHeight = _React$useState0[0],
+    setItemHeight = _React$useState0[1];
+  var itemGap = defaultTokens.itemGap;
+  var scrollMax = Math.max(INITIAL_DIMENSION, contentWidth - containerWidth);
+  _react.default.useEffect(function () {
+    scrollMaxRef.current = scrollMax;
+  }, [scrollMax]);
+  var thumbWidthPercent = calculateThumbWidth({
+    containerWidth: containerWidth,
+    contentWidth: contentWidth
+  });
+  thumbWidthPercentRef.current = thumbWidthPercent;
+  var thumbPositionPercent = calculateThumbPosition({
+    scrollOffset: scrollOffset,
+    scrollMax: scrollMax,
+    thumbWidthPercent: thumbWidthPercent
+  });
+  var thumbWrapperStyle = _react.default.useMemo(function () {
+    return [staticStyles.thumbWrapper, selectThumbWrapperStyles({
+      thumbWidthPercent: thumbWidthPercent,
+      thumbPositionPercent: thumbPositionPercent
+    }), _reactNative.Platform.OS === 'web' ? staticStyles.thumbCursor : null];
+  }, [thumbWidthPercent, thumbPositionPercent]);
+  var handleScroll = _react.default.useCallback(function (_ref7) {
+    var x = _ref7.nativeEvent.contentOffset.x;
+    scrollOffsetRef.current = x;
+    setScrollOffset(x);
+  }, []);
+  var handleContainerLayout = _react.default.useCallback(function (_ref8) {
+    var width = _ref8.nativeEvent.layout.width;
+    setContainerWidth(width);
+  }, []);
+  var handleContentWidth = _react.default.useCallback(function (width) {
+    setContentWidth(width);
+  }, []);
+  var handleItemLayout = _react.default.useCallback(function (width, height) {
+    setItemWidth(function (prev) {
+      return Math.max(prev, width);
+    });
+    setItemHeight(function (prev) {
+      return Math.max(prev, height);
+    });
+  }, []);
+  _react.default.useEffect(function () {
+    if (_reactNative.Platform.OS !== 'web') return undefined;
+    var element = scrollContainerRef.current;
+    if (!element) return undefined;
+    var handleWheel = function handleWheel(event) {
+      event.preventDefault();
+      event.stopPropagation();
+      var isHorizontal = Math.abs(event.deltaX) > Math.abs(event.deltaY);
+      var delta = isHorizontal ? event.deltaX : event.deltaY;
+      var scrollableNode = getScrollableNode(scrollRef);
+      if (scrollableNode) {
+        var maxScroll = scrollMaxRef.current;
+        var newScrollLeft = Math.max(INITIAL_DIMENSION, Math.min(maxScroll, scrollableNode.scrollLeft + delta));
+        scrollableNode.scrollLeft = newScrollLeft;
+        scrollOffsetRef.current = newScrollLeft;
+        setScrollOffset(newScrollLeft);
+      }
+    };
+    element.addEventListener('wheel', handleWheel, {
+      passive: false
+    });
+    return function () {
+      return element.removeEventListener('wheel', handleWheel);
+    };
+  }, []);
+  _react.default.useEffect(function () {
+    if (_reactNative.Platform.OS !== 'web') return undefined;
+    var element = scrollContainerRef.current;
+    if (!element) return undefined;
+    var handleFocusIn = function handleFocusIn(event) {
+      var scrollableNode = getScrollableNode(scrollRef);
+      if (!scrollableNode) return;
+      var focusedItem = event.target.closest(SCROLL_ITEM_SELECTOR);
+      if (!focusedItem) return;
+      var itemLeft = focusedItem.offsetLeft;
+      var itemRight = itemLeft + focusedItem.offsetWidth;
+      var visibleLeft = scrollableNode.scrollLeft;
+      var currentContainerWidth = containerWidth;
+      var visibleRight = visibleLeft + currentContainerWidth;
+      if (itemRight > visibleRight) {
+        scrollRef.current.scrollTo({
+          x: itemRight - currentContainerWidth,
+          animated: true
+        });
+      } else if (itemLeft < visibleLeft) {
+        scrollRef.current.scrollTo({
+          x: itemLeft,
+          animated: true
+        });
+      }
+    };
+    element.addEventListener('focusin', handleFocusIn);
+    return function () {
+      return element.removeEventListener('focusin', handleFocusIn);
+    };
+  }, [containerWidth]);
+  var hasScrollbar = scrollMax > INITIAL_DIMENSION;
+  _react.default.useEffect(function () {
+    if (_reactNative.Platform.OS !== 'web' || !hasScrollbar) return undefined;
+    var thumbElement = thumbRef.current;
+    if (!thumbElement) return undefined;
+    var handleMouseDown = function handleMouseDown(event) {
+      var _getScrollableNode$sc, _getScrollableNode;
+      event.preventDefault();
+      event.stopPropagation();
+      isDraggingRef.current = true;
+      dragStartRef.current = {
+        mouseX: event.clientX,
+        scrollOffset: (_getScrollableNode$sc = (_getScrollableNode = getScrollableNode(scrollRef)) == null ? void 0 : _getScrollableNode.scrollLeft) != null ? _getScrollableNode$sc : INITIAL_DIMENSION
+      };
+      thumbElement.style.cursor = 'grabbing';
+      document.body.style.cursor = 'grabbing';
+      document.body.style.userSelect = 'none';
+    };
+    var handleMouseMove = function handleMouseMove(event) {
+      if (!isDraggingRef.current) return;
+      var trackElement = pressableRef.current;
+      if (!trackElement) return;
+      var trackWidth = trackElement.offsetWidth;
+      var thumbPixelWidth = thumbWidthPercentRef.current / MAX_PERCENTAGE * trackWidth;
+      var availableTrackPixels = trackWidth - thumbPixelWidth;
+      if (availableTrackPixels <= INITIAL_DIMENSION) return;
+      var mouseDelta = event.clientX - dragStartRef.current.mouseX;
+      var scrollDelta = mouseDelta / availableTrackPixels * scrollMaxRef.current;
+      var targetScroll = Math.max(INITIAL_DIMENSION, Math.min(scrollMaxRef.current, dragStartRef.current.scrollOffset + scrollDelta));
+      var scrollableNode = getScrollableNode(scrollRef);
+      if (scrollableNode) {
+        scrollableNode.scrollLeft = targetScroll;
+        scrollOffsetRef.current = targetScroll;
+        setScrollOffset(targetScroll);
+      }
+    };
+    var handleMouseUp = function handleMouseUp() {
+      if (!isDraggingRef.current) return;
+      isDraggingRef.current = false;
+      thumbElement.style.cursor = '';
+      document.body.style.cursor = '';
+      document.body.style.userSelect = '';
+    };
+    thumbElement.addEventListener('mousedown', handleMouseDown);
+    document.addEventListener('mousemove', handleMouseMove);
+    document.addEventListener('mouseup', handleMouseUp);
+    return function () {
+      thumbElement.removeEventListener('mousedown', handleMouseDown);
+      document.removeEventListener('mousemove', handleMouseMove);
+      document.removeEventListener('mouseup', handleMouseUp);
+    };
+  }, [hasScrollbar]);
+  var handleKeyDown = _react.default.useCallback(function (event) {
+    if (event.key === KEY_ARROW_RIGHT || event.key === KEY_SPACE) {
+      event.preventDefault();
+      if (scrollRef.current) {
+        scrollRef.current.scrollTo({
+          x: scrollOffsetRef.current + itemWidth,
+          animated: true
+        });
+      }
+    } else if (event.key === KEY_ARROW_LEFT) {
+      event.preventDefault();
+      if (scrollRef.current) {
+        scrollRef.current.scrollTo({
+          x: Math.max(INITIAL_DIMENSION, scrollOffsetRef.current - itemWidth),
+          animated: true
+        });
+      }
+    }
+  }, [itemWidth]);
+  var handleProgressPress = _react.default.useCallback(function (event) {
+    if (scrollMax <= INITIAL_DIMENSION || isDraggingRef.current) return;
+    if (_reactNative.Platform.OS === 'web' && pressableRef.current) {
+      var offsetX = event.nativeEvent.offsetX;
+      var offsetWidth = pressableRef.current.offsetWidth;
+      var thumbPixelWidth = thumbWidthPercent / MAX_PERCENTAGE * offsetWidth;
+      var availableTrack = offsetWidth - thumbPixelWidth;
+      if (availableTrack <= INITIAL_DIMENSION) return;
+      var clickPosition = Math.max(INITIAL_DIMENSION, Math.min(availableTrack, offsetX - thumbPixelWidth / HALF_DIVISOR));
+      var targetX = clickPosition / availableTrack * scrollMax;
+      if (scrollRef.current) {
+        scrollRef.current.scrollTo({
+          x: targetX,
+          animated: true
+        });
+      }
+    } else if (pressableRef.current) {
+      var locationX = event.nativeEvent.locationX;
+      pressableRef.current.measure(function (_x, _y, width) {
+        var thumbPixelWidth = thumbWidthPercent / MAX_PERCENTAGE * width;
+        var availableTrack = width - thumbPixelWidth;
+        if (availableTrack <= INITIAL_DIMENSION) return;
+        var clickPosition = Math.max(INITIAL_DIMENSION, Math.min(availableTrack, locationX - thumbPixelWidth / HALF_DIVISOR));
+        var targetX = clickPosition / availableTrack * scrollMax;
+        if (scrollRef.current) {
+          scrollRef.current.scrollTo({
+            x: targetX,
+            animated: true
+          });
+        }
+      });
+    }
+  }, [scrollMax, thumbWidthPercent]);
+  var handleContainerRef = _react.default.useCallback(function (node) {
+    scrollContainerRef.current = node;
+    if (typeof ref === 'function') ref(node);else if (ref) Object.assign(ref, {
+      current: node
+    });
+  }, [ref]);
+  return (0, _jsxRuntime.jsxs)(_reactNative.View, Object.assign({
+    ref: handleContainerRef,
+    style: staticStyles.container
+  }, selectContainerA11yProps({
+    accessibilityLabel: resolvedAccessibilityLabel,
+    descriptionId: descriptionId,
+    handleKeyDown: handleKeyDown
+  }), selectProps(rest), {
+    children: [(0, _jsxRuntime.jsx)(_A11yText.A11yText, {
+      text: getCopy('instructionText'),
+      nativeID: descriptionId
+    }), (0, _jsxRuntime.jsx)(_reactNative.View, {
+      style: staticStyles.scrollContainer,
+      children: (0, _jsxRuntime.jsx)(_ScrollViewEnd.ScrollViewEnd, {
+        ref: scrollRef,
+        horizontal: true,
+        onScrollEnd: handleScroll,
+        onScroll: handleScroll,
+        onContentSizeChange: handleContentWidth,
+        onLayout: handleContainerLayout,
+        showsHorizontalScrollIndicator: false,
+        contentContainerStyle: [staticStyles.scrollContent, selectScrollContentStyle(itemGap)],
+        children: (0, _jsxRuntime.jsx)(_ScrollContext.ScrollProvider, {
+          itemWidth: itemWidth,
+          itemHeight: itemHeight,
+          onItemLayout: handleItemLayout,
+          children: children
+        })
+      })
+    }), scrollMax > INITIAL_DIMENSION && (0, _jsxRuntime.jsx)(_reactNative.Pressable, {
+      ref: pressableRef,
+      style: [staticStyles.pressable, selectPressableStyles(defaultTokens)],
+      onPress: handleProgressPress,
+      children: function children(pressableState) {
+        return (0, _jsxRuntime.jsx)(_ScrollProgress.ScrollProgress, {
+          ref: thumbRef,
+          pressableState: pressableState,
+          getTokens: getTokens,
+          thumbWrapperStyle: thumbWrapperStyle,
+          getCopy: getCopy
+        });
+      }
+    })]
+  }));
+});
+Scroll.displayName = 'Scroll';
+Scroll.propTypes = Object.assign({}, selectedSystemPropTypes, {
+  children: _propTypes.default.node.isRequired,
+  tokens: (0, _tokens.getTokensPropType)('Scroll'),
+  variant: _variantProp.variantProp.propType,
+  copy: _copyPropTypes.copyPropTypes,
+  dictionary: _propTypes.default.shape({
+    en: _propTypes.default.object,
+    fr: _propTypes.default.object
+  }),
+  accessibilityLabel: _propTypes.default.string
+});
+var staticStyles = _reactNative.StyleSheet.create({
+  container: {
+    width: '100%'
+  },
+  scrollContainer: {
+    width: '100%'
+  },
+  pressable: {
+    justifyContent: 'center',
+    width: '100%'
+  },
+  scrollContent: {
+    alignSelf: 'flex-start',
+    flexGrow: 1
+  },
+  thumbWrapper: {
+    height: '100%'
+  },
+  thumbCursor: {
+    cursor: 'grab'
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_propTypes","_reactNative","_useThemeTokens","_a11yProps","_copyPropTypes","_tokens","_selectSystemProps3","_useCopy","_useUniqueId","_variantProp","_viewProps","_A11yText","_ScrollViewEnd","_dictionary","_ScrollProgress","_ScrollContext","_jsxRuntime","_excluded","_selectSystemProps","selectSystemProps","a11yProps","viewProps","_selectSystemProps2","_slicedToArray2","default","selectProps","selectedSystemPropTypes","SCROLL_DESCRIPTION_PREFIX","KEY_ARROW_RIGHT","KEY_ARROW_LEFT","KEY_SPACE","MAX_PERCENTAGE","MIN_BAR_PERCENTAGE","ROLE_REGION","ROLE_NONE","COMPONENT_NAME","SCROLL_ITEM_SELECTOR","TAB_INDEX","INITIAL_DIMENSION","HALF_DIVISOR","selectPressableStyles","_ref","progressHitAreaHeight","progressSpacing","height","marginTop","selectThumbWrapperStyles","_ref2","thumbWidthPercent","thumbPositionPercent","width","marginLeft","selectContainerA11yProps","_ref3","accessibilityLabel","descriptionId","handleKeyDown","Platform","OS","role","tabIndex","onKeyDown","accessibilityRole","selectScrollContentStyle","itemGap","columnGap","calculateThumbWidth","_ref4","containerWidth","contentWidth","Math","max","min","calculateThumbPosition","_ref5","scrollOffset","scrollMax","getScrollableNode","ref","_ref$current$getScrol","_ref$current","current","Scroll","exports","React","forwardRef","_ref6","children","tokens","variant","copy","_ref6$dictionary","dictionary","customDictionary","rest","_objectWithoutProperties2","getCopy","useCopy","resolvedAccessibilityLabel","getTokens","useThemeTokensCallback","defaultTokens","useMemo","useUniqueId","scrollRef","useRef","pressableRef","scrollContainerRef","scrollMaxRef","scrollOffsetRef","thumbWidthPercentRef","thumbRef","isDraggingRef","dragStartRef","mouseX","_React$useState","useState","_React$useState2","setScrollOffset","_React$useState3","_React$useState4","setContainerWidth","_React$useState5","_React$useState6","setContentWidth","_React$useState7","_React$useState8","itemWidth","setItemWidth","_React$useState9","_React$useState0","itemHeight","setItemHeight","useEffect","thumbWrapperStyle","staticStyles","thumbWrapper","thumbCursor","handleScroll","useCallback","_ref7","x","nativeEvent","contentOffset","handleContainerLayout","_ref8","layout","handleContentWidth","handleItemLayout","prev","undefined","element","handleWheel","event","preventDefault","stopPropagation","isHorizontal","abs","deltaX","deltaY","delta","scrollableNode","maxScroll","newScrollLeft","scrollLeft","addEventListener","passive","removeEventListener","handleFocusIn","focusedItem","target","closest","itemLeft","offsetLeft","itemRight","offsetWidth","visibleLeft","currentContainerWidth","visibleRight","scrollTo","animated","hasScrollbar","thumbElement","handleMouseDown","_getScrollableNode$sc","_getScrollableNode","clientX","style","cursor","document","body","userSelect","handleMouseMove","trackElement","trackWidth","thumbPixelWidth","availableTrackPixels","mouseDelta","scrollDelta","targetScroll","handleMouseUp","key","handleProgressPress","offsetX","availableTrack","clickPosition","targetX","locationX","measure","_x","_y","handleContainerRef","node","Object","assign","jsxs","View","container","jsx","A11yText","text","nativeID","scrollContainer","ScrollViewEnd","horizontal","onScrollEnd","onScroll","onContentSizeChange","onLayout","showsHorizontalScrollIndicator","contentContainerStyle","scrollContent","ScrollProvider","onItemLayout","Pressable","pressable","onPress","pressableState","ScrollProgress","displayName","propTypes","PropTypes","isRequired","getTokensPropType","variantProp","propType","copyPropTypes","shape","en","object","fr","string","StyleSheet","create","justifyContent","alignSelf","flexGrow"],"sources":["Scroll.jsx"],"sourcesContent":["import React from 'react'\nimport PropTypes from 'prop-types'\nimport { Platform, Pressable, StyleSheet, View } from 'react-native'\nimport { useThemeTokensCallback } from '../ThemeProvider/useThemeTokens'\nimport { a11yProps } from '../utils/props/a11yProps'\nimport { copyPropTypes } from '../utils/props/copyPropTypes'\nimport { getTokensPropType } from '../utils/props/tokens'\nimport { selectSystemProps } from '../utils/props/selectSystemProps'\nimport { useCopy } from '../utils/useCopy'\nimport { useUniqueId } from '../utils/useUniqueId'\nimport { variantProp } from '../utils/props/variantProp'\nimport { viewProps } from '../utils/props/viewProps'\nimport { A11yText } from '../A11yText/A11yText'\nimport { ScrollViewEnd } from '../HorizontalScroll/ScrollViewEnd'\nimport { dictionary } from './dictionary'\nimport { ScrollProgress } from './ScrollProgress'\nimport { ScrollProvider } from './ScrollContext'\n\nconst [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps])\n\nconst SCROLL_DESCRIPTION_PREFIX = 'scroll-description'\nconst KEY_ARROW_RIGHT = 'ArrowRight'\nconst KEY_ARROW_LEFT = 'ArrowLeft'\nconst KEY_SPACE = ' '\nconst MAX_PERCENTAGE = 100\nconst MIN_BAR_PERCENTAGE = 1\nconst ROLE_REGION = 'region'\nconst ROLE_NONE = 'none'\nconst COMPONENT_NAME = 'Scroll'\nconst SCROLL_ITEM_SELECTOR = '[data-scroll-item]'\nconst TAB_INDEX = 0\nconst INITIAL_DIMENSION = 0\nconst HALF_DIVISOR = 2\n\nconst selectPressableStyles = ({ progressHitAreaHeight, progressSpacing }) => ({\n  height: progressHitAreaHeight,\n  marginTop: progressSpacing\n})\n\nconst selectThumbWrapperStyles = ({ thumbWidthPercent, thumbPositionPercent }) => ({\n  width: `${thumbWidthPercent}%`,\n  marginLeft: `${thumbPositionPercent}%`\n})\n\nconst selectContainerA11yProps = ({ accessibilityLabel, descriptionId, handleKeyDown }) =>\n  Platform.OS === 'web'\n    ? {\n        role: ROLE_REGION,\n        'aria-label': accessibilityLabel,\n        'aria-describedby': descriptionId,\n        tabIndex: TAB_INDEX,\n        onKeyDown: handleKeyDown\n      }\n    : {\n        accessibilityRole: ROLE_NONE,\n        accessibilityLabel\n      }\n\nconst selectScrollContentStyle = (itemGap) => ({\n  columnGap: itemGap\n})\n\nconst calculateThumbWidth = ({ containerWidth, contentWidth }) => {\n  if (contentWidth <= INITIAL_DIMENSION) return MAX_PERCENTAGE\n  return Math.max(\n    MIN_BAR_PERCENTAGE,\n    Math.min(MAX_PERCENTAGE, (containerWidth / contentWidth) * MAX_PERCENTAGE)\n  )\n}\n\nconst calculateThumbPosition = ({ scrollOffset, scrollMax, thumbWidthPercent }) => {\n  if (scrollMax <= INITIAL_DIMENSION) return INITIAL_DIMENSION\n  return (scrollOffset / scrollMax) * (MAX_PERCENTAGE - thumbWidthPercent)\n}\n\nconst getScrollableNode = (ref) => ref.current?.getScrollableNode?.() ?? null\n\n/**\n * The `Scroll` component provides a continuous horizontal scrollable container with a progress\n * bar indicator. Items are displayed in a flow layout where all items share the width of the\n * widest item and the height of the tallest item.\n *\n * ## Props\n *\n * - Use `children` to pass `ScrollItem` components\n * - Use `accessibilityLabel` to provide a meaningful label for the scrollable region\n * - Use `copy` to select English or French for accessible labels\n * - Use `dictionary` to override the default translations\n *\n * ## Usability and A11y guidelines\n *\n * - The scroll container is keyboard-focusable with `tabIndex=\"0\"`\n * - Each `ScrollItem` is individually focusable via Tab navigation\n * - Use left and right arrow keys to scroll by one item width\n * - Press Space bar to scroll right\n * - When tabbing through items, the scroll follows focus to keep the active item visible\n * - Screen readers announce the component as a region with a descriptive label\n * - Touch and swipe gestures are supported on mobile and mobile web\n *\n */\nexport const Scroll = React.forwardRef(\n  (\n    {\n      children,\n      tokens,\n      variant,\n      copy,\n      dictionary: customDictionary = dictionary,\n      accessibilityLabel,\n      ...rest\n    },\n    ref\n  ) => {\n    const getCopy = useCopy({ dictionary: customDictionary, copy })\n    const resolvedAccessibilityLabel = accessibilityLabel || getCopy('accessibilityLabel')\n    const getTokens = useThemeTokensCallback(COMPONENT_NAME, tokens, variant)\n    const defaultTokens = React.useMemo(() => getTokens(), [getTokens])\n    const descriptionId = useUniqueId(SCROLL_DESCRIPTION_PREFIX)\n    const scrollRef = React.useRef(null)\n    const pressableRef = React.useRef(null)\n    const scrollContainerRef = React.useRef(null)\n    const scrollMaxRef = React.useRef(INITIAL_DIMENSION)\n    const scrollOffsetRef = React.useRef(INITIAL_DIMENSION)\n    const thumbWidthPercentRef = React.useRef(MAX_PERCENTAGE)\n    const thumbRef = React.useRef(null)\n    const isDraggingRef = React.useRef(false)\n    const dragStartRef = React.useRef({\n      mouseX: INITIAL_DIMENSION,\n      scrollOffset: INITIAL_DIMENSION\n    })\n\n    const [scrollOffset, setScrollOffset] = React.useState(INITIAL_DIMENSION)\n    const [containerWidth, setContainerWidth] = React.useState(INITIAL_DIMENSION)\n    const [contentWidth, setContentWidth] = React.useState(INITIAL_DIMENSION)\n    const [itemWidth, setItemWidth] = React.useState(INITIAL_DIMENSION)\n    const [itemHeight, setItemHeight] = React.useState(INITIAL_DIMENSION)\n\n    const { itemGap } = defaultTokens\n    const scrollMax = Math.max(INITIAL_DIMENSION, contentWidth - containerWidth)\n\n    React.useEffect(() => {\n      scrollMaxRef.current = scrollMax\n    }, [scrollMax])\n\n    const thumbWidthPercent = calculateThumbWidth({ containerWidth, contentWidth })\n    thumbWidthPercentRef.current = thumbWidthPercent\n    const thumbPositionPercent = calculateThumbPosition({\n      scrollOffset,\n      scrollMax,\n      thumbWidthPercent\n    })\n\n    const thumbWrapperStyle = React.useMemo(\n      () => [\n        staticStyles.thumbWrapper,\n        selectThumbWrapperStyles({ thumbWidthPercent, thumbPositionPercent }),\n        Platform.OS === 'web' ? staticStyles.thumbCursor : null\n      ],\n      [thumbWidthPercent, thumbPositionPercent]\n    )\n\n    const handleScroll = React.useCallback(\n      ({\n        nativeEvent: {\n          contentOffset: { x }\n        }\n      }) => {\n        scrollOffsetRef.current = x\n        setScrollOffset(x)\n      },\n      []\n    )\n\n    const handleContainerLayout = React.useCallback(\n      ({\n        nativeEvent: {\n          layout: { width }\n        }\n      }) => {\n        setContainerWidth(width)\n      },\n      []\n    )\n\n    const handleContentWidth = React.useCallback((width) => {\n      setContentWidth(width)\n    }, [])\n\n    const handleItemLayout = React.useCallback((width, height) => {\n      setItemWidth((prev) => Math.max(prev, width))\n      setItemHeight((prev) => Math.max(prev, height))\n    }, [])\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web') return undefined\n      const element = scrollContainerRef.current\n      if (!element) return undefined\n      const handleWheel = (event) => {\n        event.preventDefault()\n        event.stopPropagation()\n        const isHorizontal = Math.abs(event.deltaX) > Math.abs(event.deltaY)\n        const delta = isHorizontal ? event.deltaX : event.deltaY\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (scrollableNode) {\n          const maxScroll = scrollMaxRef.current\n          const newScrollLeft = Math.max(\n            INITIAL_DIMENSION,\n            Math.min(maxScroll, scrollableNode.scrollLeft + delta)\n          )\n          scrollableNode.scrollLeft = newScrollLeft\n          scrollOffsetRef.current = newScrollLeft\n          setScrollOffset(newScrollLeft)\n        }\n      }\n      element.addEventListener('wheel', handleWheel, { passive: false })\n      return () => element.removeEventListener('wheel', handleWheel)\n    }, [])\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web') return undefined\n      const element = scrollContainerRef.current\n      if (!element) return undefined\n\n      const handleFocusIn = (event) => {\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (!scrollableNode) return\n        const focusedItem = event.target.closest(SCROLL_ITEM_SELECTOR)\n        if (!focusedItem) return\n        const itemLeft = focusedItem.offsetLeft\n        const itemRight = itemLeft + focusedItem.offsetWidth\n        const visibleLeft = scrollableNode.scrollLeft\n        const currentContainerWidth = containerWidth\n        const visibleRight = visibleLeft + currentContainerWidth\n        if (itemRight > visibleRight) {\n          scrollRef.current.scrollTo({ x: itemRight - currentContainerWidth, animated: true })\n        } else if (itemLeft < visibleLeft) {\n          scrollRef.current.scrollTo({ x: itemLeft, animated: true })\n        }\n      }\n\n      element.addEventListener('focusin', handleFocusIn)\n      return () => element.removeEventListener('focusin', handleFocusIn)\n    }, [containerWidth])\n\n    const hasScrollbar = scrollMax > INITIAL_DIMENSION\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web' || !hasScrollbar) return undefined\n      const thumbElement = thumbRef.current\n      if (!thumbElement) return undefined\n\n      const handleMouseDown = (event) => {\n        event.preventDefault()\n        event.stopPropagation()\n        isDraggingRef.current = true\n        dragStartRef.current = {\n          mouseX: event.clientX,\n          scrollOffset: getScrollableNode(scrollRef)?.scrollLeft ?? INITIAL_DIMENSION\n        }\n        thumbElement.style.cursor = 'grabbing'\n        document.body.style.cursor = 'grabbing'\n        document.body.style.userSelect = 'none'\n      }\n\n      const handleMouseMove = (event) => {\n        if (!isDraggingRef.current) return\n        const trackElement = pressableRef.current\n        if (!trackElement) return\n        const trackWidth = trackElement.offsetWidth\n        const thumbPixelWidth = (thumbWidthPercentRef.current / MAX_PERCENTAGE) * trackWidth\n        const availableTrackPixels = trackWidth - thumbPixelWidth\n        if (availableTrackPixels <= INITIAL_DIMENSION) return\n        const mouseDelta = event.clientX - dragStartRef.current.mouseX\n        const scrollDelta = (mouseDelta / availableTrackPixels) * scrollMaxRef.current\n        const targetScroll = Math.max(\n          INITIAL_DIMENSION,\n          Math.min(scrollMaxRef.current, dragStartRef.current.scrollOffset + scrollDelta)\n        )\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (scrollableNode) {\n          scrollableNode.scrollLeft = targetScroll\n          scrollOffsetRef.current = targetScroll\n          setScrollOffset(targetScroll)\n        }\n      }\n\n      const handleMouseUp = () => {\n        if (!isDraggingRef.current) return\n        isDraggingRef.current = false\n        thumbElement.style.cursor = ''\n        document.body.style.cursor = ''\n        document.body.style.userSelect = ''\n      }\n\n      thumbElement.addEventListener('mousedown', handleMouseDown)\n      document.addEventListener('mousemove', handleMouseMove)\n      document.addEventListener('mouseup', handleMouseUp)\n\n      return () => {\n        thumbElement.removeEventListener('mousedown', handleMouseDown)\n        document.removeEventListener('mousemove', handleMouseMove)\n        document.removeEventListener('mouseup', handleMouseUp)\n      }\n    }, [hasScrollbar])\n\n    const handleKeyDown = React.useCallback(\n      (event) => {\n        if (event.key === KEY_ARROW_RIGHT || event.key === KEY_SPACE) {\n          event.preventDefault()\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({\n              x: scrollOffsetRef.current + itemWidth,\n              animated: true\n            })\n          }\n        } else if (event.key === KEY_ARROW_LEFT) {\n          event.preventDefault()\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({\n              x: Math.max(INITIAL_DIMENSION, scrollOffsetRef.current - itemWidth),\n              animated: true\n            })\n          }\n        }\n      },\n      [itemWidth]\n    )\n\n    const handleProgressPress = React.useCallback(\n      (event) => {\n        if (scrollMax <= INITIAL_DIMENSION || isDraggingRef.current) return\n        if (Platform.OS === 'web' && pressableRef.current) {\n          const { offsetX } = event.nativeEvent\n          const { offsetWidth } = pressableRef.current\n          const thumbPixelWidth = (thumbWidthPercent / MAX_PERCENTAGE) * offsetWidth\n          const availableTrack = offsetWidth - thumbPixelWidth\n          if (availableTrack <= INITIAL_DIMENSION) return\n          const clickPosition = Math.max(\n            INITIAL_DIMENSION,\n            Math.min(availableTrack, offsetX - thumbPixelWidth / HALF_DIVISOR)\n          )\n          const targetX = (clickPosition / availableTrack) * scrollMax\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({ x: targetX, animated: true })\n          }\n        } else if (pressableRef.current) {\n          const { locationX } = event.nativeEvent\n          pressableRef.current.measure((_x, _y, width) => {\n            const thumbPixelWidth = (thumbWidthPercent / MAX_PERCENTAGE) * width\n            const availableTrack = width - thumbPixelWidth\n            if (availableTrack <= INITIAL_DIMENSION) return\n            const clickPosition = Math.max(\n              INITIAL_DIMENSION,\n              Math.min(availableTrack, locationX - thumbPixelWidth / HALF_DIVISOR)\n            )\n            const targetX = (clickPosition / availableTrack) * scrollMax\n            if (scrollRef.current) {\n              scrollRef.current.scrollTo({ x: targetX, animated: true })\n            }\n          })\n        }\n      },\n      [scrollMax, thumbWidthPercent]\n    )\n\n    const handleContainerRef = React.useCallback(\n      (node) => {\n        scrollContainerRef.current = node\n        if (typeof ref === 'function') ref(node)\n        else if (ref) Object.assign(ref, { current: node })\n      },\n      [ref]\n    )\n\n    return (\n      <View\n        ref={handleContainerRef}\n        style={staticStyles.container}\n        {...selectContainerA11yProps({\n          accessibilityLabel: resolvedAccessibilityLabel,\n          descriptionId,\n          handleKeyDown\n        })}\n        {...selectProps(rest)}\n      >\n        <A11yText text={getCopy('instructionText')} nativeID={descriptionId} />\n        <View style={staticStyles.scrollContainer}>\n          <ScrollViewEnd\n            ref={scrollRef}\n            horizontal\n            onScrollEnd={handleScroll}\n            onScroll={handleScroll}\n            onContentSizeChange={handleContentWidth}\n            onLayout={handleContainerLayout}\n            showsHorizontalScrollIndicator={false}\n            contentContainerStyle={[staticStyles.scrollContent, selectScrollContentStyle(itemGap)]}\n          >\n            <ScrollProvider\n              itemWidth={itemWidth}\n              itemHeight={itemHeight}\n              onItemLayout={handleItemLayout}\n            >\n              {children}\n            </ScrollProvider>\n          </ScrollViewEnd>\n        </View>\n        {scrollMax > INITIAL_DIMENSION && (\n          <Pressable\n            ref={pressableRef}\n            style={[staticStyles.pressable, selectPressableStyles(defaultTokens)]}\n            onPress={handleProgressPress}\n          >\n            {(pressableState) => (\n              <ScrollProgress\n                ref={thumbRef}\n                pressableState={pressableState}\n                getTokens={getTokens}\n                thumbWrapperStyle={thumbWrapperStyle}\n                getCopy={getCopy}\n              />\n            )}\n          </Pressable>\n        )}\n      </View>\n    )\n  }\n)\n\nScroll.displayName = 'Scroll'\n\nScroll.propTypes = {\n  ...selectedSystemPropTypes,\n  /**\n   * Scroll items to display. Should be `ScrollItem` components.\n   */\n  children: PropTypes.node.isRequired,\n  /**\n   * Theme tokens for customizing the Scroll appearance\n   */\n  tokens: getTokensPropType('Scroll'),\n  /**\n   * Variant for the Scroll component\n   */\n  variant: variantProp.propType,\n  /**\n   * Select English or French copy for accessible labels.\n   */\n  copy: copyPropTypes,\n  /**\n   * Override the default dictionary by passing the complete dictionary object for `en` and `fr`.\n   */\n  dictionary: PropTypes.shape({\n    en: PropTypes.object,\n    fr: PropTypes.object\n  }),\n  /**\n   * Accessibility label for the scrollable region\n   */\n  accessibilityLabel: PropTypes.string\n}\n\nconst staticStyles = StyleSheet.create({\n  container: {\n    width: '100%'\n  },\n  scrollContainer: {\n    width: '100%'\n  },\n  pressable: {\n    justifyContent: 'center',\n    width: '100%'\n  },\n  scrollContent: {\n    alignSelf: 'flex-start',\n    flexGrow: 1\n  },\n  thumbWrapper: {\n    height: '100%'\n  },\n  thumbCursor: {\n    cursor: 'grab'\n  }\n})\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,UAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AACA,IAAAG,eAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AACA,IAAAO,mBAAA,GAAAP,OAAA;AACA,IAAAQ,QAAA,GAAAR,OAAA;AACA,IAAAS,YAAA,GAAAT,OAAA;AACA,IAAAU,YAAA,GAAAV,OAAA;AACA,IAAAW,UAAA,GAAAX,OAAA;AACA,IAAAY,SAAA,GAAAZ,OAAA;AACA,IAAAa,cAAA,GAAAb,OAAA;AACA,IAAAc,WAAA,GAAAd,OAAA;AACA,IAAAe,eAAA,GAAAf,OAAA;AACA,IAAAgB,cAAA,GAAAhB,OAAA;AAAgD,IAAAiB,WAAA,GAAAjB,OAAA;AAAA,IAAAkB,SAAA;AAEhD,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;AAE3C,IAAMK,yBAAyB,GAAG,oBAAoB;AACtD,IAAMC,eAAe,GAAG,YAAY;AACpC,IAAMC,cAAc,GAAG,WAAW;AAClC,IAAMC,SAAS,GAAG,GAAG;AACrB,IAAMC,cAAc,GAAG,GAAG;AAC1B,IAAMC,kBAAkB,GAAG,CAAC;AAC5B,IAAMC,WAAW,GAAG,QAAQ;AAC5B,IAAMC,SAAS,GAAG,MAAM;AACxB,IAAMC,cAAc,GAAG,QAAQ;AAC/B,IAAMC,oBAAoB,GAAG,oBAAoB;AACjD,IAAMC,SAAS,GAAG,CAAC;AACnB,IAAMC,iBAAiB,GAAG,CAAC;AAC3B,IAAMC,YAAY,GAAG,CAAC;AAEtB,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAqBA,CAAAC,IAAA;EAAA,IAAMC,qBAAqB,GAAAD,IAAA,CAArBC,qBAAqB;IAAEC,eAAe,GAAAF,IAAA,CAAfE,eAAe;EAAA,OAAQ;IAC7EC,MAAM,EAAEF,qBAAqB;IAC7BG,SAAS,EAAEF;EACb,CAAC;AAAA,CAAC;AAEF,IAAMG,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAAAC,KAAA;EAAA,IAAMC,iBAAiB,GAAAD,KAAA,CAAjBC,iBAAiB;IAAEC,oBAAoB,GAAAF,KAAA,CAApBE,oBAAoB;EAAA,OAAQ;IACjFC,KAAK,EAAE,GAAGF,iBAAiB,GAAG;IAC9BG,UAAU,EAAE,GAAGF,oBAAoB;EACrC,CAAC;AAAA,CAAC;AAEF,IAAMG,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAAAC,KAAA;EAAA,IAAMC,kBAAkB,GAAAD,KAAA,CAAlBC,kBAAkB;IAAEC,aAAa,GAAAF,KAAA,CAAbE,aAAa;IAAEC,aAAa,GAAAH,KAAA,CAAbG,aAAa;EAAA,OAClFC,qBAAQ,CAACC,EAAE,KAAK,KAAK,GACjB;IACEC,IAAI,EAAE1B,WAAW;IACjB,YAAY,EAAEqB,kBAAkB;IAChC,kBAAkB,EAAEC,aAAa;IACjCK,QAAQ,EAAEvB,SAAS;IACnBwB,SAAS,EAAEL;EACb,CAAC,GACD;IACEM,iBAAiB,EAAE5B,SAAS;IAC5BoB,kBAAkB,EAAlBA;EACF,CAAC;AAAA;AAEP,IAAMS,wBAAwB,GAAG,SAA3BA,wBAAwBA,CAAIC,OAAO;EAAA,OAAM;IAC7CC,SAAS,EAAED;EACb,CAAC;AAAA,CAAC;AAEF,IAAME,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAAC,KAAA,EAAyC;EAAA,IAAnCC,cAAc,GAAAD,KAAA,CAAdC,cAAc;IAAEC,YAAY,GAAAF,KAAA,CAAZE,YAAY;EACzD,IAAIA,YAAY,IAAI/B,iBAAiB,EAAE,OAAOP,cAAc;EAC5D,OAAOuC,IAAI,CAACC,GAAG,CACbvC,kBAAkB,EAClBsC,IAAI,CAACE,GAAG,CAACzC,cAAc,EAAGqC,cAAc,GAAGC,YAAY,GAAItC,cAAc,CAC3E,CAAC;AACH,CAAC;AAED,IAAM0C,sBAAsB,GAAG,SAAzBA,sBAAsBA,CAAAC,KAAA,EAAuD;EAAA,IAAjDC,YAAY,GAAAD,KAAA,CAAZC,YAAY;IAAEC,SAAS,GAAAF,KAAA,CAATE,SAAS;IAAE5B,iBAAiB,GAAA0B,KAAA,CAAjB1B,iBAAiB;EAC1E,IAAI4B,SAAS,IAAItC,iBAAiB,EAAE,OAAOA,iBAAiB;EAC5D,OAAQqC,YAAY,GAAGC,SAAS,IAAK7C,cAAc,GAAGiB,iBAAiB,CAAC;AAC1E,CAAC;AAED,IAAM6B,iBAAiB,GAAG,SAApBA,iBAAiBA,CAAIC,GAAG;EAAA,IAAAC,qBAAA,EAAAC,YAAA;EAAA,QAAAD,qBAAA,IAAAC,YAAA,GAAKF,GAAG,CAACG,OAAO,aAAXD,YAAA,CAAaH,iBAAiB,oBAA9BG,YAAA,CAAaH,iBAAiB,CAAG,CAAC,YAAAE,qBAAA,GAAI,IAAI;AAAA;AAyBtE,IAAMG,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAGE,cAAK,CAACC,UAAU,CACpC,UAAAC,KAAA,EAUER,GAAG,EACA;EAAA,IATDS,QAAQ,GAAAD,KAAA,CAARC,QAAQ;IACRC,MAAM,GAAAF,KAAA,CAANE,MAAM;IACNC,OAAO,GAAAH,KAAA,CAAPG,OAAO;IACPC,IAAI,GAAAJ,KAAA,CAAJI,IAAI;IAAAC,gBAAA,GAAAL,KAAA,CACJM,UAAU;IAAEC,gBAAgB,GAAAF,gBAAA,cAAGC,sBAAU,GAAAD,gBAAA;IACzCrC,kBAAkB,GAAAgC,KAAA,CAAlBhC,kBAAkB;IACfwC,IAAI,OAAAC,yBAAA,CAAAvE,OAAA,EAAA8D,KAAA,EAAArE,SAAA;EAIT,IAAM+E,OAAO,GAAG,IAAAC,gBAAO,EAAC;IAAEL,UAAU,EAAEC,gBAAgB;IAAEH,IAAI,EAAJA;EAAK,CAAC,CAAC;EAC/D,IAAMQ,0BAA0B,GAAG5C,kBAAkB,IAAI0C,OAAO,CAAC,oBAAoB,CAAC;EACtF,IAAMG,SAAS,GAAG,IAAAC,sCAAsB,EAACjE,cAAc,EAAEqD,MAAM,EAAEC,OAAO,CAAC;EACzE,IAAMY,aAAa,GAAGjB,cAAK,CAACkB,OAAO,CAAC;IAAA,OAAMH,SAAS,CAAC,CAAC;EAAA,GAAE,CAACA,SAAS,CAAC,CAAC;EACnE,IAAM5C,aAAa,GAAG,IAAAgD,wBAAW,EAAC5E,yBAAyB,CAAC;EAC5D,IAAM6E,SAAS,GAAGpB,cAAK,CAACqB,MAAM,CAAC,IAAI,CAAC;EACpC,IAAMC,YAAY,GAAGtB,cAAK,CAACqB,MAAM,CAAC,IAAI,CAAC;EACvC,IAAME,kBAAkB,GAAGvB,cAAK,CAACqB,MAAM,CAAC,IAAI,CAAC;EAC7C,IAAMG,YAAY,GAAGxB,cAAK,CAACqB,MAAM,CAACnE,iBAAiB,CAAC;EACpD,IAAMuE,eAAe,GAAGzB,cAAK,CAACqB,MAAM,CAACnE,iBAAiB,CAAC;EACvD,IAAMwE,oBAAoB,GAAG1B,cAAK,CAACqB,MAAM,CAAC1E,cAAc,CAAC;EACzD,IAAMgF,QAAQ,GAAG3B,cAAK,CAACqB,MAAM,CAAC,IAAI,CAAC;EACnC,IAAMO,aAAa,GAAG5B,cAAK,CAACqB,MAAM,CAAC,KAAK,CAAC;EACzC,IAAMQ,YAAY,GAAG7B,cAAK,CAACqB,MAAM,CAAC;IAChCS,MAAM,EAAE5E,iBAAiB;IACzBqC,YAAY,EAAErC;EAChB,CAAC,CAAC;EAEF,IAAA6E,eAAA,GAAwC/B,cAAK,CAACgC,QAAQ,CAAC9E,iBAAiB,CAAC;IAAA+E,gBAAA,OAAA9F,eAAA,CAAAC,OAAA,EAAA2F,eAAA;IAAlExC,YAAY,GAAA0C,gBAAA;IAAEC,eAAe,GAAAD,gBAAA;EACpC,IAAAE,gBAAA,GAA4CnC,cAAK,CAACgC,QAAQ,CAAC9E,iBAAiB,CAAC;IAAAkF,gBAAA,OAAAjG,eAAA,CAAAC,OAAA,EAAA+F,gBAAA;IAAtEnD,cAAc,GAAAoD,gBAAA;IAAEC,iBAAiB,GAAAD,gBAAA;EACxC,IAAAE,gBAAA,GAAwCtC,cAAK,CAACgC,QAAQ,CAAC9E,iBAAiB,CAAC;IAAAqF,gBAAA,OAAApG,eAAA,CAAAC,OAAA,EAAAkG,gBAAA;IAAlErD,YAAY,GAAAsD,gBAAA;IAAEC,eAAe,GAAAD,gBAAA;EACpC,IAAAE,gBAAA,GAAkCzC,cAAK,CAACgC,QAAQ,CAAC9E,iBAAiB,CAAC;IAAAwF,gBAAA,OAAAvG,eAAA,CAAAC,OAAA,EAAAqG,gBAAA;IAA5DE,SAAS,GAAAD,gBAAA;IAAEE,YAAY,GAAAF,gBAAA;EAC9B,IAAAG,gBAAA,GAAoC7C,cAAK,CAACgC,QAAQ,CAAC9E,iBAAiB,CAAC;IAAA4F,gBAAA,OAAA3G,eAAA,CAAAC,OAAA,EAAAyG,gBAAA;IAA9DE,UAAU,GAAAD,gBAAA;IAAEE,aAAa,GAAAF,gBAAA;EAEhC,IAAQlE,OAAO,GAAKqC,aAAa,CAAzBrC,OAAO;EACf,IAAMY,SAAS,GAAGN,IAAI,CAACC,GAAG,CAACjC,iBAAiB,EAAE+B,YAAY,GAAGD,cAAc,CAAC;EAE5EgB,cAAK,CAACiD,SAAS,CAAC,YAAM;IACpBzB,YAAY,CAAC3B,OAAO,GAAGL,SAAS;EAClC,CAAC,EAAE,CAACA,SAAS,CAAC,CAAC;EAEf,IAAM5B,iBAAiB,GAAGkB,mBAAmB,CAAC;IAAEE,cAAc,EAAdA,cAAc;IAAEC,YAAY,EAAZA;EAAa,CAAC,CAAC;EAC/EyC,oBAAoB,CAAC7B,OAAO,GAAGjC,iBAAiB;EAChD,IAAMC,oBAAoB,GAAGwB,sBAAsB,CAAC;IAClDE,YAAY,EAAZA,YAAY;IACZC,SAAS,EAATA,SAAS;IACT5B,iBAAiB,EAAjBA;EACF,CAAC,CAAC;EAEF,IAAMsF,iBAAiB,GAAGlD,cAAK,CAACkB,OAAO,CACrC;IAAA,OAAM,CACJiC,YAAY,CAACC,YAAY,EACzB1F,wBAAwB,CAAC;MAAEE,iBAAiB,EAAjBA,iBAAiB;MAAEC,oBAAoB,EAApBA;IAAqB,CAAC,CAAC,EACrEQ,qBAAQ,CAACC,EAAE,KAAK,KAAK,GAAG6E,YAAY,CAACE,WAAW,GAAG,IAAI,CACxD;EAAA,GACD,CAACzF,iBAAiB,EAAEC,oBAAoB,CAC1C,CAAC;EAED,IAAMyF,YAAY,GAAGtD,cAAK,CAACuD,WAAW,CACpC,UAAAC,KAAA,EAIM;IAAA,IAFeC,CAAC,GAAAD,KAAA,CADpBE,WAAW,CACTC,aAAa,CAAIF,CAAC;IAGpBhC,eAAe,CAAC5B,OAAO,GAAG4D,CAAC;IAC3BvB,eAAe,CAACuB,CAAC,CAAC;EACpB,CAAC,EACD,EACF,CAAC;EAED,IAAMG,qBAAqB,GAAG5D,cAAK,CAACuD,WAAW,CAC7C,UAAAM,KAAA,EAIM;IAAA,IAFQ/F,KAAK,GAAA+F,KAAA,CADjBH,WAAW,CACTI,MAAM,CAAIhG,KAAK;IAGjBuE,iBAAiB,CAACvE,KAAK,CAAC;EAC1B,CAAC,EACD,EACF,CAAC;EAED,IAAMiG,kBAAkB,GAAG/D,cAAK,CAACuD,WAAW,CAAC,UAACzF,KAAK,EAAK;IACtD0E,eAAe,CAAC1E,KAAK,CAAC;EACxB,CAAC,EAAE,EAAE,CAAC;EAEN,IAAMkG,gBAAgB,GAAGhE,cAAK,CAACuD,WAAW,CAAC,UAACzF,KAAK,EAAEN,MAAM,EAAK;IAC5DoF,YAAY,CAAC,UAACqB,IAAI;MAAA,OAAK/E,IAAI,CAACC,GAAG,CAAC8E,IAAI,EAAEnG,KAAK,CAAC;IAAA,EAAC;IAC7CkF,aAAa,CAAC,UAACiB,IAAI;MAAA,OAAK/E,IAAI,CAACC,GAAG,CAAC8E,IAAI,EAAEzG,MAAM,CAAC;IAAA,EAAC;EACjD,CAAC,EAAE,EAAE,CAAC;EAENwC,cAAK,CAACiD,SAAS,CAAC,YAAM;IACpB,IAAI5E,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE,OAAO4F,SAAS;IAC3C,IAAMC,OAAO,GAAG5C,kBAAkB,CAAC1B,OAAO;IAC1C,IAAI,CAACsE,OAAO,EAAE,OAAOD,SAAS;IAC9B,IAAME,WAAW,GAAG,SAAdA,WAAWA,CAAIC,KAAK,EAAK;MAC7BA,KAAK,CAACC,cAAc,CAAC,CAAC;MACtBD,KAAK,CAACE,eAAe,CAAC,CAAC;MACvB,IAAMC,YAAY,GAAGtF,IAAI,CAACuF,GAAG,CAACJ,KAAK,CAACK,MAAM,CAAC,GAAGxF,IAAI,CAACuF,GAAG,CAACJ,KAAK,CAACM,MAAM,CAAC;MACpE,IAAMC,KAAK,GAAGJ,YAAY,GAAGH,KAAK,CAACK,MAAM,GAAGL,KAAK,CAACM,MAAM;MACxD,IAAME,cAAc,GAAGpF,iBAAiB,CAAC2B,SAAS,CAAC;MACnD,IAAIyD,cAAc,EAAE;QAClB,IAAMC,SAAS,GAAGtD,YAAY,CAAC3B,OAAO;QACtC,IAAMkF,aAAa,GAAG7F,IAAI,CAACC,GAAG,CAC5BjC,iBAAiB,EACjBgC,IAAI,CAACE,GAAG,CAAC0F,SAAS,EAAED,cAAc,CAACG,UAAU,GAAGJ,KAAK,CACvD,CAAC;QACDC,cAAc,CAACG,UAAU,GAAGD,aAAa;QACzCtD,eAAe,CAAC5B,OAAO,GAAGkF,aAAa;QACvC7C,eAAe,CAAC6C,aAAa,CAAC;MAChC;IACF,CAAC;IACDZ,OAAO,CAACc,gBAAgB,CAAC,OAAO,EAAEb,WAAW,EAAE;MAAEc,OAAO,EAAE;IAAM,CAAC,CAAC;IAClE,OAAO;MAAA,OAAMf,OAAO,CAACgB,mBAAmB,CAAC,OAAO,EAAEf,WAAW,CAAC;IAAA;EAChE,CAAC,EAAE,EAAE,CAAC;EAENpE,cAAK,CAACiD,SAAS,CAAC,YAAM;IACpB,IAAI5E,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE,OAAO4F,SAAS;IAC3C,IAAMC,OAAO,GAAG5C,kBAAkB,CAAC1B,OAAO;IAC1C,IAAI,CAACsE,OAAO,EAAE,OAAOD,SAAS;IAE9B,IAAMkB,aAAa,GAAG,SAAhBA,aAAaA,CAAIf,KAAK,EAAK;MAC/B,IAAMQ,cAAc,GAAGpF,iBAAiB,CAAC2B,SAAS,CAAC;MACnD,IAAI,CAACyD,cAAc,EAAE;MACrB,IAAMQ,WAAW,GAAGhB,KAAK,CAACiB,MAAM,CAACC,OAAO,CAACvI,oBAAoB,CAAC;MAC9D,IAAI,CAACqI,WAAW,EAAE;MAClB,IAAMG,QAAQ,GAAGH,WAAW,CAACI,UAAU;MACvC,IAAMC,SAAS,GAAGF,QAAQ,GAAGH,WAAW,CAACM,WAAW;MACpD,IAAMC,WAAW,GAAGf,cAAc,CAACG,UAAU;MAC7C,IAAMa,qBAAqB,GAAG7G,cAAc;MAC5C,IAAM8G,YAAY,GAAGF,WAAW,GAAGC,qBAAqB;MACxD,IAAIH,SAAS,GAAGI,YAAY,EAAE;QAC5B1E,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;UAAEtC,CAAC,EAAEiC,SAAS,GAAGG,qBAAqB;UAAEG,QAAQ,EAAE;QAAK,CAAC,CAAC;MACtF,CAAC,MAAM,IAAIR,QAAQ,GAAGI,WAAW,EAAE;QACjCxE,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;UAAEtC,CAAC,EAAE+B,QAAQ;UAAEQ,QAAQ,EAAE;QAAK,CAAC,CAAC;MAC7D;IACF,CAAC;IAED7B,OAAO,CAACc,gBAAgB,CAAC,SAAS,EAAEG,aAAa,CAAC;IAClD,OAAO;MAAA,OAAMjB,OAAO,CAACgB,mBAAmB,CAAC,SAAS,EAAEC,aAAa,CAAC;IAAA;EACpE,CAAC,EAAE,CAACpG,cAAc,CAAC,CAAC;EAEpB,IAAMiH,YAAY,GAAGzG,SAAS,GAAGtC,iBAAiB;EAElD8C,cAAK,CAACiD,SAAS,CAAC,YAAM;IACpB,IAAI5E,qBAAQ,CAACC,EAAE,KAAK,KAAK,IAAI,CAAC2H,YAAY,EAAE,OAAO/B,SAAS;IAC5D,IAAMgC,YAAY,GAAGvE,QAAQ,CAAC9B,OAAO;IACrC,IAAI,CAACqG,YAAY,EAAE,OAAOhC,SAAS;IAEnC,IAAMiC,eAAe,GAAG,SAAlBA,eAAeA,CAAI9B,KAAK,EAAK;MAAA,IAAA+B,qBAAA,EAAAC,kBAAA;MACjChC,KAAK,CAACC,cAAc,CAAC,CAAC;MACtBD,KAAK,CAACE,eAAe,CAAC,CAAC;MACvB3C,aAAa,CAAC/B,OAAO,GAAG,IAAI;MAC5BgC,YAAY,CAAChC,OAAO,GAAG;QACrBiC,MAAM,EAAEuC,KAAK,CAACiC,OAAO;QACrB/G,YAAY,GAAA6G,qBAAA,IAAAC,kBAAA,GAAE5G,iBAAiB,CAAC2B,SAAS,CAAC,qBAA5BiF,kBAAA,CAA8BrB,UAAU,YAAAoB,qBAAA,GAAIlJ;MAC5D,CAAC;MACDgJ,YAAY,CAACK,KAAK,CAACC,MAAM,GAAG,UAAU;MACtCC,QAAQ,CAACC,IAAI,CAACH,KAAK,CAACC,MAAM,GAAG,UAAU;MACvCC,QAAQ,CAACC,IAAI,CAACH,KAAK,CAACI,UAAU,GAAG,MAAM;IACzC,CAAC;IAED,IAAMC,eAAe,GAAG,SAAlBA,eAAeA,CAAIvC,KAAK,EAAK;MACjC,IAAI,CAACzC,aAAa,CAAC/B,OAAO,EAAE;MAC5B,IAAMgH,YAAY,GAAGvF,YAAY,CAACzB,OAAO;MACzC,IAAI,CAACgH,YAAY,EAAE;MACnB,IAAMC,UAAU,GAAGD,YAAY,CAAClB,WAAW;MAC3C,IAAMoB,eAAe,GAAIrF,oBAAoB,CAAC7B,OAAO,GAAGlD,cAAc,GAAImK,UAAU;MACpF,IAAME,oBAAoB,GAAGF,UAAU,GAAGC,eAAe;MACzD,IAAIC,oBAAoB,IAAI9J,iBAAiB,EAAE;MAC/C,IAAM+J,UAAU,GAAG5C,KAAK,CAACiC,OAAO,GAAGzE,YAAY,CAAChC,OAAO,CAACiC,MAAM;MAC9D,IAAMoF,WAAW,GAAID,UAAU,GAAGD,oBAAoB,GAAIxF,YAAY,CAAC3B,OAAO;MAC9E,IAAMsH,YAAY,GAAGjI,IAAI,CAACC,GAAG,CAC3BjC,iBAAiB,EACjBgC,IAAI,CAACE,GAAG,CAACoC,YAAY,CAAC3B,OAAO,EAAEgC,YAAY,CAAChC,OAAO,CAACN,YAAY,GAAG2H,WAAW,CAChF,CAAC;MACD,IAAMrC,cAAc,GAAGpF,iBAAiB,CAAC2B,SAAS,CAAC;MACnD,IAAIyD,cAAc,EAAE;QAClBA,cAAc,CAACG,UAAU,GAAGmC,YAAY;QACxC1F,eAAe,CAAC5B,OAAO,GAAGsH,YAAY;QACtCjF,eAAe,CAACiF,YAAY,CAAC;MAC/B;IACF,CAAC;IAED,IAAMC,aAAa,GAAG,SAAhBA,aAAaA,CAAA,EAAS;MAC1B,IAAI,CAACxF,aAAa,CAAC/B,OAAO,EAAE;MAC5B+B,aAAa,CAAC/B,OAAO,GAAG,KAAK;MAC7BqG,YAAY,CAACK,KAAK,CAACC,MAAM,GAAG,EAAE;MAC9BC,QAAQ,CAACC,IAAI,CAACH,KAAK,CAACC,MAAM,GAAG,EAAE;MAC/BC,QAAQ,CAACC,IAAI,CAACH,KAAK,CAACI,UAAU,GAAG,EAAE;IACrC,CAAC;IAEDT,YAAY,CAACjB,gBAAgB,CAAC,WAAW,EAAEkB,eAAe,CAAC;IAC3DM,QAAQ,CAACxB,gBAAgB,CAAC,WAAW,EAAE2B,eAAe,CAAC;IACvDH,QAAQ,CAACxB,gBAAgB,CAAC,SAAS,EAAEmC,aAAa,CAAC;IAEnD,OAAO,YAAM;MACXlB,YAAY,CAACf,mBAAmB,CAAC,WAAW,EAAEgB,eAAe,CAAC;MAC9DM,QAAQ,CAACtB,mBAAmB,CAAC,WAAW,EAAEyB,eAAe,CAAC;MAC1DH,QAAQ,CAACtB,mBAAmB,CAAC,SAAS,EAAEiC,aAAa,CAAC;IACxD,CAAC;EACH,CAAC,EAAE,CAACnB,YAAY,CAAC,CAAC;EAElB,IAAM7H,aAAa,GAAG4B,cAAK,CAACuD,WAAW,CACrC,UAACc,KAAK,EAAK;IACT,IAAIA,KAAK,CAACgD,GAAG,KAAK7K,eAAe,IAAI6H,KAAK,CAACgD,GAAG,KAAK3K,SAAS,EAAE;MAC5D2H,KAAK,CAACC,cAAc,CAAC,CAAC;MACtB,IAAIlD,SAAS,CAACvB,OAAO,EAAE;QACrBuB,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;UACzBtC,CAAC,EAAEhC,eAAe,CAAC5B,OAAO,GAAG8C,SAAS;UACtCqD,QAAQ,EAAE;QACZ,CAAC,CAAC;MACJ;IACF,CAAC,MAAM,IAAI3B,KAAK,CAACgD,GAAG,KAAK5K,cAAc,EAAE;MACvC4H,KAAK,CAACC,cAAc,CAAC,CAAC;MACtB,IAAIlD,SAAS,CAACvB,OAAO,EAAE;QACrBuB,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;UACzBtC,CAAC,EAAEvE,IAAI,CAACC,GAAG,CAACjC,iBAAiB,EAAEuE,eAAe,CAAC5B,OAAO,GAAG8C,SAAS,CAAC;UACnEqD,QAAQ,EAAE;QACZ,CAAC,CAAC;MACJ;IACF;EACF,CAAC,EACD,CAACrD,SAAS,CACZ,CAAC;EAED,IAAM2E,mBAAmB,GAAGtH,cAAK,CAACuD,WAAW,CAC3C,UAACc,KAAK,EAAK;IACT,IAAI7E,SAAS,IAAItC,iBAAiB,IAAI0E,aAAa,CAAC/B,OAAO,EAAE;IAC7D,IAAIxB,qBAAQ,CAACC,EAAE,KAAK,KAAK,IAAIgD,YAAY,CAACzB,OAAO,EAAE;MACjD,IAAQ0H,OAAO,GAAKlD,KAAK,CAACX,WAAW,CAA7B6D,OAAO;MACf,IAAQ5B,WAAW,GAAKrE,YAAY,CAACzB,OAAO,CAApC8F,WAAW;MACnB,IAAMoB,eAAe,GAAInJ,iBAAiB,GAAGjB,cAAc,GAAIgJ,WAAW;MAC1E,IAAM6B,cAAc,GAAG7B,WAAW,GAAGoB,eAAe;MACpD,IAAIS,cAAc,IAAItK,iBAAiB,EAAE;MACzC,IAAMuK,aAAa,GAAGvI,IAAI,CAACC,GAAG,CAC5BjC,iBAAiB,EACjBgC,IAAI,CAACE,GAAG,CAACoI,cAAc,EAAED,OAAO,GAAGR,eAAe,GAAG5J,YAAY,CACnE,CAAC;MACD,IAAMuK,OAAO,GAAID,aAAa,GAAGD,cAAc,GAAIhI,SAAS;MAC5D,IAAI4B,SAAS,CAACvB,OAAO,EAAE;QACrBuB,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;UAAEtC,CAAC,EAAEiE,OAAO;UAAE1B,QAAQ,EAAE;QAAK,CAAC,CAAC;MAC5D;IACF,CAAC,MAAM,IAAI1E,YAAY,CAACzB,OAAO,EAAE;MAC/B,IAAQ8H,SAAS,GAAKtD,KAAK,CAACX,WAAW,CAA/BiE,SAAS;MACjBrG,YAAY,CAACzB,OAAO,CAAC+H,OAAO,CAAC,UAACC,EAAE,EAAEC,EAAE,EAAEhK,KAAK,EAAK;QAC9C,IAAMiJ,eAAe,GAAInJ,iBAAiB,GAAGjB,cAAc,GAAImB,KAAK;QACpE,IAAM0J,cAAc,GAAG1J,KAAK,GAAGiJ,eAAe;QAC9C,IAAIS,cAAc,IAAItK,iBAAiB,EAAE;QACzC,IAAMuK,aAAa,GAAGvI,IAAI,CAACC,GAAG,CAC5BjC,iBAAiB,EACjBgC,IAAI,CAACE,GAAG,CAACoI,cAAc,EAAEG,SAAS,GAAGZ,eAAe,GAAG5J,YAAY,CACrE,CAAC;QACD,IAAMuK,OAAO,GAAID,aAAa,GAAGD,cAAc,GAAIhI,SAAS;QAC5D,IAAI4B,SAAS,CAACvB,OAAO,EAAE;UACrBuB,SAAS,CAACvB,OAAO,CAACkG,QAAQ,CAAC;YAAEtC,CAAC,EAAEiE,OAAO;YAAE1B,QAAQ,EAAE;UAAK,CAAC,CAAC;QAC5D;MACF,CAAC,CAAC;IACJ;EACF,CAAC,EACD,CAACxG,SAAS,EAAE5B,iBAAiB,CAC/B,CAAC;EAED,IAAMmK,kBAAkB,GAAG/H,cAAK,CAACuD,WAAW,CAC1C,UAACyE,IAAI,EAAK;IACRzG,kBAAkB,CAAC1B,OAAO,GAAGmI,IAAI;IACjC,IAAI,OAAOtI,GAAG,KAAK,UAAU,EAAEA,GAAG,CAACsI,IAAI,CAAC,MACnC,IAAItI,GAAG,EAAEuI,MAAM,CAACC,MAAM,CAACxI,GAAG,EAAE;MAAEG,OAAO,EAAEmI;IAAK,CAAC,CAAC;EACrD,CAAC,EACD,CAACtI,GAAG,CACN,CAAC;EAED,OACE,IAAA9D,WAAA,CAAAuM,IAAA,EAACtN,YAAA,CAAAuN,IAAI,EAAAH,MAAA,CAAAC,MAAA;IACHxI,GAAG,EAAEqI,kBAAmB;IACxBxB,KAAK,EAAEpD,YAAY,CAACkF;EAAU,GAC1BrK,wBAAwB,CAAC;IAC3BE,kBAAkB,EAAE4C,0BAA0B;IAC9C3C,aAAa,EAAbA,aAAa;IACbC,aAAa,EAAbA;EACF,CAAC,CAAC,EACE/B,WAAW,CAACqE,IAAI,CAAC;IAAAP,QAAA,GAErB,IAAAvE,WAAA,CAAA0M,GAAA,EAAC/M,SAAA,CAAAgN,QAAQ;MAACC,IAAI,EAAE5H,OAAO,CAAC,iBAAiB,CAAE;MAAC6H,QAAQ,EAAEtK;IAAc,CAAE,CAAC,EACvE,IAAAvC,WAAA,CAAA0M,GAAA,EAACzN,YAAA,CAAAuN,IAAI;MAAC7B,KAAK,EAAEpD,YAAY,CAACuF,eAAgB;MAAAvI,QAAA,EACxC,IAAAvE,WAAA,CAAA0M,GAAA,EAAC9M,cAAA,CAAAmN,aAAa;QACZjJ,GAAG,EAAE0B,SAAU;QACfwH,UAAU;QACVC,WAAW,EAAEvF,YAAa;QAC1BwF,QAAQ,EAAExF,YAAa;QACvByF,mBAAmB,EAAEhF,kBAAmB;QACxCiF,QAAQ,EAAEpF,qBAAsB;QAChCqF,8BAA8B,EAAE,KAAM;QACtCC,qBAAqB,EAAE,CAAC/F,YAAY,CAACgG,aAAa,EAAExK,wBAAwB,CAACC,OAAO,CAAC,CAAE;QAAAuB,QAAA,EAEvF,IAAAvE,WAAA,CAAA0M,GAAA,EAAC3M,cAAA,CAAAyN,cAAc;UACbzG,SAAS,EAAEA,SAAU;UACrBI,UAAU,EAAEA,UAAW;UACvBsG,YAAY,EAAErF,gBAAiB;UAAA7D,QAAA,EAE9BA;QAAQ,CACK;MAAC,CACJ;IAAC,CACZ,CAAC,EACNX,SAAS,GAAGtC,iBAAiB,IAC5B,IAAAtB,WAAA,CAAA0M,GAAA,EAACzN,YAAA,CAAAyO,SAAS;MACR5J,GAAG,EAAE4B,YAAa;MAClBiF,KAAK,EAAE,CAACpD,YAAY,CAACoG,SAAS,EAAEnM,qBAAqB,CAAC6D,aAAa,CAAC,CAAE;MACtEuI,OAAO,EAAElC,mBAAoB;MAAAnH,QAAA,EAE5B,SAAAA,SAACsJ,cAAc;QAAA,OACd,IAAA7N,WAAA,CAAA0M,GAAA,EAAC5M,eAAA,CAAAgO,cAAc;UACbhK,GAAG,EAAEiC,QAAS;UACd8H,cAAc,EAAEA,cAAe;UAC/B1I,SAAS,EAAEA,SAAU;UACrBmC,iBAAiB,EAAEA,iBAAkB;UACrCtC,OAAO,EAAEA;QAAQ,CAClB,CAAC;MAAA;IACH,CACQ,CACZ;EAAA,EACG,CAAC;AAEX,CACF,CAAC;AAEDd,MAAM,CAAC6J,WAAW,GAAG,QAAQ;AAE7B7J,MAAM,CAAC8J,SAAS,GAAA3B,MAAA,CAAAC,MAAA,KACX5L,uBAAuB;EAI1B6D,QAAQ,EAAE0J,kBAAS,CAAC7B,IAAI,CAAC8B,UAAU;EAInC1J,MAAM,EAAE,IAAA2J,yBAAiB,EAAC,QAAQ,CAAC;EAInC1J,OAAO,EAAE2J,wBAAW,CAACC,QAAQ;EAI7B3J,IAAI,EAAE4J,4BAAa;EAInB1J,UAAU,EAAEqJ,kBAAS,CAACM,KAAK,CAAC;IAC1BC,EAAE,EAAEP,kBAAS,CAACQ,MAAM;IACpBC,EAAE,EAAET,kBAAS,CAACQ;EAChB,CAAC,CAAC;EAIFnM,kBAAkB,EAAE2L,kBAAS,CAACU;AAAM,EACrC;AAED,IAAMpH,YAAY,GAAGqH,uBAAU,CAACC,MAAM,CAAC;EACrCpC,SAAS,EAAE;IACTvK,KAAK,EAAE;EACT,CAAC;EACD4K,eAAe,EAAE;IACf5K,KAAK,EAAE;EACT,CAAC;EACDyL,SAAS,EAAE;IACTmB,cAAc,EAAE,QAAQ;IACxB5M,KAAK,EAAE;EACT,CAAC;EACDqL,aAAa,EAAE;IACbwB,SAAS,EAAE,YAAY;IACvBC,QAAQ,EAAE;EACZ,CAAC;EACDxH,YAAY,EAAE;IACZ5F,MAAM,EAAE;EACV,CAAC;EACD6F,WAAW,EAAE;IACXmD,MAAM,EAAE;EACV;AACF,CAAC,CAAC","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/bc/Scroll_bcff81cf140cf0493527561ec0160395.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_propTypes","_reactNative","_useThemeTokens","_a11yProps","_copyPropTypes","_tokens","_selectSystemProps3","_useCopy","_useUniqueId","_variantProp","_viewProps","_A11yText","_ScrollViewEnd","_dictionary","_ScrollProgress","_ScrollContext","_jsxRuntime","_excluded","_selectSystemProps","selectSystemProps","a11yProps","viewProps","_selectSystemProps2","_slicedToArray2","default","selectProps","selectedSystemPropTypes","SCROLL_DESCRIPTION_PREFIX","KEY_ARROW_RIGHT","KEY_ARROW_LEFT","KEY_SPACE","MAX_PERCENTAGE","MIN_BAR_PERCENTAGE","ROLE_REGION","ROLE_NONE","COMPONENT_NAME","SCROLL_ITEM_SELECTOR","TAB_INDEX","INITIAL_DIMENSION","HALF_DIVISOR","selectPressableStyles","_ref","progressHitAreaHeight","progressSpacing","height","marginTop","selectThumbWrapperStyles","_ref2","thumbWidthPercent","thumbPositionPercent","width","marginLeft","selectContainerA11yProps","_ref3","accessibilityLabel","descriptionId","handleKeyDown","Platform","OS","role","tabIndex","onKeyDown","accessibilityRole","selectScrollContentStyle","itemGap","columnGap","calculateThumbWidth","_ref4","containerWidth","contentWidth","Math","max","min","calculateThumbPosition","_ref5","scrollOffset","scrollMax","getScrollableNode","ref","_ref$current$getScrol","_ref$current","current","Scroll","exports","React","forwardRef","_ref6","children","tokens","variant","copy","_ref6$dictionary","dictionary","customDictionary","rest","_objectWithoutProperties2","getCopy","useCopy","resolvedAccessibilityLabel","getTokens","useThemeTokensCallback","defaultTokens","useMemo","useUniqueId","scrollRef","useRef","pressableRef","scrollContainerRef","scrollMaxRef","scrollOffsetRef","thumbWidthPercentRef","thumbRef","isDraggingRef","dragStartRef","mouseX","_React$useState","useState","_React$useState2","setScrollOffset","_React$useState3","_React$useState4","setContainerWidth","_React$useState5","_React$useState6","setContentWidth","_React$useState7","_React$useState8","itemWidth","setItemWidth","_React$useState9","_React$useState0","itemHeight","setItemHeight","useEffect","thumbWrapperStyle","staticStyles","thumbWrapper","thumbCursor","handleScroll","useCallback","_ref7","x","nativeEvent","contentOffset","handleContainerLayout","_ref8","layout","handleContentWidth","handleItemLayout","prev","undefined","element","handleWheel","event","preventDefault","stopPropagation","isHorizontal","abs","deltaX","deltaY","delta","scrollableNode","maxScroll","newScrollLeft","scrollLeft","addEventListener","passive","removeEventListener","handleFocusIn","focusedItem","target","closest","itemLeft","offsetLeft","itemRight","offsetWidth","visibleLeft","currentContainerWidth","visibleRight","scrollTo","animated","hasScrollbar","thumbElement","handleMouseDown","_getScrollableNode$sc","_getScrollableNode","clientX","style","cursor","document","body","userSelect","handleMouseMove","trackElement","trackWidth","thumbPixelWidth","availableTrackPixels","mouseDelta","scrollDelta","targetScroll","handleMouseUp","key","handleProgressPress","offsetX","availableTrack","clickPosition","targetX","locationX","measure","_x","_y","handleContainerRef","node","Object","assign","jsxs","View","container","jsx","A11yText","text","nativeID","scrollContainer","ScrollViewEnd","horizontal","onScrollEnd","onScroll","onContentSizeChange","onLayout","showsHorizontalScrollIndicator","contentContainerStyle","scrollContent","ScrollProvider","onItemLayout","Pressable","pressable","onPress","pressableState","ScrollProgress","displayName","propTypes","PropTypes","isRequired","getTokensPropType","variantProp","propType","copyPropTypes","shape","en","object","fr","string","StyleSheet","create","justifyContent","alignSelf","flexGrow"],"sources":["Scroll.jsx"],"sourcesContent":["import React from 'react'\nimport PropTypes from 'prop-types'\nimport { Platform, Pressable, StyleSheet, View } from 'react-native'\nimport { useThemeTokensCallback } from '../ThemeProvider/useThemeTokens'\nimport { a11yProps } from '../utils/props/a11yProps'\nimport { copyPropTypes } from '../utils/props/copyPropTypes'\nimport { getTokensPropType } from '../utils/props/tokens'\nimport { selectSystemProps } from '../utils/props/selectSystemProps'\nimport { useCopy } from '../utils/useCopy'\nimport { useUniqueId } from '../utils/useUniqueId'\nimport { variantProp } from '../utils/props/variantProp'\nimport { viewProps } from '../utils/props/viewProps'\nimport { A11yText } from '../A11yText/A11yText'\nimport { ScrollViewEnd } from '../HorizontalScroll/ScrollViewEnd'\nimport { dictionary } from './dictionary'\nimport { ScrollProgress } from './ScrollProgress'\nimport { ScrollProvider } from './ScrollContext'\n\nconst [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps])\n\nconst SCROLL_DESCRIPTION_PREFIX = 'scroll-description'\nconst KEY_ARROW_RIGHT = 'ArrowRight'\nconst KEY_ARROW_LEFT = 'ArrowLeft'\nconst KEY_SPACE = ' '\nconst MAX_PERCENTAGE = 100\nconst MIN_BAR_PERCENTAGE = 1\nconst ROLE_REGION = 'region'\nconst ROLE_NONE = 'none'\nconst COMPONENT_NAME = 'Scroll'\nconst SCROLL_ITEM_SELECTOR = '[data-scroll-item]'\nconst TAB_INDEX = 0\nconst INITIAL_DIMENSION = 0\nconst HALF_DIVISOR = 2\n\nconst selectPressableStyles = ({ progressHitAreaHeight, progressSpacing }) => ({\n  height: progressHitAreaHeight,\n  marginTop: progressSpacing\n})\n\nconst selectThumbWrapperStyles = ({ thumbWidthPercent, thumbPositionPercent }) => ({\n  width: `${thumbWidthPercent}%`,\n  marginLeft: `${thumbPositionPercent}%`\n})\n\nconst selectContainerA11yProps = ({ accessibilityLabel, descriptionId, handleKeyDown }) =>\n  Platform.OS === 'web'\n    ? {\n        role: ROLE_REGION,\n        'aria-label': accessibilityLabel,\n        'aria-describedby': descriptionId,\n        tabIndex: TAB_INDEX,\n        onKeyDown: handleKeyDown\n      }\n    : {\n        accessibilityRole: ROLE_NONE,\n        accessibilityLabel\n      }\n\nconst selectScrollContentStyle = (itemGap) => ({\n  columnGap: itemGap\n})\n\nconst calculateThumbWidth = ({ containerWidth, contentWidth }) => {\n  if (contentWidth <= INITIAL_DIMENSION) return MAX_PERCENTAGE\n  return Math.max(\n    MIN_BAR_PERCENTAGE,\n    Math.min(MAX_PERCENTAGE, (containerWidth / contentWidth) * MAX_PERCENTAGE)\n  )\n}\n\nconst calculateThumbPosition = ({ scrollOffset, scrollMax, thumbWidthPercent }) => {\n  if (scrollMax <= INITIAL_DIMENSION) return INITIAL_DIMENSION\n  return (scrollOffset / scrollMax) * (MAX_PERCENTAGE - thumbWidthPercent)\n}\n\nconst getScrollableNode = (ref) => ref.current?.getScrollableNode?.() ?? null\n\n/**\n * The `Scroll` component provides a continuous horizontal scrollable container with a progress\n * bar indicator. Items are displayed in a flow layout where all items share the width of the\n * widest item and the height of the tallest item.\n *\n * ## Props\n *\n * - Use `children` to pass `ScrollItem` components\n * - Use `accessibilityLabel` to provide a meaningful label for the scrollable region\n * - Use `copy` to select English or French for accessible labels\n * - Use `dictionary` to override the default translations\n *\n * ## Usability and A11y guidelines\n *\n * - The scroll container is keyboard-focusable with `tabIndex=\"0\"`\n * - Each `ScrollItem` is individually focusable via Tab navigation\n * - Use left and right arrow keys to scroll by one item width\n * - Press Space bar to scroll right\n * - When tabbing through items, the scroll follows focus to keep the active item visible\n * - Screen readers announce the component as a region with a descriptive label\n * - Touch and swipe gestures are supported on mobile and mobile web\n *\n */\nexport const Scroll = React.forwardRef(\n  (\n    {\n      children,\n      tokens,\n      variant,\n      copy,\n      dictionary: customDictionary = dictionary,\n      accessibilityLabel,\n      ...rest\n    },\n    ref\n  ) => {\n    const getCopy = useCopy({ dictionary: customDictionary, copy })\n    const resolvedAccessibilityLabel = accessibilityLabel || getCopy('accessibilityLabel')\n    const getTokens = useThemeTokensCallback(COMPONENT_NAME, tokens, variant)\n    const defaultTokens = React.useMemo(() => getTokens(), [getTokens])\n    const descriptionId = useUniqueId(SCROLL_DESCRIPTION_PREFIX)\n    const scrollRef = React.useRef(null)\n    const pressableRef = React.useRef(null)\n    const scrollContainerRef = React.useRef(null)\n    const scrollMaxRef = React.useRef(INITIAL_DIMENSION)\n    const scrollOffsetRef = React.useRef(INITIAL_DIMENSION)\n    const thumbWidthPercentRef = React.useRef(MAX_PERCENTAGE)\n    const thumbRef = React.useRef(null)\n    const isDraggingRef = React.useRef(false)\n    const dragStartRef = React.useRef({\n      mouseX: INITIAL_DIMENSION,\n      scrollOffset: INITIAL_DIMENSION\n    })\n\n    const [scrollOffset, setScrollOffset] = React.useState(INITIAL_DIMENSION)\n    const [containerWidth, setContainerWidth] = React.useState(INITIAL_DIMENSION)\n    const [contentWidth, setContentWidth] = React.useState(INITIAL_DIMENSION)\n    const [itemWidth, setItemWidth] = React.useState(INITIAL_DIMENSION)\n    const [itemHeight, setItemHeight] = React.useState(INITIAL_DIMENSION)\n\n    const { itemGap } = defaultTokens\n    const scrollMax = Math.max(INITIAL_DIMENSION, contentWidth - containerWidth)\n\n    React.useEffect(() => {\n      scrollMaxRef.current = scrollMax\n    }, [scrollMax])\n\n    const thumbWidthPercent = calculateThumbWidth({ containerWidth, contentWidth })\n    thumbWidthPercentRef.current = thumbWidthPercent\n    const thumbPositionPercent = calculateThumbPosition({\n      scrollOffset,\n      scrollMax,\n      thumbWidthPercent\n    })\n\n    const thumbWrapperStyle = React.useMemo(\n      () => [\n        staticStyles.thumbWrapper,\n        selectThumbWrapperStyles({ thumbWidthPercent, thumbPositionPercent }),\n        Platform.OS === 'web' ? staticStyles.thumbCursor : null\n      ],\n      [thumbWidthPercent, thumbPositionPercent]\n    )\n\n    const handleScroll = React.useCallback(\n      ({\n        nativeEvent: {\n          contentOffset: { x }\n        }\n      }) => {\n        scrollOffsetRef.current = x\n        setScrollOffset(x)\n      },\n      []\n    )\n\n    const handleContainerLayout = React.useCallback(\n      ({\n        nativeEvent: {\n          layout: { width }\n        }\n      }) => {\n        setContainerWidth(width)\n      },\n      []\n    )\n\n    const handleContentWidth = React.useCallback((width) => {\n      setContentWidth(width)\n    }, [])\n\n    const handleItemLayout = React.useCallback((width, height) => {\n      setItemWidth((prev) => Math.max(prev, width))\n      setItemHeight((prev) => Math.max(prev, height))\n    }, [])\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web') return undefined\n      const element = scrollContainerRef.current\n      if (!element) return undefined\n      const handleWheel = (event) => {\n        event.preventDefault()\n        event.stopPropagation()\n        const isHorizontal = Math.abs(event.deltaX) > Math.abs(event.deltaY)\n        const delta = isHorizontal ? event.deltaX : event.deltaY\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (scrollableNode) {\n          const maxScroll = scrollMaxRef.current\n          const newScrollLeft = Math.max(\n            INITIAL_DIMENSION,\n            Math.min(maxScroll, scrollableNode.scrollLeft + delta)\n          )\n          scrollableNode.scrollLeft = newScrollLeft\n          scrollOffsetRef.current = newScrollLeft\n          setScrollOffset(newScrollLeft)\n        }\n      }\n      element.addEventListener('wheel', handleWheel, { passive: false })\n      return () => element.removeEventListener('wheel', handleWheel)\n    }, [])\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web') return undefined\n      const element = scrollContainerRef.current\n      if (!element) return undefined\n\n      const handleFocusIn = (event) => {\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (!scrollableNode) return\n        const focusedItem = event.target.closest(SCROLL_ITEM_SELECTOR)\n        if (!focusedItem) return\n        const itemLeft = focusedItem.offsetLeft\n        const itemRight = itemLeft + focusedItem.offsetWidth\n        const visibleLeft = scrollableNode.scrollLeft\n        const currentContainerWidth = containerWidth\n        const visibleRight = visibleLeft + currentContainerWidth\n        if (itemRight > visibleRight) {\n          scrollRef.current.scrollTo({ x: itemRight - currentContainerWidth, animated: true })\n        } else if (itemLeft < visibleLeft) {\n          scrollRef.current.scrollTo({ x: itemLeft, animated: true })\n        }\n      }\n\n      element.addEventListener('focusin', handleFocusIn)\n      return () => element.removeEventListener('focusin', handleFocusIn)\n    }, [containerWidth])\n\n    const hasScrollbar = scrollMax > INITIAL_DIMENSION\n\n    React.useEffect(() => {\n      if (Platform.OS !== 'web' || !hasScrollbar) return undefined\n      const thumbElement = thumbRef.current\n      if (!thumbElement) return undefined\n\n      const handleMouseDown = (event) => {\n        event.preventDefault()\n        event.stopPropagation()\n        isDraggingRef.current = true\n        dragStartRef.current = {\n          mouseX: event.clientX,\n          scrollOffset: getScrollableNode(scrollRef)?.scrollLeft ?? INITIAL_DIMENSION\n        }\n        thumbElement.style.cursor = 'grabbing'\n        document.body.style.cursor = 'grabbing'\n        document.body.style.userSelect = 'none'\n      }\n\n      const handleMouseMove = (event) => {\n        if (!isDraggingRef.current) return\n        const trackElement = pressableRef.current\n        if (!trackElement) return\n        const trackWidth = trackElement.offsetWidth\n        const thumbPixelWidth = (thumbWidthPercentRef.current / MAX_PERCENTAGE) * trackWidth\n        const availableTrackPixels = trackWidth - thumbPixelWidth\n        if (availableTrackPixels <= INITIAL_DIMENSION) return\n        const mouseDelta = event.clientX - dragStartRef.current.mouseX\n        const scrollDelta = (mouseDelta / availableTrackPixels) * scrollMaxRef.current\n        const targetScroll = Math.max(\n          INITIAL_DIMENSION,\n          Math.min(scrollMaxRef.current, dragStartRef.current.scrollOffset + scrollDelta)\n        )\n        const scrollableNode = getScrollableNode(scrollRef)\n        if (scrollableNode) {\n          scrollableNode.scrollLeft = targetScroll\n          scrollOffsetRef.current = targetScroll\n          setScrollOffset(targetScroll)\n        }\n      }\n\n      const handleMouseUp = () => {\n        if (!isDraggingRef.current) return\n        isDraggingRef.current = false\n        thumbElement.style.cursor = ''\n        document.body.style.cursor = ''\n        document.body.style.userSelect = ''\n      }\n\n      thumbElement.addEventListener('mousedown', handleMouseDown)\n      document.addEventListener('mousemove', handleMouseMove)\n      document.addEventListener('mouseup', handleMouseUp)\n\n      return () => {\n        thumbElement.removeEventListener('mousedown', handleMouseDown)\n        document.removeEventListener('mousemove', handleMouseMove)\n        document.removeEventListener('mouseup', handleMouseUp)\n      }\n    }, [hasScrollbar])\n\n    const handleKeyDown = React.useCallback(\n      (event) => {\n        if (event.key === KEY_ARROW_RIGHT || event.key === KEY_SPACE) {\n          event.preventDefault()\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({\n              x: scrollOffsetRef.current + itemWidth,\n              animated: true\n            })\n          }\n        } else if (event.key === KEY_ARROW_LEFT) {\n          event.preventDefault()\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({\n              x: Math.max(INITIAL_DIMENSION, scrollOffsetRef.current - itemWidth),\n              animated: true\n            })\n          }\n        }\n      },\n      [itemWidth]\n    )\n\n    const handleProgressPress = React.useCallback(\n      (event) => {\n        if (scrollMax <= INITIAL_DIMENSION || isDraggingRef.current) return\n        if (Platform.OS === 'web' && pressableRef.current) {\n          const { offsetX } = event.nativeEvent\n          const { offsetWidth } = pressableRef.current\n          const thumbPixelWidth = (thumbWidthPercent / MAX_PERCENTAGE) * offsetWidth\n          const availableTrack = offsetWidth - thumbPixelWidth\n          if (availableTrack <= INITIAL_DIMENSION) return\n          const clickPosition = Math.max(\n            INITIAL_DIMENSION,\n            Math.min(availableTrack, offsetX - thumbPixelWidth / HALF_DIVISOR)\n          )\n          const targetX = (clickPosition / availableTrack) * scrollMax\n          if (scrollRef.current) {\n            scrollRef.current.scrollTo({ x: targetX, animated: true })\n          }\n        } else if (pressableRef.current) {\n          const { locationX } = event.nativeEvent\n          pressableRef.current.measure((_x, _y, width) => {\n            const thumbPixelWidth = (thumbWidthPercent / MAX_PERCENTAGE) * width\n            const availableTrack = width - thumbPixelWidth\n            if (availableTrack <= INITIAL_DIMENSION) return\n            const clickPosition = Math.max(\n              INITIAL_DIMENSION,\n              Math.min(availableTrack, locationX - thumbPixelWidth / HALF_DIVISOR)\n            )\n            const targetX = (clickPosition / availableTrack) * scrollMax\n            if (scrollRef.current) {\n              scrollRef.current.scrollTo({ x: targetX, animated: true })\n            }\n          })\n        }\n      },\n      [scrollMax, thumbWidthPercent]\n    )\n\n    const handleContainerRef = React.useCallback(\n      (node) => {\n        scrollContainerRef.current = node\n        if (typeof ref === 'function') ref(node)\n        else if (ref) Object.assign(ref, { current: node })\n      },\n      [ref]\n    )\n\n    return (\n      <View\n        ref={handleContainerRef}\n        style={staticStyles.container}\n        {...selectContainerA11yProps({\n          accessibilityLabel: resolvedAccessibilityLabel,\n          descriptionId,\n          handleKeyDown\n        })}\n        {...selectProps(rest)}\n      >\n        <A11yText text={getCopy('instructionText')} nativeID={descriptionId} />\n        <View style={staticStyles.scrollContainer}>\n          <ScrollViewEnd\n            ref={scrollRef}\n            horizontal\n            onScrollEnd={handleScroll}\n            onScroll={handleScroll}\n            onContentSizeChange={handleContentWidth}\n            onLayout={handleContainerLayout}\n            showsHorizontalScrollIndicator={false}\n            contentContainerStyle={[staticStyles.scrollContent, selectScrollContentStyle(itemGap)]}\n          >\n            <ScrollProvider\n              itemWidth={itemWidth}\n              itemHeight={itemHeight}\n              onItemLayout={handleItemLayout}\n            >\n              {children}\n            </ScrollProvider>\n          </ScrollViewEnd>\n        </View>\n        {scrollMax > INITIAL_DIMENSION && (\n          <Pressable\n            ref={pressableRef}\n            style={[staticStyles.pressable, selectPressableStyles(defaultTokens)]}\n            onPress={handleProgressPress}\n          >\n            {(pressableState) => (\n              <ScrollProgress\n                ref={thumbRef}\n                pressableState={pressableState}\n                getTokens={getTokens}\n                thumbWrapperStyle={thumbWrapperStyle}\n                getCopy={getCopy}\n              />\n            )}\n          </Pressable>\n        )}\n      </View>\n    )\n  }\n)\n\nScroll.displayName = 'Scroll'\n\nScroll.propTypes = {\n  ...selectedSystemPropTypes,\n  /**\n   * Scroll items to display. Should be `ScrollItem` components.\n   */\n  children: PropTypes.node.isRequired,\n  /**\n   * Theme tokens for customizing the Scroll appearance\n   */\n  tokens: getTokensPropType('Scroll'),\n  /**\n   * Variant for the Scroll component\n   */\n  variant: variantProp.propType,\n  /**\n   * Select English or French copy for accessible labels.\n   */\n  copy: copyPropTypes,\n  /**\n   * Override the default dictionary by passing the complete dictionary object for `en` and `fr`.\n   */\n  dictionary: PropTypes.shape({\n    en: PropTypes.object,\n    fr: PropTypes.object\n  }),\n  /**\n   * Accessibility label for the scrollable region\n   */\n  accessibilityLabel: PropTypes.string\n}\n\nconst staticStyles = StyleSheet.create({\n  container: {\n    width: '100%'\n  },\n  scrollContainer: {\n    width: '100%'\n  },\n  pressable: {\n    justifyContent: 'center',\n    width: '100%'\n  },\n  scrollContent: {\n    alignSelf: 'flex-start',\n    flexGrow: 1\n  },\n  thumbWrapper: {\n    height: '100%'\n  },\n  thumbCursor: {\n    cursor: 'grab'\n  }\n})\n"],"mappings":"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","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/bc/colors_bcceb3480498c294db60fef610a0af87

@@ -0,0 +1,9 @@
+24fc180f8b3524d63c492a4f7e519bb4
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BrushProperties = void 0;
+var BrushProperties = exports.BrushProperties = ['fill', 'stroke', 'stopColor', 'floodColor', 'lightingColor'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCcnVzaFByb3BlcnRpZXMiLCJleHBvcnRzIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9leHRyYWN0L2NvbG9ycy50cyJdLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQ08sSUFBTUEsZUFBZSxHQUFBQyxPQUFBLENBQUFELGVBQUEsR0FBRyxDQUM3QixNQUFNLEVBQ04sUUFBUSxFQUNSLFdBQVcsRUFDWCxZQUFZLEVBQ1osZUFBZSxDQUNoQiIsImlnbm9yZUxpc3QiOltdfQ==

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/bc/colors_bcceb3480498c294db60fef610a0af87.map

@@ -0,0 +1 @@
+{"version":3,"names":["BrushProperties","exports"],"sources":["../../../../src/lib/extract/colors.ts"],"sourcesContent":[null],"mappings":";;;;;;AACO,IAAMA,eAAe,GAAAC,OAAA,CAAAD,eAAA,GAAG,CAC7B,MAAM,EACN,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,eAAe,CAChB","ignoreList":[]}